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 55092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor TDF_TopLevelParameterTypeList = 0x10, 56092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor /// \brief Within template argument deduction from overload resolution per 57092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor /// C++ [over.over] allow matching function types that are compatible in 58092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor /// terms of noreturn and default calling convention adjustments. 59092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor TDF_InOverloadResolution = 0x20 60508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor }; 61508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor} 62508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 630b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregorusing namespace clang; 640b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 659d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// \brief Compare two APSInts, extending and switching the sign as 669d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// necessary to compare their values regardless of underlying type. 679d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregorstatic bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { 689d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (Y.getBitWidth() > X.getBitWidth()) 699f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad X = X.extend(Y.getBitWidth()); 709d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor else if (Y.getBitWidth() < X.getBitWidth()) 719f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad Y = Y.extend(X.getBitWidth()); 729d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 739d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If there is a signedness mismatch, correct it. 749d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (X.isSigned() != Y.isSigned()) { 759d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If the signed value is negative, then the values cannot be the same. 769d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) 779d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return false; 789d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 799d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Y.setIsSigned(true); 809d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor X.setIsSigned(true); 819d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor } 829d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 839d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return X == Y; 849d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor} 859d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 86f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 87a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 88f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 89f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 9077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor TemplateArgument Arg, 912a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 921310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced); 93d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 94b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \brief Whether template argument deduction for two reference parameters 95b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// resulted in the argument type, parameter type, or neither type being more 96b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// qualified than the other. 97dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumienum DeductionQualifierComparison { 98dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NeitherMoreQualified = 0, 99dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ParamMoreQualified, 100dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ArgMoreQualified 1015c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor}; 1025c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 103b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \brief Stores the result of comparing two reference parameters while 104b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// performing template argument deduction for partial ordering of function 105dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// templates. 106b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregorstruct RefParamPartialOrderingComparison { 107b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the parameter type is an rvalue reference type. 108b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor bool ParamIsRvalueRef; 109b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the argument type is an rvalue reference type. 110b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor bool ArgIsRvalueRef; 111dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 112b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the parameter or argument (or neither) is more qualified. 113b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor DeductionQualifierComparison Qualifiers; 114b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor}; 115b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 116b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 1175c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 11820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 119bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian RedlDeduceTemplateArgumentsByTypeMatch(Sema &S, 120bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateParameterList *TemplateParams, 121bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType Param, 122bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType Arg, 123bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateDeductionInfo &Info, 124bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<DeducedTemplateArgument> & 125bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Deduced, 126bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl unsigned TDF, 127bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool PartialOrdering = false, 128bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<RefParamPartialOrderingComparison> * 129b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons = 0); 130603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 131603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 132603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 133603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 13420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 13520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 13620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 137030a6644f253818b81b4d8a7fc1770c0a3d35474Richard Smith SmallVectorImpl<DeducedTemplateArgument> &Deduced); 13820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 139199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \brief If the given expression is of a form that permits the deduction 140199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// of a non-type template parameter, return the declaration of that 141199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// non-type template parameter. 142199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregorstatic NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { 1435a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith // If we are within an alias template, the expression may have undergone 1445a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith // any number of parameter substitutions already. 1455a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith while (1) { 1465a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E)) 1475a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith E = IC->getSubExpr(); 1485a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith else if (SubstNonTypeTemplateParmExpr *Subst = 1495a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith dyn_cast<SubstNonTypeTemplateParmExpr>(E)) 1505a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith E = Subst->getReplacement(); 1515a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith else 1525a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith break; 1535a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith } 1541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 155199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 156199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 1571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 158199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return 0; 159199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 160199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Determine whether two declaration pointers refer to the same 1620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// declaration. 1630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregorstatic bool isSameDeclaration(Decl *X, Decl *Y) { 1640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NX = dyn_cast<NamedDecl>(X)) 1650d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X = NX->getUnderlyingDecl(); 1660d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NY = dyn_cast<NamedDecl>(Y)) 1670d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y = NY->getUnderlyingDecl(); 168dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1690d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X->getCanonicalDecl() == Y->getCanonicalDecl(); 1700d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 1710d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1720d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Verify that the given, deduced template arguments are compatible. 1730d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// 1740d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \returns The deduced template argument, or a NULL template argument if 1750d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// the deduced template arguments were incompatible. 176dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic DeducedTemplateArgument 1770d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas GregorcheckDeducedTemplateArguments(ASTContext &Context, 1780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &X, 1790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &Y) { 1800d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // We have no deduction for one or both of the arguments; they're compatible. 1810d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (X.isNull()) 1820d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 1830d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.isNull()) 184dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return X; 1850d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1860d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor switch (X.getKind()) { 1870d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Null: 1880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm_unreachable("Non-deduced template arguments handled above"); 1890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Type: 1910d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If two template type arguments have the same type, they're compatible. 1920d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Type && 1930d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameType(X.getAsType(), Y.getAsType())) 1940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 195dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1960d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 197dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Integral: 1990d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a constant in one case and either a dependent expression or 2000d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration in another case, keep the integral constant. 2010d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If both are integral constants with the same value, keep that value. 2020d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression || 2030d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration || 2040d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor (Y.getKind() == TemplateArgument::Integral && 205855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()))) 206dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(X, 2070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.wasDeducedFromArrayBound() && 2080d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 2090d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2100d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2110d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 212dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2130d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Template: 2140d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Template && 2150d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) 2160d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 217dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2180d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 219dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(); 220a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 221a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 222a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor if (Y.getKind() == TemplateArgument::TemplateExpansion && 223dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), 224a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern())) 225a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return X; 226dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 227a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor // All other combinations are incompatible. 228dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(); 229a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 2300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Expression: 231dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If we deduced a dependent expression in one case and either an integral 232dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // constant or a declaration in another case, keep the integral constant 2330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // or declaration. 2340d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral || 2350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration) 2360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() && 2370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 238dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) { 2400d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // Compare the expressions for equality 2410d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm::FoldingSetNodeID ID1, ID2; 2420d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.getAsExpr()->Profile(ID1, Context, true); 2430d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getAsExpr()->Profile(ID2, Context, true); 2440d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (ID1 == ID2) 2450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2460d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 247dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2480d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 250dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2510d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Declaration: 2520d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and a dependent expression, keep the 2530d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration. 2540d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) 2550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 256dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and an integral constant, keep the 2580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // integral constant. 2590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral) 2600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 261dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced two declarations, make sure they they refer to the 2630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // same declaration. 2640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Declaration && 265d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && 266d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman X.isDeclForReferenceParam() == Y.isDeclForReferenceParam()) 267d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return X; 268d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 269d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // All other combinations are incompatible. 270d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return DeducedTemplateArgument(); 271d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 272d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: 273d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // If we deduced a null pointer and a dependent expression, keep the 274d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // null pointer. 275d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman if (Y.getKind() == TemplateArgument::Expression) 276d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return X; 277d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 278d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // If we deduced a null pointer and an integral constant, keep the 279d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // integral constant. 280d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman if (Y.getKind() == TemplateArgument::Integral) 281d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return Y; 282d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 283d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // If we deduced two null pointers, make sure they have the same type. 284d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman if (Y.getKind() == TemplateArgument::NullPtr && 285d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType())) 2860d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 287dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 290dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2910d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Pack: 2920d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() != TemplateArgument::Pack || 2930d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.pack_size() != Y.pack_size()) 2940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 295dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 296dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (TemplateArgument::pack_iterator XA = X.pack_begin(), 2970d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XAEnd = X.pack_end(), 2980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor YA = Y.pack_begin(); 2990d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XA != XAEnd; ++XA, ++YA) { 300dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (checkDeducedTemplateArguments(Context, 301dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), 302135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) 303135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor .isNull()) 3040d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 3050d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 306dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 3080d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 309dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3103026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 3110d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 3120d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 3131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 314199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given constant. 315f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 316a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 3171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP, 3189d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor llvm::APSInt Value, QualType ValueType, 31902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor bool DeducedFromArrayBound, 3202a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 3215f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 3221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 323199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 3241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 325855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType, 326855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer DeducedFromArrayBound); 327dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3280d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 3290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 331f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = NTTP; 332f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 334dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 335f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 336dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 338f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 339199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 340199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 3411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 342199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given type- or value-dependent expression. 343199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// 344199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \returns true if deduction succeeded, false otherwise. 345f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 346a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 347f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor NonTypeTemplateParmDecl *NTTP, 348f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Expr *Value, 3492a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 3505f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 3511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 352199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 353199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert((Value->isTypeDependent() || Value->isValueDependent()) && 354199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Expression template argument must be type- or value-dependent."); 3551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3560d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(Value); 357dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 358dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Deduced[NTTP->getIndex()], 3590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 360dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 365dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 3669eea08ba72f8b1e7faf38e43376b9157fc4a2af2Douglas Gregor } 367dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3680d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 369f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 370199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 371199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 37215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \brief Deduce the value of the given non-type template parameter 37315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// from the given declaration. 37415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// 37515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \returns true if deduction succeeded, false otherwise. 37615755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregorstatic Sema::TemplateDeductionResult 377a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 378d82c0910f40d70a6a8beff66d854a53c1cdc44c6Craig Topper NonTypeTemplateParmDecl *NTTP, 379d82c0910f40d70a6a8beff66d854a53c1cdc44c6Craig Topper ValueDecl *D, 380d82c0910f40d70a6a8beff66d854a53c1cdc44c6Craig Topper TemplateDeductionInfo &Info, 381d82c0910f40d70a6a8beff66d854a53c1cdc44c6Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 38215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor assert(NTTP->getDepth() == 0 && 38315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor "Cannot deduce non-type template argument with depth > 0"); 384dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 385d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : 0; 386d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman TemplateArgument New(D, NTTP->getType()->isReferenceType()); 387d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman DeducedTemplateArgument NewDeduced(New); 388dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 3900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3910d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3920d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3930d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 395dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 39615755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor } 397dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 39915755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor return Sema::TDK_Success; 40015755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor} 40115755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 402f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 403a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 404db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParameterList *TemplateParams, 405f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Param, 406f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Arg, 4072a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 408d82c0910f40d70a6a8beff66d854a53c1cdc44c6Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 409d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); 410db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (!ParamDecl) { 411db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // The parameter type is dependent and is not a template template parameter, 412db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // so there is nothing that we can deduce. 413db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 414f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 415dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 416db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (TemplateTemplateParmDecl *TempParam 417db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) { 4180d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); 419dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 4200d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()], 4210d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 4220d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 4230d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = TempParam; 4240d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[TempParam->getIndex()]; 4250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 426dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 427db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor } 428dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()] = Result; 430dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Success; 431f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 432dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 433db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Verify that the two template names are equivalent. 434a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (S.Context.hasSameTemplateName(Param, Arg)) 435db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 436dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 437db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Mismatch of non-dependent template parameter to argument. 438db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.FirstArg = TemplateArgument(Param); 439db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.SecondArg = TemplateArgument(Arg); 440db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_NonDeducedMismatch; 441d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor} 442d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 4431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the template arguments by comparing the template parameter 444de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// type (which is a template-id) with the template argument type. 445de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 446a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the Sema 447de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 448de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param TemplateParams the template parameters that we are deducing 449de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 450de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Param the parameter type 451de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 452de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Arg the argument type 453de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 454de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Info information about the template argument deduction itself 455de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 456de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Deduced the deduced template arguments 457de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 458de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 459de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 460de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// but it may still fail, later, for other reasons. 461de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregorstatic Sema::TemplateDeductionResult 462a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 463de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateParameterList *TemplateParams, 464de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const TemplateSpecializationType *Param, 465de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType Arg, 4662a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 4671310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 468467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Arg.isCanonical() && "Argument type must be canonical"); 4691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 470de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Check whether the template argument is a dependent template-id. 4711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *SpecArg 472de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<TemplateSpecializationType>(Arg)) { 473de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 474de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 475a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 476de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 477de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor SpecArg->getTemplateName(), 478de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 479de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 4801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 482de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction on each template 4830972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // argument. Ignore any missing/extra arguments, since they could be 4840972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // filled in by default arguments. 485dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 486dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Param->getArgs(), Param->getNumArgs(), 4870972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor SpecArg->getArgs(), SpecArg->getNumArgs(), 488030a6644f253818b81b4d8a7fc1770c0a3d35474Richard Smith Info, Deduced); 489de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 4901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 491de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If the argument type is a class template specialization, we 492de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // perform template argument deduction using its template 493de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // arguments. 494de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *RecordArg = dyn_cast<RecordType>(Arg); 49529805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith if (!RecordArg) { 49629805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith Info.FirstArg = TemplateArgument(QualType(Param, 0)); 49729805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith Info.SecondArg = TemplateArgument(Arg); 498de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 49929805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith } 5001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ClassTemplateSpecializationDecl *SpecArg 502de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl()); 50329805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith if (!SpecArg) { 50429805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith Info.FirstArg = TemplateArgument(QualType(Param, 0)); 50529805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith Info.SecondArg = TemplateArgument(Arg); 506de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 50729805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith } 5081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 509de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 510de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 511a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, 512db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParams, 513de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 514de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateName(SpecArg->getSpecializedTemplate()), 515de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 516de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 5171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 51820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Perform template argument deduction for the template arguments. 519dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 52020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Param->getArgs(), Param->getNumArgs(), 52120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().data(), 52220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().size(), 52320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 524de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor} 525de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 526cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// \brief Determines whether the given type is an opaque type that 527cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// might be more qualified when instantiated. 528cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCallstatic bool IsPossiblyOpaquelyQualifiedType(QualType T) { 529cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall switch (T->getTypeClass()) { 530cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOfExpr: 531cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOf: 532cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentName: 533cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::Decltype: 534cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::UnresolvedUsing: 53562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall case Type::TemplateTypeParm: 536cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return true; 537cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 538cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::ConstantArray: 539cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::IncompleteArray: 540cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::VariableArray: 541cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentSizedArray: 542cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return IsPossiblyOpaquelyQualifiedType( 543cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall cast<ArrayType>(T)->getElementType()); 544cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 545cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall default: 546cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return false; 547cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } 548cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall} 549cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 550d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor/// \brief Retrieve the depth and index of a template parameter. 551dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic std::pair<unsigned, unsigned> 552d3731198193eee92796ddeb493973b7a598b003eDouglas GregorgetDepthAndIndex(NamedDecl *ND) { 553603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) 554603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 555dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 556603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) 557603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); 558dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 559603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); 560603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 561603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 562603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 563d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor/// \brief Retrieve the depth and index of an unexpanded parameter pack. 564dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic std::pair<unsigned, unsigned> 565d3731198193eee92796ddeb493973b7a598b003eDouglas GregorgetDepthAndIndex(UnexpandedParameterPack UPP) { 566d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (const TemplateTypeParmType *TTP 567d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor = UPP.first.dyn_cast<const TemplateTypeParmType *>()) 568d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 569dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 570d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor return getDepthAndIndex(UPP.first.get<NamedDecl *>()); 571d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor} 572d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 573603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Helper function to build a TemplateParameter when we don't 574603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// know its type statically. 575603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic TemplateParameter makeTemplateParameter(Decl *D) { 576603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D)) 577603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(TTP); 578cb9186e45c01dcf372d0ff708006daf194bf7d68Craig Topper if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) 579603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(NTTP); 580dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 581603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(cast<TemplateTemplateParmDecl>(D)); 582603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 583603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 58470d214f864987a06b27a92a2bd59df50037815f5Craig Toppertypedef SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2> 58570d214f864987a06b27a92a2bd59df50037815f5Craig Topper NewlyDeducedPacksType; 58670d214f864987a06b27a92a2bd59df50037815f5Craig Topper 5875429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor/// \brief Prepare to perform template argument deduction for all of the 5885429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor/// arguments in a set of argument packs. 58970d214f864987a06b27a92a2bd59df50037815f5Craig Topperstatic void 59070d214f864987a06b27a92a2bd59df50037815f5Craig TopperPrepareArgumentPackDeduction(Sema &S, 59170d214f864987a06b27a92a2bd59df50037815f5Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced, 59270d214f864987a06b27a92a2bd59df50037815f5Craig Topper ArrayRef<unsigned> PackIndices, 59370d214f864987a06b27a92a2bd59df50037815f5Craig Topper SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, 59470d214f864987a06b27a92a2bd59df50037815f5Craig Topper NewlyDeducedPacksType &NewlyDeducedPacks) { 5955429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // Save the deduced template arguments for each parameter pack expanded 5965429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // by this pack expansion, then clear out the deduction. 5975429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 5985429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // Save the previously-deduced argument pack, then clear it out so that we 5995429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // can deduce a new argument pack. 6005429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor SavedPacks[I] = Deduced[PackIndices[I]]; 601dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Deduced[PackIndices[I]] = TemplateArgument(); 602dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 603a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith if (!S.CurrentInstantiationScope) 604a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith continue; 605a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith 6066964b3f80ce1ba489e7e25e7cd58062699af9b0cRichard Smith // If the template argument pack was explicitly specified, add that to 6075429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // the set of deduced arguments. 6085429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor const TemplateArgument *ExplicitArgs; 6095429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor unsigned NumExplicitArgs; 610dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NamedDecl *PartiallySubstitutedPack 6115429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor = S.CurrentInstantiationScope->getPartiallySubstitutedPack( 6125429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor &ExplicitArgs, 6135429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor &NumExplicitArgs)) { 6145429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I]) 615dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks[I].append(ExplicitArgs, 6165429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor ExplicitArgs + NumExplicitArgs); 6175429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor } 6185429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor } 6195429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor} 6205429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor 6210216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// \brief Finish template argument deduction for a set of argument packs, 6220216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// producing the argument packs and checking for consistency with prior 6230216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// deductions. 6240216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregorstatic Sema::TemplateDeductionResult 6250216f8121df32b320cab659d5b703fee50cdfda5Douglas GregorFinishArgumentPackDeduction(Sema &S, 62670d214f864987a06b27a92a2bd59df50037815f5Craig Topper TemplateParameterList *TemplateParams, 62770d214f864987a06b27a92a2bd59df50037815f5Craig Topper bool HasAnyArguments, 62870d214f864987a06b27a92a2bd59df50037815f5Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced, 62970d214f864987a06b27a92a2bd59df50037815f5Craig Topper ArrayRef<unsigned> PackIndices, 63070d214f864987a06b27a92a2bd59df50037815f5Craig Topper SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, 63170d214f864987a06b27a92a2bd59df50037815f5Craig Topper NewlyDeducedPacksType &NewlyDeducedPacks, 63270d214f864987a06b27a92a2bd59df50037815f5Craig Topper TemplateDeductionInfo &Info) { 6330216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 6340216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // pack expansion. 6350216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 6360216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { 6370216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // We were not able to deduce anything for this parameter pack, 6380216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // so just restore the saved argument pack. 6390216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced[PackIndices[I]] = SavedPacks[I]; 6400216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor continue; 6410216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 642dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6430216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor DeducedTemplateArgument NewPack; 644dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6450216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (NewlyDeducedPacks[I].empty()) { 6460216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // If we deduced an empty argument pack, create it now. 647d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); 6480216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } else { 6490216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateArgument *ArgumentPack 650203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; 6510216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), 6520216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor ArgumentPack); 6530216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewPack 654203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor = DeducedTemplateArgument(TemplateArgument(ArgumentPack, 655203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor NewlyDeducedPacks[I].size()), 656dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); 6570216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 658dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6590216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor DeducedTemplateArgument Result 6600216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); 6610216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Result.isNull()) { 6620216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.Param 6630216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); 6640216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.FirstArg = SavedPacks[I]; 6650216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.SecondArg = NewPack; 6660216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Sema::TDK_Inconsistent; 6670216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 668dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6690216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced[PackIndices[I]] = Result; 6700216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 671dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6720216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Sema::TDK_Success; 6730216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor} 6740216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 675603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Deduce the template arguments by comparing the list of parameter 676dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// types to the list of argument types, as in the parameter-type-lists of 677dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// function types (C++ [temp.deduct.type]p10). 678603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 679603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param S The semantic analysis object within which we are deducing 680603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 681603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TemplateParams The template parameters that we are deducing 682603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 683603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Params The list of parameter types 684603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 685603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumParams The number of types in \c Params 686603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 687603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Args The list of argument types 688603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 689603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumArgs The number of types in \c Args 690603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 691603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Info information about the template argument deduction itself 692603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 693603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Deduced the deduced template arguments 694603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 695603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 696603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// how template argument deduction is performed. 697603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 6985c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param PartialOrdering If true, we are performing template argument 699dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// deduction for during partial ordering for a call 7005c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// (C++0x [temp.deduct.partial]). 7015c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 702b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \param RefParamComparisons If we're performing template argument deduction 7035c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering, the set of qualifier comparisons. 7045c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 705603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 706603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 707603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// but it may still fail, later, for other reasons. 708603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 709603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 710603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 711603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Params, unsigned NumParams, 712603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Args, unsigned NumArgs, 713603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateDeductionInfo &Info, 714d82c0910f40d70a6a8beff66d854a53c1cdc44c6Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced, 7155c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned TDF, 7165c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool PartialOrdering = false, 7175f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<RefParamPartialOrderingComparison> * 718b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons = 0) { 7190bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor // Fast-path check to see if we have too many/too few arguments. 7200bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor if (NumParams != NumArgs && 7210bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) && 7220bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1]))) 72329805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith return Sema::TDK_MiscellaneousDeductionFailure; 724dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 725603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 726dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Similarly, if P has a form that contains (T), then each parameter type 727dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Pi of the respective parameter-type- list of P is compared with the 728dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // corresponding parameter type Ai of the corresponding parameter-type-list 729dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // of A. [...] 730603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 731603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ParamIdx != NumParams; ++ParamIdx) { 732603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Check argument types. 733dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const PackExpansionType *Expansion 734603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = dyn_cast<PackExpansionType>(Params[ParamIdx]); 735603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!Expansion) { 736603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Simple case: compare the parameter and argument types at this point. 737dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 738603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we have an argument. 739603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx >= NumArgs) 74029805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith return Sema::TDK_MiscellaneousDeductionFailure; 741dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 74277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (isa<PackExpansionType>(Args[ArgIdx])) { 74377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // C++0x [temp.deduct.type]p22: 74477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the original function parameter associated with A is a function 74577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // parameter pack and the function parameter associated with P is not 74677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // a function parameter pack, then template argument deduction fails. 74729805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith return Sema::TDK_MiscellaneousDeductionFailure; 74877d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor } 749dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 750603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Sema::TemplateDeductionResult Result 751bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 752bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Params[ParamIdx], Args[ArgIdx], 753bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF, 754bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PartialOrdering, 755bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 756603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 757dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 758603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor ++ArgIdx; 759603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor continue; 760603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 761dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 7627d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // C++0x [temp.deduct.type]p5: 7637d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // The non-deduced contexts are: 764dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - A function parameter pack that does not occur at the end of the 7657d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // parameter-declaration-clause. 7667d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor if (ParamIdx + 1 < NumParams) 7677d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor return Sema::TDK_Success; 7687d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor 769603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 770dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the parameter-declaration corresponding to Pi is a function 771603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter pack, then the type of its declarator- id is compared with 772dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // each remaining parameter type in the parameter-type-list of A. Each 773603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // comparison deduces template arguments for subsequent positions in the 774603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // template parameter packs expanded by the function parameter pack. 775dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 776603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Compute the set of template parameter indices that correspond to 777603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter packs expanded by the pack expansion. 7785f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 779603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Pattern = Expansion->getPattern(); 780603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor { 781013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 7825f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 783603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 784603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 785603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned Depth, Index; 786603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 787603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 788603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor SawIndices[Index] = true; 789603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor PackIndices.push_back(Index); 790603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 791603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 792603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 793603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 794603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 795d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Keep track of the deduced template arguments for each parameter pack 796dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 797d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template argument (the inner SmallVectors). 79870d214f864987a06b27a92a2bd59df50037815f5Craig Topper NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); 7995f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 8005429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor SavedPacks(PackIndices.size()); 801dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, 8025429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 803dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 804603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor bool HasAnyArguments = false; 805603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ArgIdx < NumArgs; ++ArgIdx) { 806603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor HasAnyArguments = true; 807dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 808603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Deduce template arguments from the pattern. 809dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (Sema::TemplateDeductionResult Result 810bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, 811bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Args[ArgIdx], Info, Deduced, 812bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TDF, PartialOrdering, 813bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 814603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 815dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 816603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 817603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 818603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // for that pack, then clear out the deduced argument. 819603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 820603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 821603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!DeducedArg.isNull()) { 822603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 823603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedArg = DeducedTemplateArgument(); 824603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 825603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 826603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 827dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 828603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 829603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // pack expansion. 8300216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 831dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, 8320216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 8330216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 834dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 835603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 836dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 837603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we don't have any extra arguments. 838603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx < NumArgs) 83929805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith return Sema::TDK_MiscellaneousDeductionFailure; 840dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 841603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Sema::TDK_Success; 842603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 843603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 84461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor/// \brief Determine whether the parameter has qualifiers that are either 84561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor/// inconsistent with or a superset of the argument's qualifiers. 84661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregorstatic bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, 84761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor QualType ArgType) { 84861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ParamQs = ParamType.getQualifiers(); 84961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ArgQs = ArgType.getQualifiers(); 85061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 85161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs == ArgQs) 85261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return false; 85361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 85461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Mismatched (but not missing) Objective-C GC attributes. 85561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && 85661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ParamQs.hasObjCGCAttr()) 85761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return true; 85861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 85961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Mismatched (but not missing) address spaces. 86061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() && 86161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ParamQs.hasAddressSpace()) 86261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return true; 86361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 864f85e193739c953358c865005855253af4f68a497John McCall // Mismatched (but not missing) Objective-C lifetime qualifiers. 865f85e193739c953358c865005855253af4f68a497John McCall if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() && 866f85e193739c953358c865005855253af4f68a497John McCall ParamQs.hasObjCLifetime()) 867f85e193739c953358c865005855253af4f68a497John McCall return true; 868f85e193739c953358c865005855253af4f68a497John McCall 86961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // CVR qualifier superset. 87061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) && 87161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers()) 87261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor == ParamQs.getCVRQualifiers()); 87361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor} 87461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 875092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor/// \brief Compare types for equality with respect to possibly compatible 876092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor/// function types (noreturn adjustment, implicit calling conventions). If any 877092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor/// of parameter and argument is not a function, just perform type comparison. 878092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor/// 879092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor/// \param Param the template parameter type. 880092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor/// 881092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor/// \param Arg the argument type. 882092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregorbool Sema::isSameOrCompatibleFunctionType(CanQualType Param, 883092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor CanQualType Arg) { 884092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor const FunctionType *ParamFunction = Param->getAs<FunctionType>(), 885092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor *ArgFunction = Arg->getAs<FunctionType>(); 886092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor 887092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor // Just compare if not functions. 888092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor if (!ParamFunction || !ArgFunction) 889092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor return Param == Arg; 890092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor 891092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor // Noreturn adjustment. 892092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor QualType AdjustedParam; 893092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor if (IsNoReturnConversion(Param, Arg, AdjustedParam)) 894092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor return Arg == Context.getCanonicalType(AdjustedParam); 895092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor 896092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor // FIXME: Compatible calling conventions. 897092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor 898092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor return Param == Arg; 899092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor} 900092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor 901500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \brief Deduce the template arguments by comparing the parameter type and 902500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// the argument type (C++ [temp.deduct.type]). 903500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 904a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the semantic analysis object within which we are deducing 905500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 906500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param TemplateParams the template parameters that we are deducing 907500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 908500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ParamIn the parameter type 909500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 910500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ArgIn the argument type 911500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 912500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Info information about the template argument deduction itself 913500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 914500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Deduced the deduced template arguments 915500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 916508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 9171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// how template argument deduction is performed. 918500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 9195c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param PartialOrdering Whether we're performing template argument deduction 9205c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering (C++0x [temp.deduct.partial]). 9215c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 922b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \param RefParamComparisons If we're performing template argument deduction 9235c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering, the set of qualifier comparisons. 9245c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 925500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \returns the result of template argument deduction so far. Note that a 926500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// "success" result means that template argument deduction has not yet failed, 927500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// but it may still fail, later, for other reasons. 928f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 929bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian RedlDeduceTemplateArgumentsByTypeMatch(Sema &S, 930bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateParameterList *TemplateParams, 931bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType ParamIn, QualType ArgIn, 932bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateDeductionInfo &Info, 933bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<DeducedTemplateArgument> &Deduced, 934bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl unsigned TDF, 935bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool PartialOrdering, 936bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<RefParamPartialOrderingComparison> * 937bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons) { 9380b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // We only want to look at the canonical types, since typedefs and 9390b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // sugar are not part of template argument deduction. 940a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Param = S.Context.getCanonicalType(ParamIn); 941a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Arg = S.Context.getCanonicalType(ArgIn); 9420b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 94377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the argument type is a pack expansion, look at its pattern. 944dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // This isn't explicitly called out 94577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (const PackExpansionType *ArgExpansion 94677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor = dyn_cast<PackExpansionType>(Arg)) 94777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Arg = ArgExpansion->getPattern(); 948dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 9495c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (PartialOrdering) { 9505c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p5: 951dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Before the partial ordering is done, certain transformations are 952dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // performed on the types used for partial ordering: 953dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If P is a reference type, P is replaced by the type referred to. 9545c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor const ReferenceType *ParamRef = Param->getAs<ReferenceType>(); 9555c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (ParamRef) 9565c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = ParamRef->getPointeeType(); 957dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 9585c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If A is a reference type, A is replaced by the type referred to. 9595c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor const ReferenceType *ArgRef = Arg->getAs<ReferenceType>(); 9605c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (ArgRef) 9615c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Arg = ArgRef->getPointeeType(); 962dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 963b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (RefParamComparisons && ParamRef && ArgRef) { 9645c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p6: 965dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If both P and A were reference types (before being replaced with the 966dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // type referred to above), determine which of the two types (if any) is 9675c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // more cv-qualified than the other; otherwise the types are considered 968dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // to be equally cv-qualified for partial ordering purposes. The result 9695c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // of this determination will be used below. 9705c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // 971dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // We save this information for later, using it only when deduction 9725c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // succeeds in both directions. 973b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamPartialOrderingComparison Comparison; 974b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.ParamIsRvalueRef = ParamRef->getAs<RValueReferenceType>(); 975b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.ArgIsRvalueRef = ArgRef->getAs<RValueReferenceType>(); 976b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = NeitherMoreQualified; 977769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor 978769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor Qualifiers ParamQuals = Param.getQualifiers(); 979769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor Qualifiers ArgQuals = Arg.getQualifiers(); 980769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor if (ParamQuals.isStrictSupersetOf(ArgQuals)) 981b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = ParamMoreQualified; 982769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor else if (ArgQuals.isStrictSupersetOf(ParamQuals)) 983b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = ArgMoreQualified; 984b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons->push_back(Comparison); 9855c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } 986dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 9875c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p7: 9885c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // Remove any top-level cv-qualifiers: 989dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If P is a cv-qualified type, P is replaced by the cv-unqualified 9905c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // version of P. 9915c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = Param.getUnqualifiedType(); 992dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If A is a cv-qualified type, A is replaced by the cv-unqualified 9935c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // version of A. 9945c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Arg = Arg.getUnqualifiedType(); 9955c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } else { 9965c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.call]p4 bullet 1: 9975c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the type 9985c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // referred to by the reference) can be more cv-qualified than the 9995c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // transformed A. 10005c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (TDF & TDF_ParamWithReferenceType) { 10015c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Qualifiers Quals; 10025c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); 10035c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Quals.setCVRQualifiers(Quals.getCVRQualifiers() & 100462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Arg.getCVRQualifiers()); 10055c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = S.Context.getQualifiedType(UnqualParam, Quals); 10065c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } 1007dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 100873b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) { 100973b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // C++0x [temp.deduct.type]p10: 101073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // If P and A are function types that originated from deduction when 101173b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // taking the address of a function template (14.8.2.2) or when deducing 101273b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // template arguments from a function declaration (14.8.2.6) and Pi and 1013dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Ai are parameters of the top-level parameter-type-list of P and A, 1014dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // respectively, Pi is adjusted if it is an rvalue reference to a 1015dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // cv-unqualified template parameter and Ai is an lvalue reference, in 1016dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // which case the type of Pi is changed to be the template parameter 101773b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // type (i.e., T&& is changed to simply T). [ Note: As a result, when 101873b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be 10190099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // deduced as X&. - end note ] 102073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor TDF &= ~TDF_TopLevelParameterTypeList; 1021dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 102273b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (const RValueReferenceType *ParamRef 102373b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor = Param->getAs<RValueReferenceType>()) { 102473b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) && 102573b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor !ParamRef->getPointeeType().getQualifiers()) 102673b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (Arg->isLValueReferenceType()) 102773b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor Param = ParamRef->getPointeeType(); 102873b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor } 102973b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor } 1030500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor } 1031dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1032199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // C++ [temp.deduct.type]p9: 10331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // A template type argument T, a template template argument TT or a 10341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // template non-type argument i can be deduced if P and A have one of 1035199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // the following forms: 1036199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // 1037199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T 1038199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // cv-list T 10391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateTypeParmType *TemplateTypeParm 1040183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Param->getAs<TemplateTypeParmType>()) { 1041af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor // Just skip any attempts to deduce from a placeholder type. 1042af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor if (Arg->isPlaceholderType()) 1043af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor return Sema::TDK_Success; 1044af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor 1045f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor unsigned Index = TemplateTypeParm->getIndex(); 1046f290e0db835a619014538c41ed552696efc0e977Douglas Gregor bool RecanonicalizeArg = false; 10471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10489e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // If the argument type is an array type, move the qualifiers up to the 10499e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // top level, so they can be matched with the qualifiers on the parameter. 1050f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (isa<ArrayType>(Arg)) { 10510953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals; 1052a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); 10530953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Quals) { 1054a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getQualifiedType(Arg, Quals); 1055f290e0db835a619014538c41ed552696efc0e977Douglas Gregor RecanonicalizeArg = true; 1056f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 1057f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 10581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10590b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // The argument type can not be less qualified than the parameter 10600b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // type. 106161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (!(TDF & TDF_IgnoreQualifiers) && 106261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor hasInconsistentOrSupersetQualifiersOf(Param, Arg)) { 1063f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 106457e97786433e70197a089360228d8f0d82e3ad4cJohn McCall Info.FirstArg = TemplateArgument(Param); 1065833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(Arg); 106657e97786433e70197a089360228d8f0d82e3ad4cJohn McCall return Sema::TDK_Underqualified; 1067f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 10680b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 10690b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); 1070a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function"); 10710953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualType DeducedType = Arg; 107249f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall 107361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Remove any qualifiers on the parameter from the deduced type. 107461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // We checked the qualifiers for consistency above. 107561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers DeducedQs = DeducedType.getQualifiers(); 107661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ParamQs = Param.getQualifiers(); 107761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers()); 107861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.hasObjCGCAttr()) 107961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeObjCGCAttr(); 108061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.hasAddressSpace()) 108161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeAddressSpace(); 1082f85e193739c953358c865005855253af4f68a497John McCall if (ParamQs.hasObjCLifetime()) 1083f85e193739c953358c865005855253af4f68a497John McCall DeducedQs.removeObjCLifetime(); 1084e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor 1085e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // Objective-C ARC: 1086da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // If template deduction would produce a lifetime qualifier on a type 1087da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // that is not a lifetime type, template argument deduction fails. 1088da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() && 1089da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor !DeducedType->isDependentType()) { 1090da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 1091da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.FirstArg = TemplateArgument(Param); 1092da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.SecondArg = TemplateArgument(Arg); 1093da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor return Sema::TDK_Underqualified; 1094da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor } 1095da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor 1096da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // Objective-C ARC: 1097e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // If template deduction would produce an argument type with lifetime type 1098e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // but no lifetime qualifier, the __strong lifetime qualifier is inferred. 10994e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (S.getLangOpts().ObjCAutoRefCount && 1100e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor DeducedType->isObjCLifetimeType() && 1101e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor !DeducedQs.hasObjCLifetime()) 1102e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong); 1103e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor 110461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(), 110561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs); 110661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 1107f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (RecanonicalizeArg) 1108a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth DeducedType = S.Context.getCanonicalType(DeducedType); 11091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11100d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(DeducedType); 1111dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 11120d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index], 11130d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 11140d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 11150d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 11160d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[Index]; 11170d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 1118dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 11190b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 1120dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 11210d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index] = Result; 1122dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Success; 11230b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 11240b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1125f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // Set up the template argument deduction information for a failure. 1126833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.FirstArg = TemplateArgument(ParamIn); 1127833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(ArgIn); 1128f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 11290bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // If the parameter is an already-substituted template parameter 11300bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // pack, do nothing: we don't know which of its arguments to look 11310bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // at, so we have to wait until all of the parameter packs in this 11320bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // expansion have arguments. 11330bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor if (isa<SubstTemplateTypeParmPackType>(Param)) 11340bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor return Sema::TDK_Success; 11350bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor 1136508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // Check the cv-qualifiers on the parameter and argument types. 1137092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor CanQualType CanParam = S.Context.getCanonicalType(Param); 1138092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor CanQualType CanArg = S.Context.getCanonicalType(Arg); 1139508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (!(TDF & TDF_IgnoreQualifiers)) { 1140508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (TDF & TDF_ParamWithReferenceType) { 114161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (hasInconsistentOrSupersetQualifiersOf(Param, Arg)) 1142508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1143cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { 1144508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) 11451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Sema::TDK_NonDeducedMismatch; 1146508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 1147fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1148fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // If the parameter type is not dependent, there is nothing to deduce. 1149fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (!Param->isDependentType()) { 1150092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor if (!(TDF & TDF_SkipNonDependent)) { 1151092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor bool NonDeduced = (TDF & TDF_InOverloadResolution)? 1152092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor !S.isSameOrCompatibleFunctionType(CanParam, CanArg) : 1153092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor Param != Arg; 1154092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor if (NonDeduced) { 1155092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1156092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor } 1157092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor } 1158fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_Success; 1159fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1160092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor } else if (!Param->isDependentType()) { 1161092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor CanQualType ParamUnqualType = CanParam.getUnqualifiedType(), 1162092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor ArgUnqualType = CanArg.getUnqualifiedType(); 1163092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor bool Success = (TDF & TDF_InOverloadResolution)? 1164092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor S.isSameOrCompatibleFunctionType(ParamUnqualType, 1165092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor ArgUnqualType) : 1166092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor ParamUnqualType == ArgUnqualType; 1167092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor if (Success) 1168092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor return Sema::TDK_Success; 1169508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 11700b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1171d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor switch (Param->getTypeClass()) { 11724ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Non-canonical types cannot appear here. 11734ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) \ 11744ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class); 11754ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#define TYPE(Class, Base) 11764ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#include "clang/AST/TypeNodes.def" 11774ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 11784ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::TemplateTypeParm: 11794ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::SubstTemplateTypeParmPack: 11804ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor llvm_unreachable("Type nodes handled above"); 1181fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1182fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // These types cannot be dependent, so simply check whether the types are 1183fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // the same. 1184199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::Builtin: 11854ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::VariableArray: 11864ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Vector: 11874ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::FunctionNoProto: 11884ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Record: 11894ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Enum: 11904ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ObjCObject: 11914ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ObjCInterface: 1192fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor case Type::ObjCObjectPointer: { 1193fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (TDF & TDF_SkipNonDependent) 1194fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_Success; 1195fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1196fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (TDF & TDF_IgnoreQualifiers) { 1197fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Param = Param.getUnqualifiedType(); 1198fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Arg = Arg.getUnqualifiedType(); 1199fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1200fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1201fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch; 1202fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1203fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 12044ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // _Complex T [placeholder extension] 12054ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Complex: 12064ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>()) 1207bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 12084ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor cast<ComplexType>(Param)->getElementType(), 1209bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ComplexArg->getElementType(), 1210bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 12114ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 12124ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1213b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1214b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // _Atomic T [extension] 1215b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 1216b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>()) 1217bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1218b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman cast<AtomicType>(Param)->getValueType(), 1219b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicArg->getValueType(), 1220b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Info, Deduced, TDF); 1221b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1222b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return Sema::TDK_NonDeducedMismatch; 1223b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1224199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T * 1225d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::Pointer: { 1226c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall QualType PointeeType; 1227c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall if (const PointerType *PointerArg = Arg->getAs<PointerType>()) { 1228c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 1229c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else if (const ObjCObjectPointerType *PointerArg 1230c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall = Arg->getAs<ObjCObjectPointerType>()) { 1231c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 1232c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else { 1233f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1234c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } 12351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12364112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); 1237bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1238bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl cast<PointerType>(Param)->getPointeeType(), 1239c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType, 12404112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor Info, Deduced, SubTDF); 1241d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 12421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1243199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T & 1244d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::LValueReference: { 12456217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>(); 1246d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 1247f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1249bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1250d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<LValueReferenceType>(Param)->getPointeeType(), 1251bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ReferenceArg->getPointeeType(), Info, Deduced, 0); 1252d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 12530b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1254199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T && [C++0x] 1255d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::RValueReference: { 12566217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>(); 1257d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 1258f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1260bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1261bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl cast<RValueReferenceType>(Param)->getPointeeType(), 1262bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ReferenceArg->getPointeeType(), 1263bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1264d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 12651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1266199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [] (implied, but not stated explicitly) 12674d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::IncompleteArray: { 12681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const IncompleteArrayType *IncompleteArrayArg = 1269a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsIncompleteArrayType(Arg); 12704d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!IncompleteArrayArg) 1271f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1273e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1274bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1275bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl S.Context.getAsIncompleteArrayType(Param)->getElementType(), 1276bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl IncompleteArrayArg->getElementType(), 1277bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF); 12784d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 1279199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1280199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [integer-constant] 12814d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::ConstantArray: { 12821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayArg = 1283a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Arg); 12844d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!ConstantArrayArg) 1285f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayParm = 1288a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Param); 12894d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) 1290f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1292e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1293bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1294bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ConstantArrayParm->getElementType(), 1295bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ConstantArrayArg->getElementType(), 1296bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF); 12974d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 12984d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 1299199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // type [i] 1300199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::DependentSizedArray: { 1301a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); 1302199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!ArrayArg) 1303f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 13041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1305e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1306e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall 1307199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Check the element type of the arrays 1308199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor const DependentSizedArrayType *DependentArrayParm 1309a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = S.Context.getAsDependentSizedArrayType(Param); 1310f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1311bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1312bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl DependentArrayParm->getElementType(), 1313bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ArrayArg->getElementType(), 1314bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF)) 1315f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 13161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1317199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Determine the array bound is something we can deduce. 13181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP 1319199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); 1320199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!NTTP) 1321f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 13221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We can perform template argument deduction for the given non-type 1324199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // template parameter. 13251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 1326199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument at depth > 0"); 13271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ConstantArrayType *ConstantArrayArg 1328335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson = dyn_cast<ConstantArrayType>(ArrayArg)) { 1329335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson llvm::APSInt Size(ConstantArrayArg->getSize()); 1330dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceNonTypeTemplateArgument(S, NTTP, Size, 13319d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor S.Context.getSizeType(), 133202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/true, 1333f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1334335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson } 1335199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (const DependentSizedArrayType *DependentArrayArg 1336199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = dyn_cast<DependentSizedArrayType>(ArrayArg)) 133734c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor if (DependentArrayArg->getSizeExpr()) 133834c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, 133934c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor DependentArrayArg->getSizeExpr(), 134034c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor Info, Deduced); 13411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1342199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Incomplete type does not match a dependently-sized array type 1343f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1344199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 13451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(*)(T) 13471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)() 13481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)(T) 1349a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson case Type::FunctionProto: { 135073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList; 13511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoArg = 1352a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson dyn_cast<FunctionProtoType>(Arg); 1353a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson if (!FunctionProtoArg) 1354f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 13551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoParam = 1357a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson cast<FunctionProtoType>(Param); 1358994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 1359dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (FunctionProtoParam->getTypeQuals() 1360e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor != FunctionProtoArg->getTypeQuals() || 1361dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionProtoParam->getRefQualifier() 1362e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor != FunctionProtoArg->getRefQualifier() || 1363e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) 1364f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1365994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 1366a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson // Check return types. 1367f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1368bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1369bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FunctionProtoParam->getResultType(), 1370bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FunctionProtoArg->getResultType(), 1371bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0)) 1372f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 13731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1374603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return DeduceTemplateArguments(S, TemplateParams, 1375603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->arg_type_begin(), 1376603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->getNumArgs(), 1377603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->arg_type_begin(), 1378603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->getNumArgs(), 137973b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor Info, Deduced, SubTDF); 1380a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson } 13811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13823cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case Type::InjectedClassName: { 13833cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // Treat a template's injected-class-name as if the template 13843cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // specialization type had been used. 138531f17ecbef57b5679c017c375db330546b7b5145John McCall Param = cast<InjectedClassNameType>(Param) 138631f17ecbef57b5679c017c375db330546b7b5145John McCall ->getInjectedSpecializationType(); 13873cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<TemplateSpecializationType>(Param) && 13883cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall "injected class name is not a template specialization type"); 13893cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // fall through 13903cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 13913cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 1392f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // template-name<T> (where template-name refers to a class template) 1393d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // template-name<i> 1394db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<T> 1395db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<i> 1396db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<> 1397d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor case Type::TemplateSpecialization: { 1398d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor const TemplateSpecializationType *SpecParam 1399d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor = cast<TemplateSpecializationType>(Param); 14001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1401de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Try to deduce template arguments from the template-id. 1402de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult Result 1403a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, 1404de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced); 14051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14064a5c15f75f76b95e1c2ceb6fa2737dcadd5f4be1Douglas Gregor if (Result && (TDF & TDF_DerivedClass)) { 1407de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // C++ [temp.deduct.call]p3b3: 1408de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If P is a class, and P has the form template-id, then A can be a 1409de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // derived class of the deduced A. Likewise, if P is a pointer to a 14101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // class of the form template-id, A can be a pointer to a derived 1411de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // class pointed to by the deduced A. 1412de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // 1413de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // More importantly: 14141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // These alternatives are considered only if type deduction would 1415de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // otherwise fail. 1416a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (const RecordType *RecordT = Arg->getAs<RecordType>()) { 1417a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // We cannot inspect base classes as part of deduction when the type 1418a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // is incomplete, so either instantiate any templates necessary to 1419a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // complete the type, or skip over it if it cannot be completed. 14205769d6195087229770d7ac90449443e026c47103John McCall if (S.RequireCompleteType(Info.getLocation(), Arg, 0)) 1421a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return Result; 1422a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth 1423de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Use data recursion to crawl through the list of base classes. 14241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Visited contains the set of nodes we have already visited, while 1425de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // ToVisit is our stack of records that we still need to visit. 1426de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallPtrSet<const RecordType *, 8> Visited; 14275f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<const RecordType *, 8> ToVisit; 1428de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.push_back(RecordT); 1429de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor bool Successful = false; 143074fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(), 143174fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer Deduced.end()); 1432de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor while (!ToVisit.empty()) { 1433de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Retrieve the next class in the inheritance hierarchy. 1434de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *NextT = ToVisit.back(); 1435de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.pop_back(); 14361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1437de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If we have already seen this type, skip it. 1438de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!Visited.insert(NextT)) 1439de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor continue; 14401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1441de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If this is a base class, try to perform template argument 1442de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // deduction from it. 1443de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (NextT != RecordT) { 1444910515bc02872bd680e422f75079534d00093bc5Richard Trieu TemplateDeductionInfo BaseInfo(Info.getLocation()); 1445de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult BaseResult 1446a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, 1447910515bc02872bd680e422f75079534d00093bc5Richard Trieu QualType(NextT, 0), BaseInfo, 1448910515bc02872bd680e422f75079534d00093bc5Richard Trieu Deduced); 14491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1450de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If template argument deduction for this base was successful, 1451053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // note that we had some success. Otherwise, ignore any deductions 1452053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // from this base class. 1453053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor if (BaseResult == Sema::TDK_Success) { 1454de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Successful = true; 145574fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer DeducedOrig.clear(); 145674fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer DeducedOrig.append(Deduced.begin(), Deduced.end()); 1457910515bc02872bd680e422f75079534d00093bc5Richard Trieu Info.Param = BaseInfo.Param; 1458910515bc02872bd680e422f75079534d00093bc5Richard Trieu Info.FirstArg = BaseInfo.FirstArg; 1459910515bc02872bd680e422f75079534d00093bc5Richard Trieu Info.SecondArg = BaseInfo.SecondArg; 1460053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor } 1461053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor else 1462053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor Deduced = DeducedOrig; 1463de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 14641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1465de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Visit base classes 1466de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl()); 1467de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), 1468de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor BaseEnd = Next->bases_end(); 14699994a34f6cf842721ba7723edc0b9036229fe387Sebastian Redl Base != BaseEnd; ++Base) { 14701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(Base->getType()->isRecordType() && 1471de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor "Base class that isn't a record?"); 14726217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek ToVisit.push_back(Base->getType()->getAs<RecordType>()); 1473de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 1474de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 14751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1476de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Successful) 1477de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_Success; 1478de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 14791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1480de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 14811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1482de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 1483d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor } 1484d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 1485637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T type::* 1486637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T T::* 1487637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)() 1488637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)() 1489637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (type::*)(T) 1490637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)(T) 1491637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)(T) 1492637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)() 1493637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)(T) 1494637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::MemberPointer: { 1495637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param); 1496637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg); 1497637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor if (!MemPtrArg) 1498f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1499f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1500f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1501bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1502bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl MemPtrParam->getPointeeType(), 1503bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl MemPtrArg->getPointeeType(), 1504bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 1505bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TDF & TDF_IgnoreQualifiers)) 1506f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 1507f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1508bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1509bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType(MemPtrParam->getClass(), 0), 1510bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType(MemPtrArg->getClass(), 0), 1511fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Info, Deduced, 1512fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor TDF & TDF_IgnoreQualifiers); 1513637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor } 1514637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 15159a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // (clang extension) 15169a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // 15171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(^)(T) 15181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)() 15191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)(T) 1520859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson case Type::BlockPointer: { 1521859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param); 1522859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg); 15231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1524859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson if (!BlockPtrArg) 1525f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 15261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1527bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1528bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl BlockPtrParam->getPointeeType(), 1529bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl BlockPtrArg->getPointeeType(), 1530bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1531859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson } 1532859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson 15334ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // (clang extension) 15344ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // 15354ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // T __attribute__(((ext_vector_type(<integral constant>)))) 15364ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ExtVector: { 15374ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor const ExtVectorType *VectorParam = cast<ExtVectorType>(Param); 15384ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) { 15394ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Make sure that the vectors have the same number of elements. 15404ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (VectorParam->getNumElements() != VectorArg->getNumElements()) 15414ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 15424ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15434ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 1544bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1545bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1546bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1547bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 15484ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15494ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15504ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const DependentSizedExtVectorType *VectorArg 15514ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = dyn_cast<DependentSizedExtVectorType>(Arg)) { 15524ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // We can't check the number of elements, since the argument has a 15534ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // dependent number of elements. This can only occur during partial 15544ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // ordering. 15554ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15564ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 1557bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1558bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1559bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1560bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 15614ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15624ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15634ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 15644ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15654ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15664ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // (clang extension) 15674ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // 15684ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // T __attribute__(((ext_vector_type(N)))) 15694ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::DependentSizedExtVector: { 15704ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor const DependentSizedExtVectorType *VectorParam 15714ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = cast<DependentSizedExtVectorType>(Param); 15724ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15734ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) { 15744ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 15754ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (Sema::TemplateDeductionResult Result 1576bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1577bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1578bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1579bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 15804ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Result; 15814ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15824ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the vector size, if we can. 15834ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor NonTypeTemplateParmDecl *NTTP 15844ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); 15854ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (!NTTP) 15864ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_Success; 15874ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15884ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); 15894ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor ArgSize = VectorArg->getNumElements(); 15904ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy, 15914ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor false, Info, Deduced); 15924ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15934ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15944ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const DependentSizedExtVectorType *VectorArg 15954ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = dyn_cast<DependentSizedExtVectorType>(Arg)) { 15964ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 15974ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (Sema::TemplateDeductionResult Result 1598bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1599bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1600bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1601bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 16024ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Result; 16034ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 16044ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the vector size, if we can. 16054ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor NonTypeTemplateParmDecl *NTTP 16064ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); 16074ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (!NTTP) 16084ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_Success; 16094ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 16104ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(), 16114ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor Info, Deduced); 16124ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 16134ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 16144ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 16154ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 16164ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 1617637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOfExpr: 1618637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOf: 16194714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 16204ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::UnresolvedUsing: 16214ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Decltype: 16224ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::UnaryTransform: 16234ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Auto: 16244ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::DependentTemplateSpecialization: 16254ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::PackExpansion: 1626637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // No template argument deduction for these types 1627f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 16280b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 16290b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 16303026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid Type Class!"); 16310b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 16320b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1633f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 1634a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1635f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 1636f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 163777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor TemplateArgument Arg, 16382a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 16391310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 164077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the template argument is a pack expansion, perform template argument 164177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // deduction against the pattern of that expansion. This only occurs during 164277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // partial ordering. 164377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (Arg.isPackExpansion()) 164477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Arg = Arg.getPackExpansionPattern(); 1645dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 16460b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor switch (Param.getKind()) { 1647199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Null: 1648b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Null template argument in parameter list"); 16491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TemplateArgument::Type: 1651788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Type) 1652bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1653bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Param.getAsType(), 1654bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Arg.getAsType(), 1655bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1656788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1657788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1658788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1659a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1660788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1661db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (Arg.getKind() == TemplateArgument::Template) 1662dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 1663788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Param.getAsTemplate(), 1664db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Arg.getAsTemplate(), Info, Deduced); 1665788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1666788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1667788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1668a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1669a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1670a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor llvm_unreachable("caller should handle pack expansions"); 1671dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1672199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Declaration: 1673788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration && 1674d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) && 1675d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam()) 1676d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return Sema::TDK_Success; 1677d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 1678d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Info.FirstArg = Param; 1679d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Info.SecondArg = Arg; 1680d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return Sema::TDK_NonDeducedMismatch; 1681d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 1682d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: 1683d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman if (Arg.getKind() == TemplateArgument::NullPtr && 1684d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType())) 1685788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_Success; 1686dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1687f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1688f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1689f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 16901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1691199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Integral: 1692199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) { 1693855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral())) 1694f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1695f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1696f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1697f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1698f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1699f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 1700f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1701f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) { 1702f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1703f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1704f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1705199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1706199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1707f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1708f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1709f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 17101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1711199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Expression: { 17121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (NonTypeTemplateParmDecl *NTTP 1713199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(Param.getAsExpr())) { 1714199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) 1715a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, 1716855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer Arg.getAsIntegral(), 17179d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Arg.getIntegralType(), 171802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/false, 1719f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1720199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) 1721a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(), 1722f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 172315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration) 1724a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(), 172515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor Info, Deduced); 1726dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1727f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1728f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1729f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1730199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 17311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1732199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Can't deduce anything, but that's okay. 1733f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1734199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1735d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 173620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor llvm_unreachable("Argument packs should be expanded by the caller!"); 17370b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 17381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 17393026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 17400b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 17410b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 174220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \brief Determine whether there is a template argument to be used for 174320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// deduction. 174420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 174520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// This routine "expands" argument packs in-place, overriding its input 174620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// parameters so that \c Args[ArgIdx] will be the available template argument. 174720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 174820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \returns true if there is another template argument (which will be at 174920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \c Args[ArgIdx]), false otherwise. 1750dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args, 175120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &ArgIdx, 175220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &NumArgs) { 175320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (ArgIdx == NumArgs) 175420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return false; 1755dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 175620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 175720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Arg.getKind() != TemplateArgument::Pack) 175820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return true; 175920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 176020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?"); 176120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Args = Arg.pack_begin(); 176220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor NumArgs = Arg.pack_size(); 176320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgIdx = 0; 176420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return ArgIdx < NumArgs; 176520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 176620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 17677b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// \brief Determine whether the given set of template arguments has a pack 17687b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// expansion that is not the last template argument. 17697b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregorstatic bool hasPackExpansionBeforeEnd(const TemplateArgument *Args, 17707b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned NumArgs) { 17717b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned ArgIdx = 0; 17727b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor while (ArgIdx < NumArgs) { 17737b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 1774dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 17757b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // Unwrap argument packs. 17767b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Args[ArgIdx].getKind() == TemplateArgument::Pack) { 17777b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor Args = Arg.pack_begin(); 17787b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor NumArgs = Arg.pack_size(); 17797b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ArgIdx = 0; 17807b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor continue; 17817b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 1782dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 17837b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ++ArgIdx; 17847b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (ArgIdx == NumArgs) 17857b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 1786dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 17877b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Arg.isPackExpansion()) 17887b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return true; 17897b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 1790dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 17917b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 17927b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor} 17937b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 17941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic Sema::TemplateDeductionResult 1795a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1796f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 179720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 179820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 17992a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 1800030a6644f253818b81b4d8a7fc1770c0a3d35474Richard Smith SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 1801e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1802dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 1803dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 1804e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // non-deduced context. 18057b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (hasPackExpansionBeforeEnd(Params, NumParams)) 18067b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return Sema::TDK_Success; 1807dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1808e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1809dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If P has a form that contains <T> or <i>, then each argument Pi of the 1810dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // respective template argument list P is compared with the corresponding 1811e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // argument Ai of the corresponding template argument list of A. 181220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 1813dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); 181420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ParamIdx) { 181520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!Params[ParamIdx].isPackExpansion()) { 1816e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The simple case: deduce template arguments by matching Pi and Ai. 1817dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 181820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Check whether we have enough arguments. 181920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) 1820030a6644f253818b81b4d8a7fc1770c0a3d35474Richard Smith return Sema::TDK_Success; 1821dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 182277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (Args[ArgIdx].isPackExpansion()) { 182377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here, 182477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // but applied to pack expansions that are template arguments. 182529805ca6d278b4d9563adfee67f2478f0fecdcfcRichard Smith return Sema::TDK_MiscellaneousDeductionFailure; 182677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor } 1827dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1828e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Perform deduction for this Pi/Ai pair. 182920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Sema::TemplateDeductionResult Result 183077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor = DeduceTemplateArguments(S, TemplateParams, 183177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Params[ParamIdx], Args[ArgIdx], 183277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Info, Deduced)) 1833dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 1834dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 183520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Move to the next argument. 183620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ArgIdx; 183720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor continue; 183820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor } 1839dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1840e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The parameter is a pack expansion. 1841dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1842e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1843dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If Pi is a pack expansion, then the pattern of Pi is compared with 1844dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // each remaining argument in the template argument list of A. Each 1845dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // comparison deduces template arguments for subsequent positions in the 1846e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template parameter packs expanded by Pi. 1847e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); 1848dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1849e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Compute the set of template parameter indices that correspond to 1850e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // parameter packs expanded by the pack expansion. 18515f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 1852e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor { 1853013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 18545f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1855e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 1856e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 1857e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned Depth, Index; 1858e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 1859e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 1860e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SawIndices[Index] = true; 1861e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor PackIndices.push_back(Index); 1862e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1863e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1864e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1865e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 1866dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1867e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // FIXME: If there are no remaining arguments, we can bail out early 1868e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // and set any deduced parameter packs to an empty argument pack. 1869e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The latter part of this is a (minor) correctness issue. 1870dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1871e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Save the deduced template arguments for each parameter pack expanded 1872e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, then clear out the deduction. 18735f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 1874e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SavedPacks(PackIndices.size()); 187570d214f864987a06b27a92a2bd59df50037815f5Craig Topper NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); 1876dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, 18775429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 1878e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1879e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Keep track of the deduced template arguments for each parameter pack 1880dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 1881e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template argument (the inner SmallVectors). 1882e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor bool HasAnyArguments = false; 1883e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) { 1884e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor HasAnyArguments = true; 1885dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1886e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Deduce template arguments from the pattern. 1887dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (Sema::TemplateDeductionResult Result 1888e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], 1889e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info, Deduced)) 1890e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Result; 1891dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1892e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 1893e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 1894e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // for that pack, then clear out the deduced argument. 1895e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 1896e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 1897e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (!DeducedArg.isNull()) { 1898e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 1899e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedArg = DeducedTemplateArgument(); 1900e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1901e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1902dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1903e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ++ArgIdx; 1904e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1905dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1906e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 1907e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // pack expansion. 19080216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 1909dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, 19100216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 19110216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 1912dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 19130b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 1914dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1915f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 19160b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 19170b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 191820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 191920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas GregorDeduceTemplateArguments(Sema &S, 192020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateParameterList *TemplateParams, 192120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ParamList, 192220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ArgList, 192320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 19241310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 1925dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 192620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ParamList.data(), ParamList.size(), 192720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgList.data(), ArgList.size(), 192820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 192920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 193020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1931f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor/// \brief Determine whether two template arguments are the same. 19321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic bool isSameTemplateArg(ASTContext &Context, 1933f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &X, 1934f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &Y) { 1935f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.getKind() != Y.getKind()) 1936f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 19371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1938f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor switch (X.getKind()) { 1939f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Null: 1940b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Comparing NULL template argument"); 19411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1942f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Type: 1943f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Context.getCanonicalType(X.getAsType()) == 1944f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Context.getCanonicalType(Y.getAsType()); 19451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1946f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Declaration: 1947d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && 1948d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman X.isDeclForReferenceParam() == Y.isDeclForReferenceParam(); 1949d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 1950d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: 1951d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()); 19521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1953788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1954a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1955a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return Context.getCanonicalTemplateName( 1956a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == 1957a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Context.getCanonicalTemplateName( 1958a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); 1959dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1960f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Integral: 1961855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer return X.getAsIntegral() == Y.getAsIntegral(); 19621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1963788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Expression: { 1964788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor llvm::FoldingSetNodeID XID, YID; 1965788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor X.getAsExpr()->Profile(XID, Context, true); 1966dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Y.getAsExpr()->Profile(YID, Context, true); 1967788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return XID == YID; 1968788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor } 19691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1970f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Pack: 1971f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.pack_size() != Y.pack_size()) 1972f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 19731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator XP = X.pack_begin(), 19751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XPEnd = X.pack_end(), 1976f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor YP = Y.pack_begin(); 19771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XP != XPEnd; ++XP, ++YP) 1978f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!isSameTemplateArg(Context, *XP, *YP)) 1979f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 1980f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 1981f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return true; 1982f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 1983f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 19843026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 1985f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor} 1986f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 198754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Allocate a TemplateArgumentLoc where all locations have 198854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// been initialized to the given location. 198954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 199054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param S The semantic analysis object. 199154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 19921dfbd92c83699820bfaa352e83083124e34fc9dcJames Dennett/// \param Arg The template argument we are producing template argument 199354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// location information for. 199454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 199554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param NTTPType For a declaration template argument, the type of 199654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// the non-type template parameter that corresponds to this template 199754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 199854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 199954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param Loc The source location to use for the resulting template 200054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 2001dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic TemplateArgumentLoc 200254c53cca105ed595e12fecf04e415c3712bda936Douglas GregorgetTrivialTemplateArgumentLoc(Sema &S, 2003dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const TemplateArgument &Arg, 200454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType, 200554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor SourceLocation Loc) { 200654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor switch (Arg.getKind()) { 200754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Null: 200854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm_unreachable("Can't get a NULL template argument here"); 2009dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 201054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Type: 2011dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return TemplateArgumentLoc(Arg, 201254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 2013dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 201454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Declaration: { 201554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 2016ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) 2017d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor .takeAs<Expr>(); 201854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 201954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2020dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2021d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: { 2022d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Expr *E 2023d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) 2024d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman .takeAs<Expr>(); 2025d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true), 2026d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman E); 2027d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman } 2028d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 202954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Integral: { 203054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 2031ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>(); 203254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 203354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2034dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2035b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor case TemplateArgument::Template: 2036b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor case TemplateArgument::TemplateExpansion: { 2037b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor NestedNameSpecifierLocBuilder Builder; 2038b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor TemplateName Template = Arg.getAsTemplate(); 2039b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) 2040b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc); 2041b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 2042b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc); 2043b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 2044b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor if (Arg.getKind() == TemplateArgument::Template) 2045b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor return TemplateArgumentLoc(Arg, 2046b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.getWithLocInContext(S.Context), 2047b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Loc); 2048b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 2049b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 2050b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), 2051b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Loc, Loc); 2052b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor } 2053a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 205454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Expression: 205554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, Arg.getAsExpr()); 2056dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 205754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Pack: 205854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 205954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2060dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 20613026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 206254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 206354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 206454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 206554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Convert the given deduced template argument and add it to the set of 206654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// fully-converted template arguments. 20671310aaca223be5001d58ba9c73fa03d484fd4582Craig Topperstatic bool 20681310aaca223be5001d58ba9c73fa03d484fd4582Craig TopperConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, 20691310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper DeducedTemplateArgument Arg, 20701310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper NamedDecl *Template, 20711310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper QualType NTTPType, 20721310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper unsigned ArgumentPackIndex, 20731310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper TemplateDeductionInfo &Info, 20741310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper bool InFunctionTemplate, 20751310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper SmallVectorImpl<TemplateArgument> &Output) { 207654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 207754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // This is a template argument pack, so check each of its arguments against 207854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template parameter. 20795f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 2> PackedArgsBuilder; 2080dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (TemplateArgument::pack_iterator PA = Arg.pack_begin(), 2081135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor PAEnd = Arg.pack_end(); 208254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor PA != PAEnd; ++PA) { 2083d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // When converting the deduced template argument, append it to the 2084d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // general output list. We need to do this so that the template argument 2085d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // checking logic has all of the prior template arguments available. 208654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument InnerArg(*PA); 208754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); 2088dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, 20896952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTPType, PackedArgsBuilder.size(), 20906952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Info, InFunctionTemplate, Output)) 209154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return true; 2092dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2093d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // Move the converted template argument into our argument pack. 2094d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor PackedArgsBuilder.push_back(Output.back()); 2095d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Output.pop_back(); 209654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2097dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 209854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Create the resulting argument pack. 2099dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Output.push_back(TemplateArgument::CreatePackCopy(S.Context, 2100203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor PackedArgsBuilder.data(), 2101203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor PackedArgsBuilder.size())); 210254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return false; 210354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2104dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 210554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Convert the deduced template argument into a template 210654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // argument that we can check, almost as if the user had written 210754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template argument explicitly. 210854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType, 210954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.getLocation()); 2110dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 211154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Check the template argument, converting it as necessary. 211254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return S.CheckTemplateArgument(Param, ArgLoc, 211354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template, 211454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getLocation(), 211554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getSourceRange().getEnd(), 21166952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ArgumentPackIndex, 211754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Output, 211854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InFunctionTemplate 211954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor ? (Arg.wasDeducedFromArrayBound() 2120dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ? Sema::CTAK_DeducedFromArrayBound 212154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Deduced) 212254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Specified); 212354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 212454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 212531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// Complete template argument deduction for a class template partial 212631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// specialization. 212731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregorstatic Sema::TemplateDeductionResult 2128dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA TakumiFinishTemplateArgumentDeduction(Sema &S, 212931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor ClassTemplatePartialSpecializationDecl *Partial, 213031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 21315f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 21322a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info) { 213359a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 213459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); 213531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::SFINAETrap Trap(S); 2136dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 213731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::ContextRAII SavedContext(S, Partial); 2138f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 213902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // C++ [temp.deduct.type]p2: 214002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // [...] or if any template argument remains neither deduced nor 214102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // explicitly specified, template argument deduction fails. 21425f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 2143033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor TemplateParameterList *PartialParams = Partial->getTemplateParameters(); 2144033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { 214554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NamedDecl *Param = PartialParams->getParam(I); 2146f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Deduced[I].isNull()) { 214754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 214831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Incomplete; 2149f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 2150dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 215154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // We have deduced this argument, so it still needs to be 215254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // checked and converted. 2153dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 215454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // First, for a non-type template parameter type that is 215554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // initialized by a declaration, we need the type of the 215654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // corresponding non-type template parameter. 215754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType; 2158dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NonTypeTemplateParmDecl *NTTP 2159d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 216054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NTTPType = NTTP->getType(); 2161d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType->isDependentType()) { 2162dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2163d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.data(), Builder.size()); 2164d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTPType = S.SubstType(NTTPType, 2165d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 2166d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getLocation(), 2167d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getDeclName()); 2168d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType.isNull()) { 2169d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Info.Param = makeTemplateParameter(Param); 2170d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // FIXME: These template arguments are temporary. Free them! 2171dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(S.Context, 2172dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.data(), 2173d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.size())); 2174d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor return Sema::TDK_SubstitutionFailure; 2175d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2176d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2177d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2178d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor 217954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], 21806952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Partial, NTTPType, 0, Info, false, 218154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Builder)) { 218254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 218354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2184dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 2185dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.size())); 218654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return Sema::TDK_SubstitutionFailure; 218754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 218802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 2189dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 219002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Form the template argument list from the deduced template arguments. 21911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 2192dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 2193910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size()); 2194910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor 2195f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.reset(DeducedArgumentList); 219602cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 219702cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Substitute the deduced template arguments into the template 219802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // arguments of the class template partial specialization, and 219902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // verify that the instantiated template arguments are both valid 220002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // and are equivalent to the template arguments originally provided 22011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // to the class template. 22022a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(S); 220302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); 2204833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall const TemplateArgumentLoc *PartialTemplateArgs 2205833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall = Partial->getTemplateArgsAsWritten(); 2206d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 2207d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall // Note that we don't provide the langle and rangle locations. 2208d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall TemplateArgumentListInfo InstArgs; 2209d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 2210e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (S.Subst(PartialTemplateArgs, 2211e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getNumTemplateArgsAsWritten(), 2212e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { 2213e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; 2214e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (ParamIdx >= Partial->getTemplateParameters()->size()) 2215e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ParamIdx = Partial->getTemplateParameters()->size() - 1; 2216e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 2217e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Decl *Param 2218e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = const_cast<NamedDecl *>( 2219e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getTemplateParameters()->getParam(ParamIdx)); 2220e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2221e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); 2222e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Sema::TDK_SubstitutionFailure; 2223833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 2224833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 22255f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> ConvertedInstArgs; 222631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(), 222754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InstArgs, false, ConvertedInstArgs)) 222831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2229dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 223054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateParameterList *TemplateParams 223154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor = ClassTemplate->getTemplateParameters(); 223254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { 2233910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument InstArg = ConvertedInstArgs.data()[I]; 223431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { 22352fdc5e8199e1e239620f2faae88997153703e16fDouglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); 2236f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = TemplateArgs[I]; 2237f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.SecondArg = InstArg; 223831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 2239f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 224002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 224102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 2242bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor if (Trap.hasErrorOccurred()) 224331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2244bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor 224531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Success; 224631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor} 224731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 224831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// \brief Perform template argument deduction to determine whether 22492521813d45e0af47b27673a095329ee33932d49cLarisse Voufo/// the given template arguments match the given class template 225031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// partial specialization per C++ [temp.class.spec.match]. 225131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::TemplateDeductionResult 225231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, 225331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 225431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateDeductionInfo &Info) { 2255ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor if (Partial->isInvalidDecl()) 2256ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor return TDK_Invalid; 2257ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor 225831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // C++ [temp.class.spec.match]p2: 225931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // A partial specialization matches a given actual template 226031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // argument list if the template arguments of the partial 226131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specialization can be deduced from the actual template argument 226231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // list (14.8.2). 226359a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman 226459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 226559a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 226631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor SFINAETrap Trap(*this); 226759a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman 22685f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 226931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced.resize(Partial->getTemplateParameters()->size()); 227031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (TemplateDeductionResult Result 227131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor = ::DeduceTemplateArguments(*this, 227231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateParameters(), 227331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateArgs(), 227431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateArgs, Info, Deduced)) 227531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Result; 227631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 22777e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); 227831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, 22797e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith DeducedArgs, Info); 228031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Inst) 228131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return TDK_InstantiationDepth; 228231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 228331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Trap.hasErrorOccurred()) 228431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2285dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2286dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, 228731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced, Info); 22880b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 2289031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 2290ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo/// Complete template argument deduction for a variable template partial 2291ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo/// specialization. 2292ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo/// TODO: Unify with ClassTemplatePartialSpecializationDecl version. 2293ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufostatic Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( 2294ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Sema &S, VarTemplatePartialSpecializationDecl *Partial, 2295ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo const TemplateArgumentList &TemplateArgs, 2296ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SmallVectorImpl<DeducedTemplateArgument> &Deduced, 2297ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateDeductionInfo &Info) { 2298ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // Unevaluated SFINAE context. 2299ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); 2300ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Sema::SFINAETrap Trap(S); 2301ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2302ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // C++ [temp.deduct.type]p2: 2303ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // [...] or if any template argument remains neither deduced nor 2304ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // explicitly specified, template argument deduction fails. 2305ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SmallVector<TemplateArgument, 4> Builder; 2306ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateParameterList *PartialParams = Partial->getTemplateParameters(); 2307ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { 2308ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo NamedDecl *Param = PartialParams->getParam(I); 2309ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (Deduced[I].isNull()) { 2310ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.Param = makeTemplateParameter(Param); 2311ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_Incomplete; 2312ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2313ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2314ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // We have deduced this argument, so it still needs to be 2315ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // checked and converted. 2316ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2317ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // First, for a non-type template parameter type that is 2318ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // initialized by a declaration, we need the type of the 2319ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // corresponding non-type template parameter. 2320ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo QualType NTTPType; 2321ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (NonTypeTemplateParmDecl *NTTP = 2322ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2323ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo NTTPType = NTTP->getType(); 2324ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (NTTPType->isDependentType()) { 2325ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2326ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Builder.data(), Builder.size()); 2327ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo NTTPType = 2328ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), 2329ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo NTTP->getLocation(), NTTP->getDeclName()); 2330ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (NTTPType.isNull()) { 2331ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.Param = makeTemplateParameter(Param); 2332ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // FIXME: These template arguments are temporary. Free them! 2333ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 2334ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Builder.size())); 2335ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_SubstitutionFailure; 2336ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2337ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2338ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2339ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2340ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType, 2341ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 0, Info, false, Builder)) { 2342ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.Param = makeTemplateParameter(Param); 2343ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // FIXME: These template arguments are temporary. Free them! 2344ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 2345ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Builder.size())); 2346ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_SubstitutionFailure; 2347ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2348ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2349ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2350ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // Form the template argument list from the deduced template arguments. 2351ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy( 2352ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo S.Context, Builder.data(), Builder.size()); 2353ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2354ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.reset(DeducedArgumentList); 2355ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2356ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // Substitute the deduced template arguments into the template 2357ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // arguments of the class template partial specialization, and 2358ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // verify that the instantiated template arguments are both valid 2359ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // and are equivalent to the template arguments originally provided 2360ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // to the class template. 2361ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo LocalInstantiationScope InstScope(S); 2362ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo VarTemplateDecl *VarTemplate = Partial->getSpecializedTemplate(); 2363ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo const TemplateArgumentLoc *PartialTemplateArgs = 2364ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Partial->getTemplateArgsAsWritten(); 2365ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2366ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // Note that we don't provide the langle and rangle locations. 2367ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateArgumentListInfo InstArgs; 2368ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2369ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (S.Subst(PartialTemplateArgs, Partial->getNumTemplateArgsAsWritten(), 2370ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { 2371ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; 2372ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (ParamIdx >= Partial->getTemplateParameters()->size()) 2373ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo ParamIdx = Partial->getTemplateParameters()->size() - 1; 2374ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2375ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Decl *Param = const_cast<NamedDecl *>( 2376ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Partial->getTemplateParameters()->getParam(ParamIdx)); 2377ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.Param = makeTemplateParameter(Param); 2378ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); 2379ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_SubstitutionFailure; 2380ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2381ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SmallVector<TemplateArgument, 4> ConvertedInstArgs; 2382ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (S.CheckTemplateArgumentList(VarTemplate, Partial->getLocation(), InstArgs, 2383ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo false, ConvertedInstArgs)) 2384ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_SubstitutionFailure; 2385ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2386ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateParameterList *TemplateParams = VarTemplate->getTemplateParameters(); 2387ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { 2388ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateArgument InstArg = ConvertedInstArgs.data()[I]; 2389ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { 2390ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); 2391ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.FirstArg = TemplateArgs[I]; 2392ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info.SecondArg = InstArg; 2393ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_NonDeducedMismatch; 2394ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2395ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 2396ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2397ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (Trap.hasErrorOccurred()) 2398ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_SubstitutionFailure; 2399ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2400ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_Success; 2401ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo} 2402ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2403ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo/// \brief Perform template argument deduction to determine whether 2404ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo/// the given template arguments match the given variable template 2405ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo/// partial specialization per C++ [temp.class.spec.match]. 2406ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo/// TODO: Unify with ClassTemplatePartialSpecializationDecl version. 2407ef4579cda09b73e3d4d98af48201da25adc29326Larisse VoufoSema::TemplateDeductionResult 2408ef4579cda09b73e3d4d98af48201da25adc29326Larisse VoufoSema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, 2409ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo const TemplateArgumentList &TemplateArgs, 2410ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateDeductionInfo &Info) { 2411ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (Partial->isInvalidDecl()) 2412ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return TDK_Invalid; 2413ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2414ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // C++ [temp.class.spec.match]p2: 2415ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // A partial specialization matches a given actual template 2416ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // argument list if the template arguments of the partial 2417ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // specialization can be deduced from the actual template argument 2418ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // list (14.8.2). 2419ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2420ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // Unevaluated SFINAE context. 2421ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 2422ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SFINAETrap Trap(*this); 2423ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2424ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SmallVector<DeducedTemplateArgument, 4> Deduced; 2425ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Deduced.resize(Partial->getTemplateParameters()->size()); 2426ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (TemplateDeductionResult Result = ::DeduceTemplateArguments( 2427ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo *this, Partial->getTemplateParameters(), Partial->getTemplateArgs(), 2428ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateArgs, Info, Deduced)) 2429ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Result; 2430ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2431ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); 2432ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, 2433ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo DeducedArgs, Info); 2434ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (Inst) 2435ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return TDK_InstantiationDepth; 2436ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2437ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (Trap.hasErrorOccurred()) 2438ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Sema::TDK_SubstitutionFailure; 2439ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 2440ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, 2441ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Deduced, Info); 2442ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo} 2443ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 24444112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor/// \brief Determine whether the given type T is a simple-template-id type. 24454112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregorstatic bool isSimpleTemplateIdType(QualType T) { 24461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *Spec 2447183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = T->getAs<TemplateSpecializationType>()) 24484112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return Spec->getTemplateName().getAsTemplateDecl() != 0; 24491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 24504112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return false; 24514112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor} 245283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 245383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Substitute the explicitly-provided template arguments into the 245483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// given function template according to C++ [temp.arg.explicit]. 245583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 245683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template into which the explicit 245783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template arguments will be substituted. 245883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 24591dfbd92c83699820bfaa352e83083124e34fc9dcJames Dennett/// \param ExplicitTemplateArgs the explicitly-specified template 246083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// arguments. 246183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 24621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param Deduced the deduced template arguments, which will be populated 246383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// with the converted and checked explicit template arguments. 246483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 24651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ParamTypes will be populated with the instantiated function 246683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// parameters. 246783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 246883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionType if non-NULL, the result type of the function template 246983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// will also be instantiated and the pointed-to value will be updated with 247083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the instantiated function type. 247183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 247283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info if substitution fails for any reason, this object will be 247383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// populated with more information about the failure. 247483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 247583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns TDK_Success if substitution was successful, or some failure 247683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// condition. 247783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 247883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::SubstituteExplicitTemplateArguments( 247983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplateDecl *FunctionTemplate, 248067714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo &ExplicitTemplateArgs, 24815f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 24825f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<QualType> &ParamTypes, 248383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType *FunctionType, 248483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 248583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 248683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 248783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 248883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 2489d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs.size() == 0) { 249083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // No arguments to substitute; just copy over the parameter types and 249183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // fill in the function type. 249283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (FunctionDecl::param_iterator P = Function->param_begin(), 249383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor PEnd = Function->param_end(); 249483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor P != PEnd; 249583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ++P) 249683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.push_back((*P)->getType()); 24971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 249883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) 249983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *FunctionType = Function->getType(); 250083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 250183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 25021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 250359a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 250459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 25051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 25061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 250783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p3: 25081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Template arguments that are present shall be specified in the 25091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // declaration order of their corresponding template-parameters. The 251083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template argument list shall not specify more template-arguments than 25111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // there are corresponding template-parameters. 25125f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 25131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 25141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Enter a new template instantiation context where we check the 251583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments against this function template, 251683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // and then substitute them into the function parameter types. 25177e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); 25181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 25197e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith FunctionTemplate, DeducedArgs, 25209b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, 25219b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 252283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Inst) 252383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InstantiationDepth; 25241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 252583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (CheckTemplateArgumentList(FunctionTemplate, 252683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SourceLocation(), 2527d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall ExplicitTemplateArgs, 252883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor true, 2529f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor Builder) || Trap.hasErrorOccurred()) { 2530910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor unsigned Index = Builder.size(); 2531fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor if (Index >= TemplateParams->size()) 2532fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Index = TemplateParams->size() - 1; 2533fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); 253483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InvalidExplicitArguments; 2535f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor } 25361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 253783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the explicitly-specified 253883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments. 25391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *ExplicitArgumentList 2540910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 254183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(ExplicitArgumentList); 2542dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2543df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // Template argument deduction and the final substitution should be 2544df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // done in the context of the templated declaration. Explicit 2545df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // argument substitution, on the other hand, needs to happen in the 2546df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // calling context. 2547df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 2548df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall 2549dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If we deduced template arguments for a template parameter pack, 2550d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // note that the template argument pack is partially substituted and record 2551d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // the explicit template arguments. They'll be used as part of deduction 2552d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // for this template parameter pack. 2553d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor for (unsigned I = 0, N = Builder.size(); I != N; ++I) { 2554d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument &Arg = Builder[I]; 2555d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 2556d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor CurrentInstantiationScope->SetPartiallySubstitutedPack( 2557dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateParams->getParam(I), 2558d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Arg.pack_begin(), 2559d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Arg.pack_size()); 2560d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor break; 2561d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 2562d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 2563d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 2564eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith const FunctionProtoType *Proto 2565eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith = Function->getType()->getAs<FunctionProtoType>(); 2566eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith assert(Proto && "Function template does not have a prototype?"); 2567eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith 256883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Instantiate the types of each of the function parameters given the 2569eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // explicitly-specified template arguments. If the function has a trailing 2570eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // return type, substitute it after the arguments to ensure we substitute 2571eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // in lexical order. 2572cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (Proto->hasTrailingReturn()) { 2573cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (SubstParmTypes(Function->getLocation(), 2574cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->param_begin(), Function->getNumParams(), 2575cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2576cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ParamTypes)) 2577cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor return TDK_SubstitutionFailure; 2578cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2579cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2580eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // Instantiate the return type. 2581eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // FIXME: exception-specifications? 2582cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor QualType ResultType; 2583cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor { 2584cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // C++11 [expr.prim.general]p3: 2585cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // If a declaration declares a member function or member function 2586cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // template of a class X, the expression this is a prvalue of type 2587cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq 2588cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // and the end of the function-definition, member-declarator, or 2589cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // declarator. 2590cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor unsigned ThisTypeQuals = 0; 2591cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor CXXRecordDecl *ThisContext = 0; 2592cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) { 2593cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ThisContext = Method->getParent(); 2594cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ThisTypeQuals = Method->getTypeQualifiers(); 2595cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2596cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2597cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals, 259880ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith getLangOpts().CPlusPlus11); 2599cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2600cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ResultType = SubstType(Proto->getResultType(), 2601cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2602cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->getTypeSpecStartLoc(), 2603cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->getDeclName()); 2604cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (ResultType.isNull() || Trap.hasErrorOccurred()) 2605cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor return TDK_SubstitutionFailure; 2606cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2607cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2608eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // Instantiate the types of each of the function parameters given the 2609eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // explicitly-specified template arguments if we didn't do so earlier. 2610eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith if (!Proto->hasTrailingReturn() && 2611eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith SubstParmTypes(Function->getLocation(), 2612eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith Function->param_begin(), Function->getNumParams(), 2613eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2614eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith ParamTypes)) 2615eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith return TDK_SubstitutionFailure; 2616eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith 2617eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith if (FunctionType) { 2618bea522ff43a3f11c7a2bc7949119dbb9fce19e39Jordan Rose *FunctionType = BuildFunctionType(ResultType, ParamTypes, 261983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getLocation(), 2620fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Function->getDeclName(), 26210918989f0eed08870e50418df97d1486d977d773Jordan Rose Proto->getExtProtoInfo()); 262283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType->isNull() || Trap.hasErrorOccurred()) 262383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 262483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 26251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 262683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p2: 26271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Trailing template arguments that can be deduced (14.8.2) may be 26281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // omitted from the list of explicit template-arguments. If all of the 262983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments can be deduced, they may all be omitted; in this 263083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // case, the empty template argument list <> itself may also be omitted. 263183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // 2632d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Take all of the explicitly-specified arguments and put them into 2633d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // the set of deduced template arguments. Explicitly-specified 2634d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // parameter packs, however, will be set to NULL since the deduction 2635d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // mechanisms handle explicitly-specified argument packs directly. 263683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced.reserve(TemplateParams->size()); 2637d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) { 2638d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument &Arg = ExplicitArgumentList->get(I); 2639d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (Arg.getKind() == TemplateArgument::Pack) 2640d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Deduced.push_back(DeducedTemplateArgument()); 2641d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor else 2642d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Deduced.push_back(Arg); 2643d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 26441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 264583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 264683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 264783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 2648b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor/// \brief Check whether the deduced argument type for a call to a function 2649b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor/// template matches the actual argument type per C++ [temp.deduct.call]p4. 2650b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregorstatic bool 2651b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas GregorCheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg, 2652b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType DeducedA) { 2653b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor ASTContext &Context = S.Context; 2654b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2655b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType A = OriginalArg.OriginalArgType; 2656b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType OriginalParamType = OriginalArg.OriginalParamType; 2657b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2658b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Check for type equality (top-level cv-qualifiers are ignored). 2659b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (Context.hasSameUnqualifiedType(A, DeducedA)) 2660b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2661b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2662b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Strip off references on the argument types; they aren't needed for 2663b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // the following checks. 2664b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>()) 2665b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor DeducedA = DeducedARef->getPointeeType(); 2666b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *ARef = A->getAs<ReferenceType>()) 2667b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = ARef->getPointeeType(); 2668b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2669b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // C++ [temp.deduct.call]p4: 2670b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // [...] However, there are three cases that allow a difference: 2671b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 2672b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // type referred to by the reference) can be more cv-qualified than 2673b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // the transformed A. 2674b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *OriginalParamRef 2675b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor = OriginalParamType->getAs<ReferenceType>()) { 2676b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // We don't want to keep the reference around any more. 2677b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor OriginalParamType = OriginalParamRef->getPointeeType(); 2678b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2679b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor Qualifiers AQuals = A.getQualifiers(); 2680b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor Qualifiers DeducedAQuals = DeducedA.getQualifiers(); 2681b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor 2682b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor // Under Objective-C++ ARC, the deduced type may have implicitly been 2683b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor // given strong lifetime. If so, update the original qualifiers to 2684b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor // include this strong lifetime. 2685b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor if (S.getLangOpts().ObjCAutoRefCount && 2686b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong && 2687b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor AQuals.getObjCLifetime() == Qualifiers::OCL_None) { 2688b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor AQuals.setObjCLifetime(Qualifiers::OCL_Strong); 2689b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor } 2690b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor 2691b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (AQuals == DeducedAQuals) { 2692b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Qualifiers match; there's nothing to do. 2693b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) { 2694c99f0ec89fd9782cfafd14d7b1b0a80151eab24aDouglas Gregor return true; 2695b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } else { 2696b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Qualifiers are compatible, so have the argument type adopt the 2697b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // deduced argument type's qualifiers as if we had performed the 2698b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // qualification conversion. 2699b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals); 2700b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2701b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2702b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2703b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - The transformed A can be another pointer or pointer to member 2704b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // type that can be converted to the deduced A via a qualification 2705b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // conversion. 270618e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // 270718e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // Also allow conversions which merely strip [[noreturn]] from function types 270818e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // (recursively) as an extension. 270918e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // FIXME: Currently, this doesn't place nicely with qualfication conversions. 2710b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor bool ObjCLifetimeConversion = false; 271118e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth QualType ResultTy; 2712b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if ((A->isAnyPointerType() || A->isMemberPointerType()) && 271318e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth (S.IsQualificationConversion(A, DeducedA, false, 271418e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth ObjCLifetimeConversion) || 271518e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth S.IsNoReturnConversion(A, DeducedA, ResultTy))) 2716b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2717b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2718b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2719b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - If P is a class and P has the form simple-template-id, then the 2720b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // transformed A can be a derived class of the deduced A. [...] 2721b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // [...] Likewise, if P is a pointer to a class of the form 2722b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // simple-template-id, the transformed A can be a pointer to a 2723b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // derived class pointed to by the deduced A. 2724b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *OriginalParamPtr 2725b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor = OriginalParamType->getAs<PointerType>()) { 2726b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) { 2727b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *APtr = A->getAs<PointerType>()) { 2728b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (A->getPointeeType()->isRecordType()) { 2729b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor OriginalParamType = OriginalParamPtr->getPointeeType(); 2730b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor DeducedA = DeducedAPtr->getPointeeType(); 2731b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = APtr->getPointeeType(); 2732b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2733b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2734b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2735b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2736b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2737b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (Context.hasSameUnqualifiedType(A, DeducedA)) 2738b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2739b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2740b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) && 2741b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor S.IsDerivedFrom(A, DeducedA)) 2742b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2743b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2744b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return true; 2745b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor} 2746b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 27471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Finish template argument deduction for a function template, 274883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// checking the deduced template arguments for completeness and forming 274983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the function template specialization. 2750dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// 2751dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// \param OriginalCallArgs If non-NULL, the original call arguments against 2752dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// which the deduced argument types should be compared. 27531eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::TemplateDeductionResult 275483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, 27555f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 275602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified, 275783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 2758dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor TemplateDeductionInfo &Info, 27595f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs) { 276083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 276183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 27621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 276359a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 276459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 276551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor SFINAETrap Trap(*this); 276651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 276751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Enter a new template instantiation context while we instantiate the 276851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // actual function declaration. 27697e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); 277051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 27717e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith FunctionTemplate, DeducedArgs, 27729b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, 27739b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 277451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (Inst) 277551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_InstantiationDepth; 277651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 277796db310ab7ca59e1890ddef25a3701bc2909d20fJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 2778f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 277983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.deduct.type]p2: 278083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // [...] or if any template argument remains neither deduced nor 278183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly specified, template argument deduction fails. 27825f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 2783b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 2784b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NamedDecl *Param = TemplateParams->getParam(I); 2785dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 278651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (!Deduced[I].isNull()) { 27873273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor if (I < NumExplicitlySpecified) { 278802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have already fully type-checked and converted this 2789dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // argument, because it was explicitly-specified. Just record the 27903273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor // presence of this argument. 2791910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.push_back(Deduced[I]); 279202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor continue; 279302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 279402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 279502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have deduced this argument, so it still needs to be 279602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // checked and converted. 279702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 279802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // First, for a non-type template parameter type that is 279902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // initialized by a declaration, we need the type of the 280002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // corresponding non-type template parameter. 280102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor QualType NTTPType; 2802dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NonTypeTemplateParmDecl *NTTP 2803dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2804b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = NTTP->getType(); 2805b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType->isDependentType()) { 2806dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2807b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.data(), Builder.size()); 2808b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = SubstType(NTTPType, 2809b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 2810b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getLocation(), 2811b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getDeclName()); 2812b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType.isNull()) { 2813b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2814b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2815dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, 2816dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.data(), 2817b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.size())); 2818b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor return TDK_SubstitutionFailure; 281902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 282002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 282102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 282202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 2823b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I], 28246952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor FunctionTemplate, NTTPType, 0, Info, 282554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor true, Builder)) { 2826b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2827910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2828dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2829dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.size())); 283002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor return TDK_SubstitutionFailure; 283102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 283202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 283351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor continue; 283451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 2835dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2836ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // C++0x [temp.arg.explicit]p3: 2837dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // A trailing template parameter pack (14.5.3) not otherwise deduced will 2838ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // be deduced to an empty sequence of template arguments. 2839ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // FIXME: Where did the word "trailing" come from? 2840ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor if (Param->isTemplateParameterPack()) { 2841d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // We may have had explicitly-specified template arguments for this 2842d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template parameter pack. If so, our empty deduction extends the 2843d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // explicitly-specified set (C++0x [temp.arg.explicit]p9). 2844d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument *ExplicitArgs; 2845d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor unsigned NumExplicitArgs; 2846a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith if (CurrentInstantiationScope && 2847a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs, 2848d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor &NumExplicitArgs) 284922eaced5cac3cf0522c953f593419fc6cf184aafDouglas Gregor == Param) { 2850d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs)); 2851dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 285222eaced5cac3cf0522c953f593419fc6cf184aafDouglas Gregor // Forget the partially-substituted pack; it's substitution is now 285322eaced5cac3cf0522c953f593419fc6cf184aafDouglas Gregor // complete. 285422eaced5cac3cf0522c953f593419fc6cf184aafDouglas Gregor CurrentInstantiationScope->ResetPartiallySubstitutedPack(); 285522eaced5cac3cf0522c953f593419fc6cf184aafDouglas Gregor } else { 285622eaced5cac3cf0522c953f593419fc6cf184aafDouglas Gregor Builder.push_back(TemplateArgument::getEmptyPack()); 285722eaced5cac3cf0522c953f593419fc6cf184aafDouglas Gregor } 2858ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor continue; 2859ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor } 286051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 2861dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Substitute into the default template argument, if available. 2862305e5b4268685aa97d6338fe4362d1b73246cbe9Richard Smith bool HasDefaultArg = false; 286351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor TemplateArgumentLoc DefArg 286451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate, 286551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 286651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 286751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Param, 2868305e5b4268685aa97d6338fe4362d1b73246cbe9Richard Smith Builder, HasDefaultArg); 286951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 287051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If there was no default argument, deduction is incomplete. 287151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (DefArg.getArgument().isNull()) { 287283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.Param = makeTemplateParameter( 287351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 2874305e5b4268685aa97d6338fe4362d1b73246cbe9Richard Smith Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2875305e5b4268685aa97d6338fe4362d1b73246cbe9Richard Smith Builder.size())); 2876305e5b4268685aa97d6338fe4362d1b73246cbe9Richard Smith return HasDefaultArg ? TDK_SubstitutionFailure : TDK_Incomplete; 287783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 2878dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 287951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Check whether we can actually use the default argument. 288051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (CheckTemplateArgument(Param, DefArg, 288151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate, 288251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 288351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 28846952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor 0, Builder, 28858735b294a257a07ca158c28094d7324f0adf889aDouglas Gregor CTAK_Specified)) { 288651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Info.Param = makeTemplateParameter( 288751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 2888910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2889dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2890910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size())); 289151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_SubstitutionFailure; 289251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 28931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 289451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If we get here, we successfully used the default template argument. 289583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 28961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 289783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the deduced template arguments. 28981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 2899910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 290083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(DeducedArgumentList); 29011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Substitute the deduced template arguments into the function template 290383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration to produce the function template specialization. 2904d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor DeclContext *Owner = FunctionTemplate->getDeclContext(); 2905d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor if (FunctionTemplate->getFriendObjectKind()) 2906d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor Owner = FunctionTemplate->getLexicalDeclContext(); 290783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization = cast_or_null<FunctionDecl>( 2908d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, 2909357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor MultiLevelTemplateArgumentList(*DeducedArgumentList))); 29105fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor if (!Specialization || Specialization->isInvalidDecl()) 291183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 29121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2913dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == 2914f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor FunctionTemplate->getCanonicalDecl()); 2915dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 29161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the template argument list is owned by the function template 291783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // specialization, release it. 2918ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList && 2919ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor !Trap.hasErrorOccurred()) 292083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.take(); 29211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29225fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // There may have been an error that did not prevent us from constructing a 29235fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // declaration. Mark the declaration invalid and return with a substitution 29245fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // failure. 29255fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor if (Trap.hasErrorOccurred()) { 29265fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor Specialization->setInvalidDecl(true); 29275fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor return TDK_SubstitutionFailure; 29285fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor } 29295fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor 2930dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (OriginalCallArgs) { 2931dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // C++ [temp.deduct.call]p4: 2932dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // In general, the deduction process attempts to find template argument 2933dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // values that will make the deduced A identical to A (after the type A 2934dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // is transformed as described above). [...] 2935dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) { 2936dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor OriginalCallArg OriginalArg = (*OriginalCallArgs)[I]; 2937dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor unsigned ParamIdx = OriginalArg.ArgIdx; 2938dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 2939dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (ParamIdx >= Specialization->getNumParams()) 2940dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor continue; 2941dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 2942dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType(); 2943b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) 2944b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return Sema::TDK_SubstitutionFailure; 2945dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor } 2946dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor } 2947dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 29489b623639378d53a675921ddfa7316034d571881eDouglas Gregor // If we suppressed any diagnostics while performing template argument 29499b623639378d53a675921ddfa7316034d571881eDouglas Gregor // deduction, and if we haven't already instantiated this declaration, 29509b623639378d53a675921ddfa7316034d571881eDouglas Gregor // keep track of these diagnostics. They'll be emitted if this specialization 29519b623639378d53a675921ddfa7316034d571881eDouglas Gregor // is actually used. 29529b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Info.diag_begin() != Info.diag_end()) { 2953ee0a47998ca7db5d31291a397aca38219d3dfd7dCraig Topper SuppressedDiagnosticsMap::iterator 29549b623639378d53a675921ddfa7316034d571881eDouglas Gregor Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); 29559b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Pos == SuppressedDiagnostics.end()) 29569b623639378d53a675921ddfa7316034d571881eDouglas Gregor SuppressedDiagnostics[Specialization->getCanonicalDecl()] 29579b623639378d53a675921ddfa7316034d571881eDouglas Gregor .append(Info.diag_begin(), Info.diag_end()); 2958dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi } 29599b623639378d53a675921ddfa7316034d571881eDouglas Gregor 29601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TDK_Success; 296183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 296283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 29639c72c6088d591ace8503b842d39448c2040f3033John McCall/// Gets the type of a function for template-argument-deducton 29649c72c6088d591ace8503b842d39448c2040f3033John McCall/// purposes when it's considered as part of an overload set. 296560e141e1f87211ca831de6821003d80fe20a06f3Richard Smithstatic QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R, 2966eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn) { 296760e141e1f87211ca831de6821003d80fe20a06f3Richard Smith // We may need to deduce the return type of the function now. 296860e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (S.getLangOpts().CPlusPlus1y && Fn->getResultType()->isUndeducedType() && 296960e141e1f87211ca831de6821003d80fe20a06f3Richard Smith S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/false)) 297060e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return QualType(); 297160e141e1f87211ca831de6821003d80fe20a06f3Richard Smith 2972eff92135d32039c9874dc356f3e93143af6069c1John McCall if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) 29739c72c6088d591ace8503b842d39448c2040f3033John McCall if (Method->isInstance()) { 29749c72c6088d591ace8503b842d39448c2040f3033John McCall // An instance method that's referenced in a form that doesn't 29759c72c6088d591ace8503b842d39448c2040f3033John McCall // look like a member pointer is just invalid. 29769c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.HasFormOfMemberPointer) return QualType(); 29779c72c6088d591ace8503b842d39448c2040f3033John McCall 297860e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return S.Context.getMemberPointerType(Fn->getType(), 297960e141e1f87211ca831de6821003d80fe20a06f3Richard Smith S.Context.getTypeDeclType(Method->getParent()).getTypePtr()); 29809c72c6088d591ace8503b842d39448c2040f3033John McCall } 29819c72c6088d591ace8503b842d39448c2040f3033John McCall 29829c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.IsAddressOfOperand) return Fn->getType(); 298360e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return S.Context.getPointerType(Fn->getType()); 2984eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2985eff92135d32039c9874dc356f3e93143af6069c1John McCall 2986eff92135d32039c9874dc356f3e93143af6069c1John McCall/// Apply the deduction rules for overload sets. 2987eff92135d32039c9874dc356f3e93143af6069c1John McCall/// 2988eff92135d32039c9874dc356f3e93143af6069c1John McCall/// \return the null type if this argument should be treated as an 2989eff92135d32039c9874dc356f3e93143af6069c1John McCall/// undeduced context 2990eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType 2991eff92135d32039c9874dc356f3e93143af6069c1John McCallResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, 299275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor Expr *Arg, QualType ParamType, 299375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor bool ParamWasReference) { 2994dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 29959c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr::FindResult R = OverloadExpr::find(Arg); 2996eff92135d32039c9874dc356f3e93143af6069c1John McCall 29979c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr *Ovl = R.Expression; 2998eff92135d32039c9874dc356f3e93143af6069c1John McCall 299975f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // C++0x [temp.deduct.call]p4 300075f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor unsigned TDF = 0; 300175f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (ParamWasReference) 300275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_ParamWithReferenceType; 300375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (R.IsAddressOfOperand) 300475f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_IgnoreQualifiers; 300575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 3006eff92135d32039c9874dc356f3e93143af6069c1John McCall // C++0x [temp.deduct.call]p6: 3007eff92135d32039c9874dc356f3e93143af6069c1John McCall // When P is a function type, pointer to function type, or pointer 3008eff92135d32039c9874dc356f3e93143af6069c1John McCall // to member function type: 3009eff92135d32039c9874dc356f3e93143af6069c1John McCall 3010eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!ParamType->isFunctionType() && 3011eff92135d32039c9874dc356f3e93143af6069c1John McCall !ParamType->isFunctionPointerType() && 3012860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor !ParamType->isMemberFunctionPointerType()) { 3013860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (Ovl->hasExplicitTemplateArgs()) { 3014860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // But we can still look for an explicit specialization. 3015860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (FunctionDecl *ExplicitSpec 3016860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor = S.ResolveSingleFunctionTemplateSpecialization(Ovl)) 301760e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return GetTypeOfFunction(S, R, ExplicitSpec); 3018860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 3019eff92135d32039c9874dc356f3e93143af6069c1John McCall 3020860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor return QualType(); 3021860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 3022860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 3023860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // Gather the explicit template arguments, if any. 3024860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor TemplateArgumentListInfo ExplicitTemplateArgs; 3025860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (Ovl->hasExplicitTemplateArgs()) 3026860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs); 3027eff92135d32039c9874dc356f3e93143af6069c1John McCall QualType Match; 30287bb12da2b0749eeebb21854c77877736969e59f2John McCall for (UnresolvedSetIterator I = Ovl->decls_begin(), 30297bb12da2b0749eeebb21854c77877736969e59f2John McCall E = Ovl->decls_end(); I != E; ++I) { 3030eff92135d32039c9874dc356f3e93143af6069c1John McCall NamedDecl *D = (*I)->getUnderlyingDecl(); 3031eff92135d32039c9874dc356f3e93143af6069c1John McCall 3032860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) { 3033860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // - If the argument is an overload set containing one or more 3034860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // function templates, the parameter is treated as a 3035860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // non-deduced context. 3036860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (!Ovl->hasExplicitTemplateArgs()) 3037860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor return QualType(); 3038860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 3039860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // Otherwise, see if we can resolve a function type 3040860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor FunctionDecl *Specialization = 0; 304193e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Ovl->getNameLoc()); 3042860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs, 3043860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor Specialization, Info)) 3044860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor continue; 3045860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 3046860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor D = Specialization; 3047860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 3048eff92135d32039c9874dc356f3e93143af6069c1John McCall 3049eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn = cast<FunctionDecl>(D); 305060e141e1f87211ca831de6821003d80fe20a06f3Richard Smith QualType ArgType = GetTypeOfFunction(S, R, Fn); 30519c72c6088d591ace8503b842d39448c2040f3033John McCall if (ArgType.isNull()) continue; 3052eff92135d32039c9874dc356f3e93143af6069c1John McCall 305375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // Function-to-pointer conversion. 3054dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (!ParamWasReference && ParamType->isPointerType() && 305575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType->isFunctionType()) 305675f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 3057dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3058eff92135d32039c9874dc356f3e93143af6069c1John McCall // - If the argument is an overload set (not containing function 3059eff92135d32039c9874dc356f3e93143af6069c1John McCall // templates), trial argument deduction is attempted using each 3060eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the members of the set. If deduction succeeds for only one 3061eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the overload set members, that member is used as the 3062eff92135d32039c9874dc356f3e93143af6069c1John McCall // argument value for the deduction. If deduction succeeds for 3063eff92135d32039c9874dc356f3e93143af6069c1John McCall // more than one member of the overload set the parameter is 3064eff92135d32039c9874dc356f3e93143af6069c1John McCall // treated as a non-deduced context. 3065eff92135d32039c9874dc356f3e93143af6069c1John McCall 3066eff92135d32039c9874dc356f3e93143af6069c1John McCall // We do all of this in a fresh context per C++0x [temp.deduct.type]p2: 3067eff92135d32039c9874dc356f3e93143af6069c1John McCall // Type deduction is done independently for each P/A pair, and 3068eff92135d32039c9874dc356f3e93143af6069c1John McCall // the deduced template argument values are then combined. 3069eff92135d32039c9874dc356f3e93143af6069c1John McCall // So we do not reject deductions which were made elsewhere. 30705f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 8> 307102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Deduced(TemplateParams->size()); 307293e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Ovl->getNameLoc()); 3073eff92135d32039c9874dc356f3e93143af6069c1John McCall Sema::TemplateDeductionResult Result 3074bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, 3075bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ArgType, Info, Deduced, TDF); 3076eff92135d32039c9874dc356f3e93143af6069c1John McCall if (Result) continue; 3077eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!Match.isNull()) return QualType(); 3078eff92135d32039c9874dc356f3e93143af6069c1John McCall Match = ArgType; 3079eff92135d32039c9874dc356f3e93143af6069c1John McCall } 3080eff92135d32039c9874dc356f3e93143af6069c1John McCall 3081eff92135d32039c9874dc356f3e93143af6069c1John McCall return Match; 3082eff92135d32039c9874dc356f3e93143af6069c1John McCall} 3083eff92135d32039c9874dc356f3e93143af6069c1John McCall 3084dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \brief Perform the adjustments to the parameter and argument types 3085f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// described in C++ [temp.deduct.call]. 3086f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// 3087f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// \returns true if the caller should not attempt to perform any template 30880efa62f2096f28a610ac2ea8d2651448a7ec89c7Richard Smith/// argument deduction based on this P/A pair because the argument is an 30890efa62f2096f28a610ac2ea8d2651448a7ec89c7Richard Smith/// overloaded function set that could not be resolved. 3090f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregorstatic bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, 3091f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TemplateParameterList *TemplateParams, 3092f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ParamType, 3093f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ArgType, 3094f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg, 3095f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned &TDF) { 3096f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 30970099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // If P is a cv-qualified type, the top level cv-qualifiers of P's type 3098f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // are ignored for type deduction. 3099a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor if (ParamType.hasQualifiers()) 3100a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor ParamType = ParamType.getUnqualifiedType(); 3101f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>(); 3102f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 310334b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType PointeeType = ParamRefType->getPointeeType(); 310434b41d939a1328f484511c6002ba2456db879a29Richard Smith 31050efa62f2096f28a610ac2ea8d2651448a7ec89c7Richard Smith // If the argument has incomplete array type, try to complete its type. 3106d10099e5c8238fa0327f03921cf2e3c8975c881eDouglas Gregor if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0)) 3107f15748a28c8443eef2924ef83689c358c661e9c5Douglas Gregor ArgType = Arg->getType(); 3108f15748a28c8443eef2924ef83689c358c661e9c5Douglas Gregor 31092ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // [C++0x] If P is an rvalue reference to a cv-unqualified 31102ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // template parameter and the argument is an lvalue, the type 31112ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // "lvalue reference to A" is used in place of A for type 31122ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // deduction. 311334b41d939a1328f484511c6002ba2456db879a29Richard Smith if (isa<RValueReferenceType>(ParamType)) { 311434b41d939a1328f484511c6002ba2456db879a29Richard Smith if (!PointeeType.getQualifiers() && 311534b41d939a1328f484511c6002ba2456db879a29Richard Smith isa<TemplateTypeParmType>(PointeeType) && 31169625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->Classify(S.Context).isLValue() && 31179625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->getType() != S.Context.OverloadTy && 31189625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->getType() != S.Context.BoundMemberTy) 31192ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor ArgType = S.Context.getLValueReferenceType(ArgType); 31202ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor } 31212ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor 3122f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is a reference type, the type referred to by P is used 3123f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for type deduction. 312434b41d939a1328f484511c6002ba2456db879a29Richard Smith ParamType = PointeeType; 3125f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3126dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3127f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Overload sets usually make this parameter an undeduced 3128f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // context, but there are sometimes special circumstances. 3129f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType == S.Context.OverloadTy) { 3130f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = ResolveOverloadForDeduction(S, TemplateParams, 3131f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg, ParamType, 3132f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType != 0); 3133f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType.isNull()) 3134f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return true; 3135f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3136dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3137f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 3138f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 3139f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is of the form T&&, where T is a template parameter, and 3140f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the argument is an lvalue, the type A& is used in place of A for 3141f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type deduction. 3142f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType->isRValueReferenceType() && 3143f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType->getAs<TemplateTypeParmType>() && 3144f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg->isLValue()) 3145f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getLValueReferenceType(ArgType); 3146f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } else { 3147f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++ [temp.deduct.call]p2: 3148f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // If P is not a reference type: 3149f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is an array type, the pointer type produced by the 3150f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // array-to-pointer standard conversion (4.2) is used in place of 3151f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // A for type deduction; otherwise, 3152f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isArrayType()) 3153f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getArrayDecayedType(ArgType); 3154f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is a function type, the pointer type produced by the 3155f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // function-to-pointer standard conversion (4.3) is used in place 3156f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // of A for type deduction; otherwise, 3157f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (ArgType->isFunctionType()) 3158f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 3159f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else { 31600099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // - If A is a cv-qualified type, the top level cv-qualifiers of A's 3161f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type are ignored for type deduction. 3162a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor ArgType = ArgType.getUnqualifiedType(); 3163f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3164f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3165dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3166f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p4: 3167f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // In general, the deduction process attempts to find template argument 3168f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // values that will make the deduced A identical to A (after the type A 3169f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // is transformed as described above). [...] 3170f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF = TDF_SkipNonDependent; 3171dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3172f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 3173f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type referred to by the reference) can be more cv-qualified than 3174f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the transformed A. 3175f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) 3176f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_ParamWithReferenceType; 3177f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - The transformed A can be another pointer or pointer to member 3178f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type that can be converted to the deduced A via a qualification 3179f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // conversion (4.4). 3180f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isPointerType() || ArgType->isMemberPointerType() || 3181f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType->isObjCObjectPointerType()) 3182f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_IgnoreQualifiers; 3183f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If P is a class and P has the form simple-template-id, then the 3184f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a derived class of the deduced A. Likewise, 3185f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // if P is a pointer to a class of the form simple-template-id, the 3186f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a pointer to a derived class pointed to by 3187f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the deduced A. 3188f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (isSimpleTemplateIdType(ParamType) || 3189f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor (isa<PointerType>(ParamType) && 3190f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor isSimpleTemplateIdType( 3191f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType->getAs<PointerType>()->getPointeeType()))) 3192f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_DerivedClass; 3193dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3194f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return false; 3195f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor} 3196f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 3197dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregorstatic bool hasDeducibleTemplateParameters(Sema &S, 3198dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor FunctionTemplateDecl *FunctionTemplate, 3199dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType T); 3200dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 32014b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// \brief Perform template argument deduction by matching a parameter type 32024b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// against a single expression, where the expression is an element of 32030efa62f2096f28a610ac2ea8d2651448a7ec89c7Richard Smith/// an initializer list that was originally matched against a parameter 32040efa62f2096f28a610ac2ea8d2651448a7ec89c7Richard Smith/// of type \c initializer_list\<ParamType\>. 32054b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redlstatic Sema::TemplateDeductionResult 32064b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian RedlDeduceTemplateArgumentByListElement(Sema &S, 32074b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl TemplateParameterList *TemplateParams, 32084b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl QualType ParamType, Expr *Arg, 32094b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl TemplateDeductionInfo &Info, 32104b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl SmallVectorImpl<DeducedTemplateArgument> &Deduced, 32114b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl unsigned TDF) { 32124b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // Handle the case where an init list contains another init list as the 32134b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // element. 32144b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 32154b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl QualType X; 32164b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X)) 32174b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Sema::TDK_Success; // Just ignore this expression. 32184b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 32194b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // Recurse down into the init list. 32204b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 32214b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (Sema::TemplateDeductionResult Result = 32224b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl DeduceTemplateArgumentByListElement(S, TemplateParams, X, 32234b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl ILE->getInit(i), 32244b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl Info, Deduced, TDF)) 32254b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Result; 32264b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl } 32274b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Sema::TDK_Success; 32284b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl } 32294b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 32304b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // For all other cases, just match by type. 3231d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor QualType ArgType = Arg->getType(); 3232d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, 32330efa62f2096f28a610ac2ea8d2651448a7ec89c7Richard Smith ArgType, Arg, TDF)) { 32340efa62f2096f28a610ac2ea8d2651448a7ec89c7Richard Smith Info.Expression = Arg; 3235d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor return Sema::TDK_FailedOverloadResolution; 32360efa62f2096f28a610ac2ea8d2651448a7ec89c7Richard Smith } 32374b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, 3238d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor ArgType, Info, Deduced, TDF); 32394b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl} 32404b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 3241e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \brief Perform template argument deduction from a function call 3242e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// (C++ [temp.deduct.call]). 3243e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 3244e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 3245e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 3246e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 324740ae6666dd7a458f2d213370922a38be13f003c4James Dennett/// \param ExplicitTemplateArgs the explicit template arguments provided 324848026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// for this call. 32496db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// 3250e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Args the function call arguments 3251e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 3252e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Specialization if template argument deduction was successful, 32531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 3254e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 3255e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 3256e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Info the argument will be updated to provide additional information 3257e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// about template argument deduction. 3258e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 3259e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \returns the result of template argument deduction. 3260e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::TemplateDeductionResult 3261e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 326267714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 326313a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles llvm::ArrayRef<Expr *> Args, 3264e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *&Specialization, 3265e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateDeductionInfo &Info) { 3266ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor if (FunctionTemplate->isInvalidDecl()) 3267ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor return TDK_Invalid; 3268ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor 3269e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 32706db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor 3271e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++ [temp.deduct.call]p1: 3272e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // Template argument deduction is done by comparing each function template 3273e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // parameter type (call it P) with the type of the corresponding argument 3274e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // of the call (call it A) as described below. 327513a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles unsigned CheckArgs = Args.size(); 327613a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles if (Args.size() < Function->getMinRequiredArguments()) 3277e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooFewArguments; 327813a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles else if (Args.size() > Function->getNumParams()) { 32791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *Proto 3280183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Function->getType()->getAs<FunctionProtoType>(); 3281f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Proto->isTemplateVariadic()) 3282f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor /* Do nothing */; 3283f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (Proto->isVariadic()) 3284f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor CheckArgs = Function->getNumParams(); 3285dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi else 3286e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooManyArguments; 3287e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 32881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 32896db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // The types of the parameters from which we will perform template argument 32906db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // deduction. 32912a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 3292e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateParameterList *TemplateParams 3293e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor = FunctionTemplate->getTemplateParameters(); 32945f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 32955f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> ParamTypes; 329602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 3297d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 329883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionResult Result = 329983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SubstituteExplicitTemplateArguments(FunctionTemplate, 3300d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 330183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced, 330283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes, 330383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 0, 330483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info); 330583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Result) 330683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 330702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 330802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 33096db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } else { 33106db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Just fill in the parameter types from the function declaration. 3311f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 33126db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor ParamTypes.push_back(Function->getParamDecl(I)->getType()); 33136db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } 33141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33156db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Deduce template arguments from the function parameters. 33161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 3317f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned ArgIdx = 0; 33185f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<OriginalCallArg, 4> OriginalCallArgs; 3319dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (unsigned ParamIdx = 0, NumParams = ParamTypes.size(); 3320f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamIdx != NumParams; ++ParamIdx) { 3321dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType OrigParamType = ParamTypes[ParamIdx]; 3322dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType ParamType = OrigParamType; 3323dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3324dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const PackExpansionType *ParamExpansion 3325f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = dyn_cast<PackExpansionType>(ParamType); 3326f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!ParamExpansion) { 3327f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Simple case: matching a function parameter to a function argument. 3328f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgIdx >= CheckArgs) 3329f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3330dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3331f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx++]; 3332f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 3333dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3334f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 3335f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 3336f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 3337f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 3338f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 3339dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3340d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor // If we have nothing to deduce, we're done. 3341d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) 3342d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor continue; 3343d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor 334484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // If the argument is an initializer list ... 334584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 334684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // ... then the parameter is an undeduced context, unless the parameter 334784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // type is (reference to cv) std::initializer_list<P'>, in which case 334884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // deduction is done for each element of the initializer list, and the 334984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // result is the deduced type if it's the same for all elements. 335084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl QualType X; 335184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Removing references was already done. 335284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (!isStdInitializerList(ParamType, &X)) 335384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl continue; 335484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 335584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 335684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result = 33574b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl DeduceTemplateArgumentByListElement(*this, TemplateParams, X, 33584b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl ILE->getInit(i), 33594b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl Info, Deduced, TDF)) 336084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 336184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 336284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Don't track the argument type, since an initializer list has none. 336384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl continue; 336484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 336584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 3366dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // Keep track of the argument type and corresponding parameter index, 3367dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // so we can check for compatibility between the deduced A and A. 3368d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1, 3369d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor ArgType)); 3370dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3371f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (TemplateDeductionResult Result 3372bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 3373bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ParamType, ArgType, 3374bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 3375f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return Result; 33761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3377f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 337875f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor } 3379dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3380f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p1: 3381dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // For a function parameter pack that occurs at the end of the 3382dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // parameter-declaration-list, the type A of each remaining argument of 3383dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the call is compared with the type P of the declarator-id of the 3384dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // function parameter pack. Each comparison deduces template arguments 3385dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // for subsequent positions in the template parameter packs expanded by 33867d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // the function parameter pack. For a function parameter pack that does 3387dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // not occur at the end of the parameter-declaration-list, the type of 33887d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // the parameter pack is a non-deduced context. 33897d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor if (ParamIdx + 1 < NumParams) 33907d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor break; 3391dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3392f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ParamPattern = ParamExpansion->getPattern(); 33935f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 3394f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor { 3395013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 33965f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3397f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor collectUnexpandedParameterPacks(ParamPattern, Unexpanded); 3398f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 3399f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned Depth, Index; 3400f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 3401f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 3402f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor SawIndices[Index] = true; 3403f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor PackIndices.push_back(Index); 3404f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3405f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3406f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3407f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 3408dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3409d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Keep track of the deduced template arguments for each parameter pack 3410dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 3411d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template argument (the inner SmallVectors). 341270d214f864987a06b27a92a2bd59df50037815f5Craig Topper NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); 34135f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 3414d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor SavedPacks(PackIndices.size()); 34155429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks, 3416dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks); 3417f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor bool HasAnyArguments = false; 341813a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles for (; ArgIdx < Args.size(); ++ArgIdx) { 3419f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor HasAnyArguments = true; 3420dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3421dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType OrigParamType = ParamPattern; 3422dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor ParamType = OrigParamType; 3423f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx]; 3424f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 3425dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3426f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 3427f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 3428f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 3429f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) { 3430f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // We can't actually perform any deduction for this argument, so stop 3431f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // deduction at this point. 3432f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ++ArgIdx; 3433f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3434f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3435dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 343684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // As above, initializer lists need special handling. 343784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 343884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl QualType X; 343984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (!isStdInitializerList(ParamType, &X)) { 344084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ++ArgIdx; 344184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl break; 344284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 3443dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 344484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 344584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result = 344684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X, 344784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ILE->getInit(i)->getType(), 344884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl Info, Deduced, TDF)) 344984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 345084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 345184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } else { 345284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 345384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Keep track of the argument type and corresponding argument index, 345484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // so we can check for compatibility between the deduced A and A. 345584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) 345684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx, 345784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ArgType)); 345884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 345984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result 346084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 346184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ParamType, ArgType, Info, 346284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl Deduced, TDF)) 346384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 346484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 3465eff92135d32039c9874dc356f3e93143af6069c1John McCall 3466f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 3467f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 3468f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for that pack, then clear out the deduced argument. 3469f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 3470f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 3471f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!DeducedArg.isNull()) { 3472f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 3473f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedArg = DeducedTemplateArgument(); 3474f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3475e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 3476e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 3477dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3478f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 3479f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // pack expansion. 34800216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 3481dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments, 34820216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 34830216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 3484dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 34851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3486f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // After we've matching against a parameter pack, we're done. 3487f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3488e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 348965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 34901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 349102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified, 3492dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor Specialization, Info, &OriginalCallArgs); 349383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 3494127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor 349583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Deduce template arguments when taking the address of a function 34964b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to 34974b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// a template. 349883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 349983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template for which we are performing 350083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 350183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 350240ae6666dd7a458f2d213370922a38be13f003c4James Dennett/// \param ExplicitTemplateArgs the explicitly-specified template 35034b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 350483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 350583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ArgFunctionType the function type that will be used as the 350683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// "argument" type (A) when performing template argument deduction from the 35074b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// function template's function type. This type may be NULL, if there is no 35084b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// argument type to compare against, in C++0x [temp.arg.explicit]p3. 350983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 351083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Specialization if template argument deduction was successful, 35111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 351283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 351383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 351483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info the argument will be updated to provide additional information 351583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// about template argument deduction. 351683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 351783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns the result of template argument deduction. 351883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 351983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 352067714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 352183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType ArgFunctionType, 352283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 3523092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor TemplateDeductionInfo &Info, 3524092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor bool InOverloadResolution) { 3525ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor if (FunctionTemplate->isInvalidDecl()) 3526ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor return TDK_Invalid; 3527ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor 352883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 352983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 353083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 353183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType FunctionType = Function->getType(); 35321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 353383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitute any explicit template arguments. 35342a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 35355f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 353602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 35375f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> ParamTypes; 3538d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 35391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (TemplateDeductionResult Result 35401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump = SubstituteExplicitTemplateArguments(FunctionTemplate, 3541d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 35421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced, ParamTypes, 354383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor &FunctionType, Info)) 354483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 354502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 354602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 3547127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor } 354883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 354959a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 355059a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 35511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 35521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3553eff92135d32039c9874dc356f3e93143af6069c1John McCall Deduced.resize(TemplateParams->size()); 3554eff92135d32039c9874dc356f3e93143af6069c1John McCall 355560e141e1f87211ca831de6821003d80fe20a06f3Richard Smith // If the function has a deduced return type, substitute it for a dependent 355660e141e1f87211ca831de6821003d80fe20a06f3Richard Smith // type so that we treat it as a non-deduced context in what follows. 355760e141e1f87211ca831de6821003d80fe20a06f3Richard Smith bool HasUndeducedReturnType = false; 355860e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (getLangOpts().CPlusPlus1y && InOverloadResolution && 355960e141e1f87211ca831de6821003d80fe20a06f3Richard Smith Function->getResultType()->isUndeducedType()) { 356060e141e1f87211ca831de6821003d80fe20a06f3Richard Smith FunctionType = SubstAutoType(FunctionType, Context.DependentTy); 356160e141e1f87211ca831de6821003d80fe20a06f3Richard Smith HasUndeducedReturnType = true; 356260e141e1f87211ca831de6821003d80fe20a06f3Richard Smith } 356360e141e1f87211ca831de6821003d80fe20a06f3Richard Smith 35644b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (!ArgFunctionType.isNull()) { 3565092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor unsigned TDF = TDF_TopLevelParameterTypeList; 3566092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor if (InOverloadResolution) TDF |= TDF_InOverloadResolution; 35674b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // Deduce template arguments from the function type. 35684b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (TemplateDeductionResult Result 3569bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 3570092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor FunctionType, ArgFunctionType, 3571092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor Info, Deduced, TDF)) 35724b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return Result; 35734b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 3574fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 3575dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (TemplateDeductionResult Result 3576fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 3577fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor NumExplicitlySpecified, 3578fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor Specialization, Info)) 3579fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return Result; 3580fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 358160e141e1f87211ca831de6821003d80fe20a06f3Richard Smith // If the function has a deduced return type, deduce it now, so we can check 358260e141e1f87211ca831de6821003d80fe20a06f3Richard Smith // that the deduced function type matches the requested type. 358360e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (HasUndeducedReturnType && 358460e141e1f87211ca831de6821003d80fe20a06f3Richard Smith Specialization->getResultType()->isUndeducedType() && 358560e141e1f87211ca831de6821003d80fe20a06f3Richard Smith DeduceReturnType(Specialization, Info.getLocation(), false)) 358660e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return TDK_MiscellaneousDeductionFailure; 358760e141e1f87211ca831de6821003d80fe20a06f3Richard Smith 3588fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // If the requested function type does not match the actual type of the 3589092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor // specialization with respect to arguments of compatible pointer to function 3590092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor // types, template argument deduction fails. 3591092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor if (!ArgFunctionType.isNull()) { 3592092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor if (InOverloadResolution && !isSameOrCompatibleFunctionType( 3593092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor Context.getCanonicalType(Specialization->getType()), 3594092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor Context.getCanonicalType(ArgFunctionType))) 3595092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor return TDK_MiscellaneousDeductionFailure; 3596092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor else if(!InOverloadResolution && 3597092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor !Context.hasSameType(Specialization->getType(), ArgFunctionType)) 3598092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor return TDK_MiscellaneousDeductionFailure; 3599092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor } 3600fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 3601fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_Success; 3602e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor} 3603e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 360465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \brief Deduce template arguments for a templated conversion 360565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// function (C++ [temp.deduct.conv]) and, if successful, produce a 360665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// conversion function template specialization. 360765ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::TemplateDeductionResult 360865ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 360965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType ToType, 361065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor CXXConversionDecl *&Specialization, 361165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionInfo &Info) { 3612ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor if (FunctionTemplate->isInvalidDecl()) 3613ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor return TDK_Invalid; 3614ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor 36151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CXXConversionDecl *Conv 361665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()); 361765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType FromType = Conv->getConversionType(); 361865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 361965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Canonicalize the types for deduction. 362065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType P = Context.getCanonicalType(FromType); 362165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType A = Context.getCanonicalType(ToType); 362265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 36235453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p2: 362465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If P is a reference type, the type referred to by P is used for 362565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type deduction. 362665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *PRef = P->getAs<ReferenceType>()) 362765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = PRef->getPointeeType(); 362865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 36295453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p4: 36305453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // [...] If A is a reference type, the type referred to by A is used 363165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // for type deduction. 363265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *ARef = A->getAs<ReferenceType>()) 36335453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor A = ARef->getPointeeType().getUnqualifiedType(); 36345453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++ [temp.deduct.conv]p3: 363565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 36361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If A is not a reference type: 363765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else { 363865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor assert(!A->isReferenceType() && "Reference types were handled above"); 363965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 364065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is an array type, the pointer type produced by the 36411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // array-to-pointer standard conversion (4.2) is used in place 364265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // of P for type deduction; otherwise, 364365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (P->isArrayType()) 364465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getArrayDecayedType(P); 364565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a function type, the pointer type produced by the 364665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // function-to-pointer standard conversion (4.3) is used in 364765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // place of P for type deduction; otherwise, 364865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else if (P->isFunctionType()) 364965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getPointerType(P); 365065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a cv-qualified type, the top level cv-qualifiers of 36510099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // P's type are ignored for type deduction. 365265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else 365365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = P.getUnqualifiedType(); 365465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 36555453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p4: 36560099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // If A is a cv-qualified type, the top level cv-qualifiers of A's 36575453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // type are ignored for type deduction. If A is a reference type, the type 36585453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // referred to by A is used for type deduction. 365965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor A = A.getUnqualifiedType(); 366065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor } 366165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 366259a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 366359a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 36641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 366565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 366665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++ [temp.deduct.conv]p1: 366765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Template argument deduction is done by comparing the return 366865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type of the template conversion function (call it P) with the 366965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type that is required as the result of the conversion (call it 367065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A) as described in 14.8.2.4. 367165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateParameterList *TemplateParams 367265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = FunctionTemplate->getTemplateParameters(); 36735f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 36741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 367565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 367665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p4: 367765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // In general, the deduction process attempts to find template 367865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // argument values that will make the deduced A identical to 367965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A. However, there are two cases that allow a difference: 368065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor unsigned TDF = 0; 368165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If the original A is a reference type, A can be more 368265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // cv-qualified than the deduced A (i.e., the type referred to 368365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // by the reference) 368465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (ToType->isReferenceType()) 368565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_ParamWithReferenceType; 368665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - The deduced A can be another pointer or pointer to member 36870099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // type that can be converted to A via a qualification 368865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // conversion. 368965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 369065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when 369165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // both P and A are pointers or member pointers. In this case, we 369265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // just ignore cv-qualifiers completely). 369365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if ((P->isPointerType() && A->isPointerType()) || 36942cae1e216c12c7574f5ac59cb0844d22bed9401dDouglas Gregor (P->isMemberPointerType() && A->isMemberPointerType())) 369565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_IgnoreQualifiers; 369665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (TemplateDeductionResult Result 3697bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 3698bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl P, A, Info, Deduced, TDF)) 369965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 370065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 370165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Finish template argument deduction. 37022a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 370365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionDecl *Spec = 0; 370465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionResult Result 3705dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec, 370602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Info); 370765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor Specialization = cast_or_null<CXXConversionDecl>(Spec); 370865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 370965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 371065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 37114b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \brief Deduce template arguments for a function template when there is 37124b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// nothing to deduce against (C++0x [temp.arg.explicit]p3). 37134b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 37144b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 37154b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 37164b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 371740ae6666dd7a458f2d213370922a38be13f003c4James Dennett/// \param ExplicitTemplateArgs the explicitly-specified template 37184b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 37194b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 37204b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Specialization if template argument deduction was successful, 37214b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// this will be set to the function template specialization produced by 37224b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 37234b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 37244b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Info the argument will be updated to provide additional information 37254b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// about template argument deduction. 37264b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 37274b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \returns the result of template argument deduction. 37284b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::TemplateDeductionResult 37294b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 373067714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 37314b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionDecl *&Specialization, 3732092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor TemplateDeductionInfo &Info, 3733092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor bool InOverloadResolution) { 37344b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, 3735092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor QualType(), Specialization, Info, 3736092140a434366007a611c0a1a73fb6a4e8ff7f5eDouglas Gregor InOverloadResolution); 37374b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor} 37384b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor 373934b41d939a1328f484511c6002ba2456db879a29Richard Smithnamespace { 374034b41d939a1328f484511c6002ba2456db879a29Richard Smith /// Substitute the 'auto' type specifier within a type for a given replacement 374134b41d939a1328f484511c6002ba2456db879a29Richard Smith /// type. 374234b41d939a1328f484511c6002ba2456db879a29Richard Smith class SubstituteAutoTransform : 374334b41d939a1328f484511c6002ba2456db879a29Richard Smith public TreeTransform<SubstituteAutoTransform> { 374434b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType Replacement; 374534b41d939a1328f484511c6002ba2456db879a29Richard Smith public: 374634b41d939a1328f484511c6002ba2456db879a29Richard Smith SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) : 374734b41d939a1328f484511c6002ba2456db879a29Richard Smith TreeTransform<SubstituteAutoTransform>(SemaRef), Replacement(Replacement) { 374834b41d939a1328f484511c6002ba2456db879a29Richard Smith } 374934b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) { 375034b41d939a1328f484511c6002ba2456db879a29Richard Smith // If we're building the type pattern to deduce against, don't wrap the 375134b41d939a1328f484511c6002ba2456db879a29Richard Smith // substituted type in an AutoType. Certain template deduction rules 375234b41d939a1328f484511c6002ba2456db879a29Richard Smith // apply only when a template type parameter appears directly (and not if 375334b41d939a1328f484511c6002ba2456db879a29Richard Smith // the parameter is found through desugaring). For instance: 375434b41d939a1328f484511c6002ba2456db879a29Richard Smith // auto &&lref = lvalue; 375534b41d939a1328f484511c6002ba2456db879a29Richard Smith // must transform into "rvalue reference to T" not "rvalue reference to 375634b41d939a1328f484511c6002ba2456db879a29Richard Smith // auto type deduced as T" in order for [temp.deduct.call]p3 to apply. 375760e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (!Replacement.isNull() && isa<TemplateTypeParmType>(Replacement)) { 375834b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType Result = Replacement; 3759a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith TemplateTypeParmTypeLoc NewTL = 3760a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith TLB.push<TemplateTypeParmTypeLoc>(Result); 376134b41d939a1328f484511c6002ba2456db879a29Richard Smith NewTL.setNameLoc(TL.getNameLoc()); 376234b41d939a1328f484511c6002ba2456db879a29Richard Smith return Result; 376334b41d939a1328f484511c6002ba2456db879a29Richard Smith } else { 3764dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith bool Dependent = 3765dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith !Replacement.isNull() && Replacement->isDependentType(); 3766dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith QualType Result = 3767dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith SemaRef.Context.getAutoType(Dependent ? QualType() : Replacement, 3768dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith TL.getTypePtr()->isDecltypeAuto(), 3769dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith Dependent); 377034b41d939a1328f484511c6002ba2456db879a29Richard Smith AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); 377134b41d939a1328f484511c6002ba2456db879a29Richard Smith NewTL.setNameLoc(TL.getNameLoc()); 377234b41d939a1328f484511c6002ba2456db879a29Richard Smith return Result; 377334b41d939a1328f484511c6002ba2456db879a29Richard Smith } 377434b41d939a1328f484511c6002ba2456db879a29Richard Smith } 3775dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor 3776dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor ExprResult TransformLambdaExpr(LambdaExpr *E) { 3777dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor // Lambdas never need to be transformed. 3778dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor return E; 3779dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor } 37809b1317531d376738fd6631291b0a04109c76a63bRichard Smith 378160e141e1f87211ca831de6821003d80fe20a06f3Richard Smith QualType Apply(TypeLoc TL) { 378260e141e1f87211ca831de6821003d80fe20a06f3Richard Smith // Create some scratch storage for the transformed type locations. 378360e141e1f87211ca831de6821003d80fe20a06f3Richard Smith // FIXME: We're just going to throw this information away. Don't build it. 378460e141e1f87211ca831de6821003d80fe20a06f3Richard Smith TypeLocBuilder TLB; 378560e141e1f87211ca831de6821003d80fe20a06f3Richard Smith TLB.reserve(TL.getFullDataSize()); 378660e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return TransformType(TLB, TL); 37879b1317531d376738fd6631291b0a04109c76a63bRichard Smith } 378834b41d939a1328f484511c6002ba2456db879a29Richard Smith }; 378934b41d939a1328f484511c6002ba2456db879a29Richard Smith} 379034b41d939a1328f484511c6002ba2456db879a29Richard Smith 379160e141e1f87211ca831de6821003d80fe20a06f3Richard SmithSema::DeduceAutoResult 379260e141e1f87211ca831de6821003d80fe20a06f3Richard SmithSema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result) { 379360e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return DeduceAutoType(Type->getTypeLoc(), Init, Result); 379460e141e1f87211ca831de6821003d80fe20a06f3Richard Smith} 379560e141e1f87211ca831de6821003d80fe20a06f3Richard Smith 37969b1317531d376738fd6631291b0a04109c76a63bRichard Smith/// \brief Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) 379734b41d939a1328f484511c6002ba2456db879a29Richard Smith/// 379834b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Type the type pattern using the auto type-specifier. 379934b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Init the initializer for the variable whose type is to be deduced. 380034b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Result if type deduction was successful, this will be set to the 38019b1317531d376738fd6631291b0a04109c76a63bRichard Smith/// deduced type. 3802b832f6dea893f25b40500a04781286236281cb20Sebastian RedlSema::DeduceAutoResult 380360e141e1f87211ca831de6821003d80fe20a06f3Richard SmithSema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) { 380432509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall if (Init->getType()->isNonOverloadPlaceholderType()) { 38059b1317531d376738fd6631291b0a04109c76a63bRichard Smith ExprResult NonPlaceholder = CheckPlaceholderExpr(Init); 38069b1317531d376738fd6631291b0a04109c76a63bRichard Smith if (NonPlaceholder.isInvalid()) 38079b1317531d376738fd6631291b0a04109c76a63bRichard Smith return DAR_FailedAlreadyDiagnosed; 38089b1317531d376738fd6631291b0a04109c76a63bRichard Smith Init = NonPlaceholder.take(); 380932509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall } 381032509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall 381160e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (Init->isTypeDependent() || Type.getType()->isDependentType()) { 38129b1317531d376738fd6631291b0a04109c76a63bRichard Smith Result = SubstituteAutoTransform(*this, Context.DependentTy).Apply(Type); 381360e141e1f87211ca831de6821003d80fe20a06f3Richard Smith assert(!Result.isNull() && "substituting DependentTy can't fail"); 3814b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Succeeded; 381534b41d939a1328f484511c6002ba2456db879a29Richard Smith } 381634b41d939a1328f484511c6002ba2456db879a29Richard Smith 3817a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith // If this is a 'decltype(auto)' specifier, do the decltype dance. 3818a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith // Since 'decltype(auto)' can only occur at the top of the type, we 3819a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith // don't need to go digging for it. 382060e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (const AutoType *AT = Type.getType()->getAs<AutoType>()) { 3821a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith if (AT->isDecltypeAuto()) { 3822a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith if (isa<InitListExpr>(Init)) { 3823a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith Diag(Init->getLocStart(), diag::err_decltype_auto_initializer_list); 3824a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith return DAR_FailedAlreadyDiagnosed; 3825a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith } 3826a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith 3827a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith QualType Deduced = BuildDecltypeType(Init, Init->getLocStart()); 3828a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith // FIXME: Support a non-canonical deduced type for 'auto'. 3829a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith Deduced = Context.getCanonicalType(Deduced); 38309b1317531d376738fd6631291b0a04109c76a63bRichard Smith Result = SubstituteAutoTransform(*this, Deduced).Apply(Type); 383160e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (Result.isNull()) 383260e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return DAR_FailedAlreadyDiagnosed; 3833a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith return DAR_Succeeded; 3834a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith } 3835a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith } 3836a2c3646c35dd09d21b74826240aa916545b1873fRichard Smith 383734b41d939a1328f484511c6002ba2456db879a29Richard Smith SourceLocation Loc = Init->getExprLoc(); 383834b41d939a1328f484511c6002ba2456db879a29Richard Smith 383934b41d939a1328f484511c6002ba2456db879a29Richard Smith LocalInstantiationScope InstScope(*this); 384034b41d939a1328f484511c6002ba2456db879a29Richard Smith 384134b41d939a1328f484511c6002ba2456db879a29Richard Smith // Build template<class TemplParam> void Func(FuncParam); 38424fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl *TemplParam = 38434fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0, 38444fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth false, false); 38454fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); 38464fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth NamedDecl *TemplParamPtr = TemplParam; 3847483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr, 3848483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith Loc); 3849483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith 38509b1317531d376738fd6631291b0a04109c76a63bRichard Smith QualType FuncParam = SubstituteAutoTransform(*this, TemplArg).Apply(Type); 38519b1317531d376738fd6631291b0a04109c76a63bRichard Smith assert(!FuncParam.isNull() && 38529b1317531d376738fd6631291b0a04109c76a63bRichard Smith "substituting template parameter for 'auto' failed"); 385334b41d939a1328f484511c6002ba2456db879a29Richard Smith 385434b41d939a1328f484511c6002ba2456db879a29Richard Smith // Deduce type of TemplParam in Func(Init) 38555f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 1> Deduced; 385634b41d939a1328f484511c6002ba2456db879a29Richard Smith Deduced.resize(1); 385734b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType InitType = Init->getType(); 385834b41d939a1328f484511c6002ba2456db879a29Richard Smith unsigned TDF = 0; 385934b41d939a1328f484511c6002ba2456db879a29Richard Smith 386093e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Loc); 386162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 38628ad6c8696a23f410398fc126929b107404c59a95Richard Smith InitListExpr *InitList = dyn_cast<InitListExpr>(Init); 386362b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (InitList) { 386462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) { 38658ad6c8696a23f410398fc126929b107404c59a95Richard Smith if (DeduceTemplateArgumentByListElement(*this, &TemplateParams, 3866d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor TemplArg, 3867d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor InitList->getInit(i), 3868d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor Info, Deduced, TDF)) 3869b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 387062b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 387162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } else { 3872d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams, 3873d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor FuncParam, InitType, Init, 3874d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor TDF)) 3875d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor return DAR_Failed; 38768ad6c8696a23f410398fc126929b107404c59a95Richard Smith 387762b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam, 387862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl InitType, Info, Deduced, TDF)) 3879b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 388062b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 388134b41d939a1328f484511c6002ba2456db879a29Richard Smith 388270a01898008a90007866f15c4d9d53ba00b0d203Eli Friedman if (Deduced[0].getKind() != TemplateArgument::Type) 3883b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 388462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 388570a01898008a90007866f15c4d9d53ba00b0d203Eli Friedman QualType DeducedType = Deduced[0].getAsType(); 388670a01898008a90007866f15c4d9d53ba00b0d203Eli Friedman 388762b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (InitList) { 388862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl DeducedType = BuildStdInitializerList(DeducedType, Loc); 388962b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (DeducedType.isNull()) 3890b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_FailedAlreadyDiagnosed; 389162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 389262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 38939b1317531d376738fd6631291b0a04109c76a63bRichard Smith Result = SubstituteAutoTransform(*this, DeducedType).Apply(Type); 389460e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (Result.isNull()) 389560e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return DAR_FailedAlreadyDiagnosed; 389662b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 38979a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor // Check that the deduced argument type is compatible with the original 38989a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor // argument type per C++ [temp.deduct.call]p4. 38999b1317531d376738fd6631291b0a04109c76a63bRichard Smith if (!InitList && !Result.isNull() && 39009b1317531d376738fd6631291b0a04109c76a63bRichard Smith CheckOriginalCallArgDeduction(*this, 39019a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor Sema::OriginalCallArg(FuncParam,0,InitType), 39029b1317531d376738fd6631291b0a04109c76a63bRichard Smith Result)) { 39039b1317531d376738fd6631291b0a04109c76a63bRichard Smith Result = QualType(); 3904b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 39059a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor } 39069a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor 3907b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Succeeded; 390834b41d939a1328f484511c6002ba2456db879a29Richard Smith} 390934b41d939a1328f484511c6002ba2456db879a29Richard Smith 3910dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard SmithQualType Sema::SubstAutoType(QualType Type, QualType Deduced) { 3911dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith return SubstituteAutoTransform(*this, Deduced).TransformType(Type); 3912dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith} 3913dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith 391462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redlvoid Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) { 391562b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (isa<InitListExpr>(Init)) 391662b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl Diag(VDecl->getLocation(), 391762b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl diag::err_auto_var_deduction_failure_from_init_list) 391862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange(); 391962b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl else 392062b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl Diag(VDecl->getLocation(), diag::err_auto_var_deduction_failure) 392162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << VDecl->getDeclName() << VDecl->getType() << Init->getType() 392262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << Init->getSourceRange(); 392362b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl} 392462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 392560e141e1f87211ca831de6821003d80fe20a06f3Richard Smithbool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, 392660e141e1f87211ca831de6821003d80fe20a06f3Richard Smith bool Diagnose) { 392760e141e1f87211ca831de6821003d80fe20a06f3Richard Smith assert(FD->getResultType()->isUndeducedType()); 392860e141e1f87211ca831de6821003d80fe20a06f3Richard Smith 392960e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (FD->getTemplateInstantiationPattern()) 393060e141e1f87211ca831de6821003d80fe20a06f3Richard Smith InstantiateFunctionDefinition(Loc, FD); 393160e141e1f87211ca831de6821003d80fe20a06f3Richard Smith 393260e141e1f87211ca831de6821003d80fe20a06f3Richard Smith bool StillUndeduced = FD->getResultType()->isUndeducedType(); 393360e141e1f87211ca831de6821003d80fe20a06f3Richard Smith if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) { 393460e141e1f87211ca831de6821003d80fe20a06f3Richard Smith Diag(Loc, diag::err_auto_fn_used_before_defined) << FD; 393560e141e1f87211ca831de6821003d80fe20a06f3Richard Smith Diag(FD->getLocation(), diag::note_callee_decl) << FD; 393660e141e1f87211ca831de6821003d80fe20a06f3Richard Smith } 393760e141e1f87211ca831de6821003d80fe20a06f3Richard Smith 393860e141e1f87211ca831de6821003d80fe20a06f3Richard Smith return StillUndeduced; 393960e141e1f87211ca831de6821003d80fe20a06f3Richard Smith} 394060e141e1f87211ca831de6821003d80fe20a06f3Richard Smith 39418a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic void 39426fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, QualType T, 3943e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3944ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Level, 3945013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Deduced); 3946dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3947dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \brief If this is a non-static member function, 39481310aaca223be5001d58ba9c73fa03d484fd4582Craig Topperstatic void 39491310aaca223be5001d58ba9c73fa03d484fd4582Craig TopperAddImplicitObjectParameterType(ASTContext &Context, 39501310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper CXXMethodDecl *Method, 39511310aaca223be5001d58ba9c73fa03d484fd4582Craig Topper SmallVectorImpl<QualType> &ArgTypes) { 3952407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // C++11 [temp.func.order]p3: 3953407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // [...] The new parameter is of type "reference to cv A," where cv are 3954407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // the cv-qualifiers of the function template (if any) and A is 3955407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // the class of which the function template is a member. 395677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // 3957407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // The standard doesn't say explicitly, but we pick the appropriate kind of 3958407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // reference type based on [over.match.funcs]p4. 395977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor QualType ArgTy = Context.getTypeDeclType(Method->getParent()); 396077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTy = Context.getQualifiedType(ArgTy, 396177bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Qualifiers::fromCVRMask(Method->getTypeQualifiers())); 3962407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman if (Method->getRefQualifier() == RQ_RValue) 3963407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman ArgTy = Context.getRValueReferenceType(ArgTy); 3964407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman else 3965407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman ArgTy = Context.getLValueReferenceType(ArgTy); 396677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTypes.push_back(ArgTy); 396777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor} 396877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 39698a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \brief Determine whether the function template \p FT1 is at least as 39708a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// specialized as \p FT2. 39718a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic bool isAtLeastAsSpecializedAs(Sema &S, 39725769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 39738a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT1, 39748a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT2, 39758a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplatePartialOrderingContext TPOC, 3976dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi unsigned NumCallArguments, 39775f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) { 39788a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionDecl *FD1 = FT1->getTemplatedDecl(); 3979dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionDecl *FD2 = FT2->getTemplatedDecl(); 39808a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>(); 39818a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>(); 3982dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 39838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(Proto1 && Proto2 && "Function templates must have prototypes"); 39848a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); 39855f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 39868a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced.resize(TemplateParams->size()); 39878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 39888a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p3: 39898a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // The types used to determine the ordering depend on the context in which 39908a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // the partial ordering is done: 399193e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Loc); 39928d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method1 = 0; 39938d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method2 = 0; 39948d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic2 = false; 39958d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic1 = false; 39968d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor unsigned Skip2 = 0; 39978a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 39988a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 39998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a function call, the function parameter types are 40008a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used. 40018d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method1 = dyn_cast<CXXMethodDecl>(FD1); 40028d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method2 = dyn_cast<CXXMethodDecl>(FD2); 40038d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic1 = Method1 && !Method1->isStatic(); 40048d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic2 = Method2 && !Method2->isStatic(); 40058d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor 40069cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // C++11 [temp.func.order]p3: 40078d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // [...] If only one of the function templates is a non-static 40088d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // member, that function template is considered to have a new 40098d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // first parameter inserted in its function parameter list. The 40108d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // new parameter is of type "reference to cv A," where cv are 40118d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the cv-qualifiers of the function template (if any) and A is 40128d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the class of which the function template is a member. 40138d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // 40149cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // Note that we interpret this to mean "if one of the function 40159cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // templates is a non-static member and the other is a non-member"; 40169cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // otherwise, the ordering rules for static functions against non-static 40179cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // functions don't make any sense. 40189cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // 40198d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // C++98/03 doesn't have this provision, so instead we drop the 40209cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // first argument of the free function, which seems to match 40219cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // existing practice. 40225f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> Args1; 402380ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith unsigned Skip1 = !S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !Method1; 402480ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith if (S.getLangOpts().CPlusPlus11 && IsNonStatic1 && !Method2) 4025407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman AddImplicitObjectParameterType(S.Context, Method1, Args1); 4026dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Args1.insert(Args1.end(), 40278d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end()); 402877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 40295f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> Args2; 403080ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith Skip2 = !S.getLangOpts().CPlusPlus11 && IsNonStatic1 && !Method2; 403180ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith if (S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !Method1) 4032407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman AddImplicitObjectParameterType(S.Context, Method2, Args2); 4033dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Args2.insert(Args2.end(), 40348d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end()); 4035dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 40365c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++ [temp.func.order]p5: 40375c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // The presence of unused ellipsis and default arguments has no effect on 40385c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // the partial ordering of function templates. 40395c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Args1.size() > NumCallArguments) 40405c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args1.resize(NumCallArguments); 40415c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Args2.size() > NumCallArguments) 40425c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args2.resize(NumCallArguments); 40435c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(), 40445c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args1.data(), Args1.size(), Info, Deduced, 40455c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TDF_None, /*PartialOrdering=*/true, 4046b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons)) 40478a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 4048dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 40498a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 40508a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 4051dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 40528a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 40538a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a call to a conversion operator, the return types 40548a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // of the conversion function templates are used. 4055bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 4056bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Proto2->getResultType(), 4057bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Proto1->getResultType(), 4058bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF_None, 4059bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl /*PartialOrdering=*/true, 4060bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 40618a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 40628a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 4063dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 40648a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 40650099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // - In other contexts (14.6.6.2) the function template's function type 40668a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // is used. 4067bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 4068bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FD2->getType(), FD1->getType(), 4069bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF_None, 4070bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl /*PartialOrdering=*/true, 4071bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 40728a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 40738a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 40748a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 4075dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 40768a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p11: 4077dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // In most cases, all template parameters must have values in order for 4078dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // deduction to succeed, but for partial ordering purposes a template 4079dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // parameter may remain without a value provided it is not used in the 40808a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // types being used for partial ordering. [ Note: a template parameter used 40818a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // in a non-deduced context is considered used. -end note] 40828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor unsigned ArgIdx = 0, NumArgs = Deduced.size(); 40838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 40848a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull()) 40858a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 40868a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 40878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (ArgIdx == NumArgs) { 4088dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // All template arguments were deduced. FT1 is at least as specialized 40898a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // as FT2. 40908a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 40918a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 40928a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 4093e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // Figure out which template parameters were used. 4094013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector UsedParameters(TemplateParams->size()); 40958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 40968a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 4097dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi unsigned NumParams = std::min(NumCallArguments, 4098dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi std::min(Proto1->getNumArgs(), 40995c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Proto2->getNumArgs())); 410080ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith if (S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !IsNonStatic1) 41016fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Method2->getThisType(S.Context), 41026fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis false, 41038d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor TemplateParams->getDepth(), UsedParameters); 41048d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor for (unsigned I = Skip2; I < NumParams; ++I) 41056fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Proto2->getArgType(I), false, 4106ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 4107e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 41088a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 41098a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 4110dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41118a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 41126fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Proto2->getResultType(), false, 4113ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 4114e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 41158a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 4116dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41178a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 41186fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false, 4119ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 4120ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor UsedParameters); 41218a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 41228a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 4123dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 41258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If this argument had no value deduced but was used in one of the types 41268a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used for partial ordering, then deduction fails. 41278a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) 41288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 4129dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41308a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 41318a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor} 4132dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41339da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor/// \brief Determine whether this a function template whose parameter-type-list 41349da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor/// ends with a function parameter pack. 41359da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregorstatic bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { 41369da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor FunctionDecl *Function = FunTmpl->getTemplatedDecl(); 41379da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor unsigned NumParams = Function->getNumParams(); 41389da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (NumParams == 0) 41399da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 4140dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41419da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor ParmVarDecl *Last = Function->getParamDecl(NumParams - 1); 41429da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (!Last->isParameterPack()) 41439da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 4144dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41459da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // Make sure that no previous parameter is a parameter pack. 41469da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor while (--NumParams > 0) { 41479da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (Function->getParamDecl(NumParams - 1)->isParameterPack()) 41489da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 41499da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor } 4150dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41519da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return true; 41529da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor} 4153dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4154bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized function template according 415565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// to the rules of function template partial ordering (C++ [temp.func.order]). 415665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 415765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT1 the first function template 415865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 415965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT2 the second function template 416065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 41618a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param TPOC the context in which we are performing partial ordering of 41628a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// function templates. 41631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 41645c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param NumCallArguments The number of arguments in a call, used only 41655c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when \c TPOC is \c TPOC_Call. 41665c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 4167bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized function template. If neither 416865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// template is more specialized, returns NULL. 416965ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorFunctionTemplateDecl * 417065ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, 417165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionTemplateDecl *FT2, 41725769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 41735c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TemplatePartialOrderingContext TPOC, 41745c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumCallArguments) { 41755f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons; 4176dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, 41775c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NumCallArguments, 0); 4178dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, 41795c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NumCallArguments, 4180b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor &RefParamComparisons); 4181dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better1 != Better2) // We have a clear winner 41838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return Better1? FT1 : FT2; 4184dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41858a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (!Better1 && !Better2) // Neither is better than the other 418665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return 0; 41878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 41888a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p10: 4189dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If for each type being considered a given template is at least as 41908a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized for all types and more specialized for some set of types and 4191dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the other template is not more specialized for any types or is not at 41928a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // least as specialized for any types, then the given template is more 41938a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other template. Otherwise, neither template is more 41948a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other. 41958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better1 = false; 41968a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better2 = false; 4197b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) { 41988a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p9: 41998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If, for a given type, deduction succeeds in both directions (i.e., the 4200b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // types are identical after the transformations above) and both P and A 4201b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // were reference types (before being replaced with the type referred to 4202b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // above): 4203b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 4204dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // -- if the type from the argument template was an lvalue reference 4205b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // and the type from the parameter template was not, the argument 4206b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // type is considered to be more specialized than the other; 4207b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // otherwise, 4208b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (!RefParamComparisons[I].ArgIsRvalueRef && 4209b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons[I].ParamIsRvalueRef) { 4210b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better2 = true; 4211b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better1) 4212b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 4213b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 4214b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor } else if (!RefParamComparisons[I].ParamIsRvalueRef && 4215b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons[I].ArgIsRvalueRef) { 4216b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better1 = true; 4217b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better2) 4218b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 4219b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 4220b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor } 4221dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4222b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // -- if the type from the argument template is more cv-qualified than 4223b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // the type from the parameter template (as described above), the 4224b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // argument type is considered to be more specialized than the 4225b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // other; otherwise, 4226b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor switch (RefParamComparisons[I].Qualifiers) { 4227b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case NeitherMoreQualified: 4228b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor break; 4229dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4230b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case ParamMoreQualified: 4231b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better1 = true; 4232b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better2) 4233b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 4234b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 4235dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4236b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case ArgMoreQualified: 4237b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better2 = true; 4238b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better1) 4239b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 4240b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 42418a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 4242dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4243b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // -- neither type is more specialized than the other. 42448a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 4245dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 42468a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(!(Better1 && Better2) && "Should have broken out in the loop above"); 424765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (Better1) 424865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return FT1; 42498a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor else if (Better2) 42508a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return FT2; 4251dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 42529da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // FIXME: This mimics what GCC implements, but doesn't match up with the 42539da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // proposed resolution for core issue 692. This area needs to be sorted out, 42549da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // but for now we attempt to maintain compatibility. 42559da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor bool Variadic1 = isVariadicFunctionTemplate(FT1); 42569da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor bool Variadic2 = isVariadicFunctionTemplate(FT2); 42579da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (Variadic1 != Variadic2) 42589da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return Variadic1? FT2 : FT1; 4259dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 42609da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return 0; 426165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 426283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 4263d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Determine if the two templates are equivalent. 4264d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregorstatic bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { 4265d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (T1 == T2) 4266d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return true; 4267dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4268d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!T1 || !T2) 4269d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return false; 4270dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4271d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return T1->getCanonicalDecl() == T2->getCanonicalDecl(); 4272d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 4273d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 4274d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Retrieve the most specialized of the given function template 4275d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specializations. 4276d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4277c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecBegin the start iterator of the function template 4278c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations that we will be comparing. 4279d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4280c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecEnd the end iterator of the function template 4281c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations, paired with \p SpecBegin. 4282d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4283d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param TPOC the partial ordering context to use to compare the function 4284d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template specializations. 4285d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 42865c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param NumCallArguments The number of arguments in a call, used only 42875c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when \c TPOC is \c TPOC_Call. 42885c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 4289dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \param Loc the location where the ambiguity or no-specializations 4290d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// diagnostic should occur. 4291d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4292d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param NoneDiag partial diagnostic used to diagnose cases where there are 4293d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// no matching candidates. 4294d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4295d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one 4296d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// occurs. 4297d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4298d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param CandidateDiag partial diagnostic used for each function template 4299d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specialization that is a candidate in the ambiguous ordering. One parameter 4300d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// in this diagnostic should be unbound, which will correspond to the string 4301d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// describing the template arguments for the function template specialization. 4302d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4303dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \returns the most specialized function template specialization, if 4304c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// found. Otherwise, returns SpecEnd. 43054384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse VoufoUnresolvedSetIterator Sema::getMostSpecialized( 43064384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo UnresolvedSetIterator SpecBegin, UnresolvedSetIterator SpecEnd, 43074384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo TemplateSpecCandidateSet &FailedCandidates, 43084384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo TemplatePartialOrderingContext TPOC, unsigned NumCallArguments, 43094384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo SourceLocation Loc, const PartialDiagnostic &NoneDiag, 43104384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, 43114384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo bool Complain, QualType TargetType) { 4312c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (SpecBegin == SpecEnd) { 43134384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo if (Complain) { 43141be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor Diag(Loc, NoneDiag); 43154384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo FailedCandidates.NoteCandidates(*this, Loc); 43164384712b3a0aedd7c68d6abdb0407850f7b46c8bLarisse Voufo } 4317c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 4318d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4319dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4320dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (SpecBegin + 1 == SpecEnd) 4321c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecBegin; 4322dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4323d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Find the function template that is better than all of the templates it 4324d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // has been compared to. 4325c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall UnresolvedSetIterator Best = SpecBegin; 4326dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionTemplateDecl *BestTemplate 4327c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*Best)->getPrimaryTemplate(); 4328d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(BestTemplate && "Not a function template specialization?"); 4329c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) { 4330c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 4331c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 4332d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(Challenger && "Not a function template specialization?"); 4333c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 43345c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Loc, TPOC, NumCallArguments), 4335d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Challenger)) { 4336d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Best = I; 4337d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate = Challenger; 4338d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4339d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4340dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4341d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Make sure that the "best" function template is more specialized than all 4342d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // of the others. 4343d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor bool Ambiguous = false; 4344c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { 4345c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 4346c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 4347d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (I != Best && 4348dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 43495c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Loc, TPOC, NumCallArguments), 4350d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate)) { 4351d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Ambiguous = true; 4352d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor break; 4353d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4354d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4355dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4356d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!Ambiguous) { 4357d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // We found an answer. Return it. 4358c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return Best; 4359d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4360dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4361d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Diagnose the ambiguity. 4362df6217ec356f1e8f440ea7222be3603c011a295dRichard Smith if (Complain) { 43631be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor Diag(Loc, AmbigDiag); 4364dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4365df6217ec356f1e8f440ea7222be3603c011a295dRichard Smith // FIXME: Can we order the candidates in some sane way? 43666efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { 43676efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu PartialDiagnostic PD = CandidateDiag; 43686efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu PD << getTemplateArgumentBindingsText( 43691be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(), 4370c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs()); 43716efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu if (!TargetType.isNull()) 43726efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu HandleFunctionTypeMismatch(PD, cast<FunctionDecl>(*I)->getType(), 43736efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu TargetType); 43746efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu Diag((*I)->getLocation(), PD); 43756efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu } 4376df6217ec356f1e8f440ea7222be3603c011a295dRichard Smith } 4377dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4378c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 4379d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 4380d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 4381bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized class template partial specialization 4382bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// according to the rules of partial ordering of class template partial 4383bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// specializations (C++ [temp.class.order]). 4384bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4385bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS1 the first class template partial specialization 4386bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4387bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS2 the second class template partial specialization 4388bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4389bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized class template partial specialization. If 4390bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// neither partial specialization is more specialized, returns NULL. 4391bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorClassTemplatePartialSpecializationDecl * 4392bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorSema::getMoreSpecializedPartialSpecialization( 4393bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor ClassTemplatePartialSpecializationDecl *PS1, 43945769d6195087229770d7ac90449443e026c47103John McCall ClassTemplatePartialSpecializationDecl *PS2, 43955769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc) { 4396bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // C++ [temp.class.order]p1: 4397bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // For two class template partial specializations, the first is at least as 4398dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // specialized as the second if, given the following rewrite to two 4399dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // function templates, the first function template is at least as 4400dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // specialized as the second according to the ordering rules for function 4401bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // templates (14.6.6.2): 4402bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the first function template has the same template parameters as the 4403dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // first partial specialization and has a single function parameter 4404dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // whose type is a class template specialization with the template 4405bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the first partial specialization, and 4406bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the second function template has the same template parameters as the 4407dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // second partial specialization and has a single function parameter 4408dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // whose type is a class template specialization with the template 4409bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the second partial specialization. 4410bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // 441131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // Rather than synthesize function templates, we merely perform the 441231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // equivalent partial ordering by performing deduction directly on 441331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // the template arguments of the class template partial 441431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specializations. This computation is slightly simpler than the 441531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // general problem of function template partial ordering, because 441631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // class template partial specializations are more constrained. We 441731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // know that every template parameter is deducible from the class 441831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // template partial specialization's template arguments, for 441931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // example. 44205f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 442193e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Loc); 442231f17ecbef57b5679c017c375db330546b7b5145John McCall 442331f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT1 = PS1->getInjectedSpecializationType(); 442431f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT2 = PS2->getInjectedSpecializationType(); 4425dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4426bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS1 is at least as specialized as PS2 4427bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS2->getTemplateParameters()->size()); 4428bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this, 4429bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PS2->getTemplateParameters(), 44305c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PT2, PT1, Info, Deduced, TDF_None, 4431dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi /*PartialOrdering=*/true, 4432b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /*RefParamComparisons=*/0); 44332c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better1) { 44347e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end()); 4435ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, DeducedArgs, 4436ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info); 4437ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Better1 = !::FinishTemplateArgumentDeduction( 4438ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo *this, PS2, PS1->getTemplateArgs(), Deduced, Info); 4439ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 4440ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 4441ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // Determine whether PS2 is at least as specialized as PS1 4442ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Deduced.clear(); 4443ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Deduced.resize(PS1->getTemplateParameters()->size()); 4444ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo bool Better2 = !DeduceTemplateArgumentsByTypeMatch( 4445ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo *this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, 4446ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo /*PartialOrdering=*/true, 4447ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo /*RefParamComparisons=*/0); 4448ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (Better2) { 4449ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), 4450ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Deduced.end()); 4451ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, DeducedArgs, 4452ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Info); 4453ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Better2 = !::FinishTemplateArgumentDeduction( 4454ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo *this, PS1, PS2->getTemplateArgs(), Deduced, Info); 4455ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo } 4456ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 4457ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (Better1 == Better2) 4458ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return 0; 4459ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 4460ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo return Better1 ? PS1 : PS2; 4461ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo} 4462ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 4463ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo/// TODO: Unify with ClassTemplatePartialSpecializationDecl version. 4464ef4579cda09b73e3d4d98af48201da25adc29326Larisse VoufoVarTemplatePartialSpecializationDecl * 4465ef4579cda09b73e3d4d98af48201da25adc29326Larisse VoufoSema::getMoreSpecializedPartialSpecialization( 4466ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo VarTemplatePartialSpecializationDecl *PS1, 4467ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { 4468ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SmallVector<DeducedTemplateArgument, 4> Deduced; 4469ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateDeductionInfo Info(Loc); 4470ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 4471ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo assert(PS1->getSpecializedTemplate() == PS1->getSpecializedTemplate() && 4472ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo "the partial specializations being compared should specialize" 4473ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo " the same template."); 4474ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateName Name(PS1->getSpecializedTemplate()); 4475ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name); 4476ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo QualType PT1 = Context.getTemplateSpecializationType( 4477ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo CanonTemplate, PS1->getTemplateArgs().data(), 4478ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo PS1->getTemplateArgs().size()); 4479ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo QualType PT2 = Context.getTemplateSpecializationType( 4480ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo CanonTemplate, PS2->getTemplateArgs().data(), 4481ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo PS2->getTemplateArgs().size()); 4482ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo 4483ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo // Determine whether PS1 is at least as specialized as PS2 4484ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Deduced.resize(PS2->getTemplateParameters()->size()); 4485ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo bool Better1 = !DeduceTemplateArgumentsByTypeMatch( 4486ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo *this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, 4487ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo /*PartialOrdering=*/true, 4488ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo /*RefParamComparisons=*/0); 4489ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo if (Better1) { 4490ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), 4491ef4579cda09b73e3d4d98af48201da25adc29326Larisse Voufo Deduced.end()); 44922c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, 44937e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith DeducedArgs, Info); 4494dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, 4495dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PS1->getTemplateArgs(), 4496516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 44972c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 4498dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4499bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS2 is at least as specialized as PS1 4500db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Deduced.clear(); 4501bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS1->getTemplateParameters()->size()); 4502bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this, 4503bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PS1->getTemplateParameters(), 45045c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PT1, PT2, Info, Deduced, TDF_None, 45055c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor /*PartialOrdering=*/true, 4506b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /*RefParamComparisons=*/0); 45072c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better2) { 45087e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end()); 45092c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, 45107e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith DeducedArgs, Info); 4511dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, 4512dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PS2->getTemplateArgs(), 4513516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 45142c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 4515dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4516bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor if (Better1 == Better2) 4517bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return 0; 4518dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4519bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return Better1? PS1 : PS2; 4520bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor} 4521bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 45221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 45236fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4524e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 4525e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4526ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4527013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used); 4528031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4529e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4530031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// expression. 45311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 45326fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4533e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const Expr *E, 4534e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4535ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4536013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4537be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor // We can deduce from a pack expansion. 4538be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E)) 4539be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor E = Expansion->getPattern(); 4540dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 45416098381c29c2693832aa81ef046cf21a49729436Richard Smith // Skip through any implicit casts we added while type-checking, and any 45426098381c29c2693832aa81ef046cf21a49729436Richard Smith // substitutions performed by template alias expansion. 45436098381c29c2693832aa81ef046cf21a49729436Richard Smith while (1) { 45446098381c29c2693832aa81ef046cf21a49729436Richard Smith if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 45456098381c29c2693832aa81ef046cf21a49729436Richard Smith E = ICE->getSubExpr(); 45466098381c29c2693832aa81ef046cf21a49729436Richard Smith else if (const SubstNonTypeTemplateParmExpr *Subst = 45476098381c29c2693832aa81ef046cf21a49729436Richard Smith dyn_cast<SubstNonTypeTemplateParmExpr>(E)) 45486098381c29c2693832aa81ef046cf21a49729436Richard Smith E = Subst->getReplacement(); 45496098381c29c2693832aa81ef046cf21a49729436Richard Smith else 45506098381c29c2693832aa81ef046cf21a49729436Richard Smith break; 45516098381c29c2693832aa81ef046cf21a49729436Richard Smith } 4552dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4553dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to 4554e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // find other occurrences of template parameters. 4555f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 4556c781f9cd854f3d5d1c826f4a13382c6abca4cff7Douglas Gregor if (!DRE) 4557031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4558031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 45591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const NonTypeTemplateParmDecl *NTTP 4560031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 4561031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!NTTP) 4562031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4563031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4564ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (NTTP->getDepth() == Depth) 4565ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[NTTP->getIndex()] = true; 4566031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4567031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4568e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4569e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// nested name specifier. 4570e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 45716fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4572e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor NestedNameSpecifier *NNS, 4573e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4574ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4575013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4576e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!NNS) 4577e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4578dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 45796fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth, 4580ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 45816fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0), 4582ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4583e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 4584dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4585e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4586e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// template name. 4587e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 45886fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4589e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor TemplateName Name, 4590e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4591ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4592013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4593e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 4594e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateTemplateParmDecl *TTP 4595ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(Template)) { 4596ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 4597ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 4598ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 4599e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4600e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 4601dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4602788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) 46036fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced, 4604788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Depth, Used); 4605e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) 46066fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced, 4607ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4608e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 4609e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 4610e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4611031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// type. 46121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 46136fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, QualType T, 4614e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4615ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4616013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4617e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (T.isNull()) 4618e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4619dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4620031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Non-dependent types have nothing deducible 4621031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!T->isDependentType()) 4622031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4623031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 46246fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis T = Ctx.getCanonicalType(T); 4625031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (T->getTypeClass()) { 4626031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Pointer: 46276fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4628e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<PointerType>(T)->getPointeeType(), 4629e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4630ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4631e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4632031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4633031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4634031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::BlockPointer: 46356fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4636e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<BlockPointerType>(T)->getPointeeType(), 4637e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4638ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4639e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4640031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4641031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4642031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::LValueReference: 4643031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::RValueReference: 46446fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4645e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ReferenceType>(T)->getPointeeType(), 4646e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4647ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4648e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4649031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4650031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4651031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::MemberPointer: { 4652031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr()); 46536fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced, 4654ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 46556fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0), 4656ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4657031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4658031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4659031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4660031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::DependentSizedArray: 46616fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4662e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<DependentSizedArrayType>(T)->getSizeExpr(), 4663ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4664031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Fall through to check the element type 4665031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4666031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ConstantArray: 4667031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::IncompleteArray: 46686fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4669e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ArrayType>(T)->getElementType(), 4670ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4671031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4672031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4673031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Vector: 4674031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ExtVector: 46756fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4676e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<VectorType>(T)->getElementType(), 4677ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4678031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4679031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 46809cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor case Type::DependentSizedExtVector: { 46819cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor const DependentSizedExtVectorType *VecType 4682f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<DependentSizedExtVectorType>(T); 46836fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, 4684ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 46856fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, 4686ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 46879cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor break; 46889cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 46899cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 4690031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionProto: { 4691f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 46926fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Proto->getResultType(), OnlyDeduced, 4693ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4694031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I) 46956fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Proto->getArgType(I), OnlyDeduced, 4696ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4697031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4698031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4699031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4700ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor case Type::TemplateTypeParm: { 4701ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T); 4702ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 4703ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 4704031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4705ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 4706031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 47070bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor case Type::SubstTemplateTypeParmPack: { 47080bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor const SubstTemplateTypeParmPackType *Subst 47090bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor = cast<SubstTemplateTypeParmPackType>(T); 47106fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 47110bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor QualType(Subst->getReplacedParameter(), 0), 47120bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor OnlyDeduced, Depth, Used); 47136fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(), 47140bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor OnlyDeduced, Depth, Used); 47150bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor break; 47160bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor } 47170bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor 471831f17ecbef57b5679c017c375db330546b7b5145John McCall case Type::InjectedClassName: 471931f17ecbef57b5679c017c375db330546b7b5145John McCall T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType(); 472031f17ecbef57b5679c017c375db330546b7b5145John McCall // fall through 472131f17ecbef57b5679c017c375db330546b7b5145John McCall 4722031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::TemplateSpecialization: { 47231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const TemplateSpecializationType *Spec 4724f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<TemplateSpecializationType>(T); 47256fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced, 4726ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4727dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 47287b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4729dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4730dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 47317b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4732dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 47337b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 47347b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 47357b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 4736e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 47376fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, 4738ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 4739e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 4740e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 47411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4742e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor case Type::Complex: 4743e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 47446fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4745e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ComplexType>(T)->getElementType(), 4746ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4747e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 4748031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4749b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 4750b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (!OnlyDeduced) 47516fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4752b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman cast<AtomicType>(T)->getValueType(), 4753b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman OnlyDeduced, Depth, Used); 4754b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 4755b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 47564714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 4757e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 47586fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 47594714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor cast<DependentNameType>(T)->getQualifier(), 4760ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4761031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4762031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 476333500955d731c73717af52088b7fc0e7a85681e7John McCall case Type::DependentTemplateSpecialization: { 476433500955d731c73717af52088b7fc0e7a85681e7John McCall const DependentTemplateSpecializationType *Spec 476533500955d731c73717af52088b7fc0e7a85681e7John McCall = cast<DependentTemplateSpecializationType>(T); 476633500955d731c73717af52088b7fc0e7a85681e7John McCall if (!OnlyDeduced) 47676fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getQualifier(), 476833500955d731c73717af52088b7fc0e7a85681e7John McCall OnlyDeduced, Depth, Used); 4769dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 47707b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4771dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4772dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 47737b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4774dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 47757b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 47767b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 47777b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 477833500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 47796fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, 478033500955d731c73717af52088b7fc0e7a85681e7John McCall Used); 478133500955d731c73717af52088b7fc0e7a85681e7John McCall break; 478233500955d731c73717af52088b7fc0e7a85681e7John McCall } 478333500955d731c73717af52088b7fc0e7a85681e7John McCall 4784ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOf: 4785ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 47866fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4787ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfType>(T)->getUnderlyingType(), 4788ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4789ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4790ad5e73887052193afda72db8efcb812bd083a4a8John McCall 4791ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOfExpr: 4792ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 47936fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4794ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfExprType>(T)->getUnderlyingExpr(), 4795ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4796ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4797ad5e73887052193afda72db8efcb812bd083a4a8John McCall 4798ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::Decltype: 4799ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 48006fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4801ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<DecltypeType>(T)->getUnderlyingExpr(), 4802ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4803ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4804ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 4805ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 4806ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt if (!OnlyDeduced) 48076fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4808ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt cast<UnaryTransformType>(T)->getUnderlyingType(), 4809ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt OnlyDeduced, Depth, Used); 4810ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt break; 4811ad5e73887052193afda72db8efcb812bd083a4a8John McCall 48127536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor case Type::PackExpansion: 48136fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 48147536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor cast<PackExpansionType>(T)->getPattern(), 48157536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor OnlyDeduced, Depth, Used); 48167536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor break; 48177536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 481834b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: 48196fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 482034b41d939a1328f484511c6002ba2456db879a29Richard Smith cast<AutoType>(T)->getDeducedType(), 482134b41d939a1328f484511c6002ba2456db879a29Richard Smith OnlyDeduced, Depth, Used); 482234b41d939a1328f484511c6002ba2456db879a29Richard Smith 4823e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // None of these types have any template parameters in them. 4824031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Builtin: 4825031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::VariableArray: 4826031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionNoProto: 4827031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Record: 4828031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Enum: 4829031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ObjCInterface: 4830c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 4831d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 4832ed97649e9574b9d854fa4d6109c9333ae0993554John McCall case Type::UnresolvedUsing: 4833031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define TYPE(Class, Base) 4834031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 4835031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define DEPENDENT_TYPE(Class, Base) 4836031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 4837031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#include "clang/AST/TypeNodes.def" 4838031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4839031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4840031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4841031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4842e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by this 4843031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument. 48441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 48456fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4846e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 4847e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4848ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4849013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4850031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (TemplateArg.getKind()) { 4851031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Null: 4852031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Integral: 4853d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor case TemplateArgument::Declaration: 4854031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 48551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4856d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: 4857d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced, 4858d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Depth, Used); 4859d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman break; 4860d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 4861031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Type: 48626fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced, 4863ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4864031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4865031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4866788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 4867a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 48686fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4869dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArg.getAsTemplateOrTemplatePattern(), 4870788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor OnlyDeduced, Depth, Used); 4871031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4872031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4873031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Expression: 48746fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced, 4875ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4876031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4877dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4878d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 4879e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(), 4880e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor PEnd = TemplateArg.pack_end(); 4881e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor P != PEnd; ++P) 48826fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used); 4883d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson break; 4884031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4885031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4886031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 488716ae9de07730832945204877d752db7f1c070962James Dennett/// \brief Mark which template parameters can be deduced from a given 4888031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument list. 4889031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 4890031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param TemplateArgs the template argument list from which template 4891031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// parameters will be deduced. 4892031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 489316ae9de07730832945204877d752db7f1c070962James Dennett/// \param Used a bit vector whose elements will be set to \c true 4894031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// to indicate when the corresponding template parameter will be 4895031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// deduced. 48961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 4897e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorSema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, 4898ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor bool OnlyDeduced, unsigned Depth, 4899013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 49007b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4901dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4902dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 49037b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4904dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 49057b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size())) 49067b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return; 49077b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 4908031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 49096fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced, 4910ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4911031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 491263f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor 491363f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// \brief Marks all of the template parameters that will be deduced by a 491463f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// call to the given function template. 4915dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumivoid 49166fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisSema::MarkDeducedTemplateParameters(ASTContext &Ctx, 491789cf425f1136f8d24a64ed94450e488b6794dfa4Dmitri Gribenko const FunctionTemplateDecl *FunctionTemplate, 4918013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Deduced) { 4919dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateParameterList *TemplateParams 492063f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor = FunctionTemplate->getTemplateParameters(); 492163f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.clear(); 492263f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.resize(TemplateParams->size()); 4923dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 492463f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 492563f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 49266fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(), 4927ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor true, TemplateParams->getDepth(), Deduced); 492863f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor} 4929dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4930dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregorbool hasDeducibleTemplateParameters(Sema &S, 4931dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor FunctionTemplateDecl *FunctionTemplate, 4932dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType T) { 4933dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (!T->isDependentType()) 4934dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor return false; 4935dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4936dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor TemplateParameterList *TemplateParams 4937dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor = FunctionTemplate->getTemplateParameters(); 4938013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector Deduced(TemplateParams->size()); 49396fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), 4940dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor Deduced); 4941dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4942013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer return Deduced.any(); 4943dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor} 4944