SemaTemplateDeduction.cpp revision d10099e5c8238fa0327f03921cf2e3c8975c881e
10b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/ 20b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 30b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// The LLVM Compiler Infrastructure 40b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 50b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// This file is distributed under the University of Illinois Open Source 60b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// License. See LICENSE.TXT for details. 70b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===----------------------------------------------------------------------===/ 80b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 90b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// This file implements C++ template argument deduction. 100b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 110b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===----------------------------------------------------------------------===/ 120b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 13e737f5041a36d0befb39ffeed8d50ba15916d3daDouglas Gregor#include "clang/Sema/Sema.h" 1419510856727e0e14a3696b2a72c35163bff2a71fJohn McCall#include "clang/Sema/DeclSpec.h" 157cd088e519d7e6caa4c4c12db52e0e4ae35d25c2John McCall#include "clang/Sema/Template.h" 162a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall#include "clang/Sema/TemplateDeduction.h" 170b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ASTContext.h" 187cd088e519d7e6caa4c4c12db52e0e4ae35d25c2John McCall#include "clang/AST/DeclObjC.h" 190b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/DeclTemplate.h" 200b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/StmtVisitor.h" 210b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/Expr.h" 220b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ExprCXX.h" 23013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer#include "llvm/ADT/SmallBitVector.h" 2434b41d939a1328f484511c6002ba2456db879a29Richard Smith#include "TreeTransform.h" 258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor#include <algorithm> 26508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 27508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregornamespace clang { 282a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall using namespace sema; 292a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall 30508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Various flags that control template argument deduction. 31508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// 32508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// These flags can be bitwise-OR'd together. 33508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor enum TemplateDeductionFlags { 34508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief No template argument deduction flags, which indicates the 35508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// strictest results for template argument deduction (as used for, e.g., 36508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// matching class template partial specializations). 37508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_None = 0, 38508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, we are 39508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// matching with a parameter type for which the original parameter was 40508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// a reference. 41508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_ParamWithReferenceType = 0x1, 42508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, we 43508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// are matching in a case where we ignore cv-qualifiers. 44508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_IgnoreQualifiers = 0x02, 45508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, 46508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// we are matching in a case where we can perform template argument 474112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor /// deduction from a template-id of a derived class of the argument type. 481282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor TDF_DerivedClass = 0x04, 491282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// \brief Allow non-dependent types to differ, e.g., when performing 501282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// template argument deduction from a function call where conversions 511282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// may apply. 5273b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor TDF_SkipNonDependent = 0x08, 5373b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor /// \brief Whether we are performing template argument deduction for 54dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi /// parameters and arguments in a top-level template argument 5573b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor TDF_TopLevelParameterTypeList = 0x10 56508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor }; 57508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor} 58508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 590b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregorusing namespace clang; 600b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 619d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// \brief Compare two APSInts, extending and switching the sign as 629d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// necessary to compare their values regardless of underlying type. 639d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregorstatic bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { 649d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (Y.getBitWidth() > X.getBitWidth()) 659f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad X = X.extend(Y.getBitWidth()); 669d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor else if (Y.getBitWidth() < X.getBitWidth()) 679f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad Y = Y.extend(X.getBitWidth()); 689d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 699d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If there is a signedness mismatch, correct it. 709d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (X.isSigned() != Y.isSigned()) { 719d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If the signed value is negative, then the values cannot be the same. 729d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) 739d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return false; 749d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 759d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Y.setIsSigned(true); 769d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor X.setIsSigned(true); 779d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor } 789d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 799d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return X == Y; 809d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor} 819d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 82f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 83a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 84f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 85f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 8677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor TemplateArgument Arg, 872a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 885f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced); 89d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 90b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \brief Whether template argument deduction for two reference parameters 91b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// resulted in the argument type, parameter type, or neither type being more 92b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// qualified than the other. 93dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumienum DeductionQualifierComparison { 94dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NeitherMoreQualified = 0, 95dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ParamMoreQualified, 96dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ArgMoreQualified 975c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor}; 985c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 99b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \brief Stores the result of comparing two reference parameters while 100b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// performing template argument deduction for partial ordering of function 101dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// templates. 102b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregorstruct RefParamPartialOrderingComparison { 103b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the parameter type is an rvalue reference type. 104b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor bool ParamIsRvalueRef; 105b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the argument type is an rvalue reference type. 106b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor bool ArgIsRvalueRef; 107dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 108b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the parameter or argument (or neither) is more qualified. 109b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor DeductionQualifierComparison Qualifiers; 110b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor}; 111b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 112b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 1135c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 11420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 115bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian RedlDeduceTemplateArgumentsByTypeMatch(Sema &S, 116bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateParameterList *TemplateParams, 117bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType Param, 118bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType Arg, 119bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateDeductionInfo &Info, 120bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<DeducedTemplateArgument> & 121bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Deduced, 122bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl unsigned TDF, 123bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool PartialOrdering = false, 124bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<RefParamPartialOrderingComparison> * 125b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons = 0); 126603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 127603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 128603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 129603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 13020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 13120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 13220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 1335f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 1340972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor bool NumberOfArgumentsMustMatch = true); 13520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 136199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \brief If the given expression is of a form that permits the deduction 137199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// of a non-type template parameter, return the declaration of that 138199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// non-type template parameter. 139199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregorstatic NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { 140199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E)) 141199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor E = IC->getSubExpr(); 1421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 143199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 144199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 1451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 146199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return 0; 147199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 148199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Determine whether two declaration pointers refer to the same 1500d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// declaration. 1510d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregorstatic bool isSameDeclaration(Decl *X, Decl *Y) { 1520d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (!X || !Y) 1530d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return !X && !Y; 154dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NX = dyn_cast<NamedDecl>(X)) 1560d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X = NX->getUnderlyingDecl(); 1570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NY = dyn_cast<NamedDecl>(Y)) 1580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y = NY->getUnderlyingDecl(); 159dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X->getCanonicalDecl() == Y->getCanonicalDecl(); 1610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 1620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Verify that the given, deduced template arguments are compatible. 1640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// 1650d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \returns The deduced template argument, or a NULL template argument if 1660d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// the deduced template arguments were incompatible. 167dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic DeducedTemplateArgument 1680d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas GregorcheckDeducedTemplateArguments(ASTContext &Context, 1690d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &X, 1700d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &Y) { 1710d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // We have no deduction for one or both of the arguments; they're compatible. 1720d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (X.isNull()) 1730d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 1740d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.isNull()) 175dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return X; 1760d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1770d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor switch (X.getKind()) { 1780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Null: 1790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm_unreachable("Non-deduced template arguments handled above"); 1800d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1810d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Type: 1820d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If two template type arguments have the same type, they're compatible. 1830d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Type && 1840d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameType(X.getAsType(), Y.getAsType())) 1850d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 186dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1870d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 188dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Integral: 1900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a constant in one case and either a dependent expression or 1910d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration in another case, keep the integral constant. 1920d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If both are integral constants with the same value, keep that value. 1930d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression || 1940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration || 1950d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor (Y.getKind() == TemplateArgument::Integral && 1960d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor hasSameExtendedValue(*X.getAsIntegral(), *Y.getAsIntegral()))) 197dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(X, 1980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.wasDeducedFromArrayBound() && 1990d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 2000d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2010d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2020d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 203dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2040d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Template: 2050d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Template && 2060d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) 2070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 208dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2090d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 210dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(); 211a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 212a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 213a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor if (Y.getKind() == TemplateArgument::TemplateExpansion && 214dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), 215a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern())) 216a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return X; 217dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 218a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor // All other combinations are incompatible. 219dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(); 220a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 2210d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Expression: 222dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If we deduced a dependent expression in one case and either an integral 223dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // constant or a declaration in another case, keep the integral constant 2240d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // or declaration. 2250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral || 2260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration) 2270d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() && 2280d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 229dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) { 2310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // Compare the expressions for equality 2320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm::FoldingSetNodeID ID1, ID2; 2330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.getAsExpr()->Profile(ID1, Context, true); 2340d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getAsExpr()->Profile(ID2, Context, true); 2350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (ID1 == ID2) 2360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 238dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2400d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 241dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2420d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Declaration: 2430d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and a dependent expression, keep the 2440d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration. 2450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) 2460d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 247dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2480d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and an integral constant, keep the 2490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // integral constant. 2500d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral) 2510d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 252dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2530d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced two declarations, make sure they they refer to the 2540d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // same declaration. 2550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Declaration && 2560d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor isSameDeclaration(X.getAsDecl(), Y.getAsDecl())) 2570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 258dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 261dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Pack: 2630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() != TemplateArgument::Pack || 2640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.pack_size() != Y.pack_size()) 2650d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 266dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 267dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (TemplateArgument::pack_iterator XA = X.pack_begin(), 2680d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XAEnd = X.pack_end(), 2690d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor YA = Y.pack_begin(); 2700d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XA != XAEnd; ++XA, ++YA) { 271dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (checkDeducedTemplateArguments(Context, 272dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), 273135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) 274135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor .isNull()) 2750d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2760d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 277dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 280dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2813026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 2820d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 2830d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 285199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given constant. 286f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 287a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 2881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP, 2899d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor llvm::APSInt Value, QualType ValueType, 29002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor bool DeducedFromArrayBound, 2912a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 2925f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 2931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 294199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 2951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2960d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(Value, ValueType, DeducedFromArrayBound); 297dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 2980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 2990d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3000d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 301f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = NTTP; 302f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3030d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 304dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 305f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 306dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 308f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 309199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 310199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 3111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 312199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given type- or value-dependent expression. 313199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// 314199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \returns true if deduction succeeded, false otherwise. 315f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 316a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 317f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor NonTypeTemplateParmDecl *NTTP, 318f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Expr *Value, 3192a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 3205f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 3211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 322199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 323199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert((Value->isTypeDependent() || Value->isValueDependent()) && 324199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Expression template argument must be type- or value-dependent."); 3251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(Value); 327dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 328dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Deduced[NTTP->getIndex()], 3290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 330dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3340d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 335dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 3369eea08ba72f8b1e7faf38e43376b9157fc4a2af2Douglas Gregor } 337dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3380d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 339f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 340199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 341199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 34215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \brief Deduce the value of the given non-type template parameter 34315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// from the given declaration. 34415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// 34515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \returns true if deduction succeeded, false otherwise. 34615755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregorstatic Sema::TemplateDeductionResult 347a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 34815755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor NonTypeTemplateParmDecl *NTTP, 34915755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor Decl *D, 3502a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 3515f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 35215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor assert(NTTP->getDepth() == 0 && 35315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor "Cannot deduce non-type template argument with depth > 0"); 354dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(D? D->getCanonicalDecl() : 0); 356dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 3580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 363dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 36415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor } 365dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3660d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 36715755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor return Sema::TDK_Success; 36815755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor} 36915755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 370f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 371a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 372db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParameterList *TemplateParams, 373f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Param, 374f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Arg, 3752a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 3765f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 377d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); 378db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (!ParamDecl) { 379db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // The parameter type is dependent and is not a template template parameter, 380db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // so there is nothing that we can deduce. 381db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 382f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 383dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 384db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (TemplateTemplateParmDecl *TempParam 385db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) { 3860d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); 387dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()], 3890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3910d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = TempParam; 3920d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[TempParam->getIndex()]; 3930d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 394dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 395db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor } 396dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3970d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()] = Result; 398dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Success; 399f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 400dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 401db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Verify that the two template names are equivalent. 402a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (S.Context.hasSameTemplateName(Param, Arg)) 403db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 404dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 405db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Mismatch of non-dependent template parameter to argument. 406db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.FirstArg = TemplateArgument(Param); 407db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.SecondArg = TemplateArgument(Arg); 408db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_NonDeducedMismatch; 409d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor} 410d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 4111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the template arguments by comparing the template parameter 412de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// type (which is a template-id) with the template argument type. 413de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 414a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the Sema 415de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 416de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param TemplateParams the template parameters that we are deducing 417de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 418de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Param the parameter type 419de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 420de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Arg the argument type 421de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 422de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Info information about the template argument deduction itself 423de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 424de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Deduced the deduced template arguments 425de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 426de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 427de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 428de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// but it may still fail, later, for other reasons. 429de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregorstatic Sema::TemplateDeductionResult 430a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 431de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateParameterList *TemplateParams, 432de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const TemplateSpecializationType *Param, 433de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType Arg, 4342a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 4355f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 436467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Arg.isCanonical() && "Argument type must be canonical"); 4371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 438de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Check whether the template argument is a dependent template-id. 4391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *SpecArg 440de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<TemplateSpecializationType>(Arg)) { 441de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 442de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 443a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 444de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 445de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor SpecArg->getTemplateName(), 446de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 447de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 4481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 450de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction on each template 4510972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // argument. Ignore any missing/extra arguments, since they could be 4520972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // filled in by default arguments. 453dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 454dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Param->getArgs(), Param->getNumArgs(), 4550972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor SpecArg->getArgs(), SpecArg->getNumArgs(), 4560972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor Info, Deduced, 4570972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor /*NumberOfArgumentsMustMatch=*/false); 458de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 4591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 460de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If the argument type is a class template specialization, we 461de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // perform template argument deduction using its template 462de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // arguments. 463de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *RecordArg = dyn_cast<RecordType>(Arg); 464de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!RecordArg) 465de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 4661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ClassTemplateSpecializationDecl *SpecArg 468de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl()); 469de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!SpecArg) 470de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 4711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 472de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 473de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 474a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, 475db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParams, 476de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 477de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateName(SpecArg->getSpecializedTemplate()), 478de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 479de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 4801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Perform template argument deduction for the template arguments. 482dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 48320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Param->getArgs(), Param->getNumArgs(), 48420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().data(), 48520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().size(), 48620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 487de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor} 488de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 489cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// \brief Determines whether the given type is an opaque type that 490cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// might be more qualified when instantiated. 491cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCallstatic bool IsPossiblyOpaquelyQualifiedType(QualType T) { 492cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall switch (T->getTypeClass()) { 493cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOfExpr: 494cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOf: 495cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentName: 496cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::Decltype: 497cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::UnresolvedUsing: 49862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall case Type::TemplateTypeParm: 499cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return true; 500cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 501cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::ConstantArray: 502cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::IncompleteArray: 503cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::VariableArray: 504cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentSizedArray: 505cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return IsPossiblyOpaquelyQualifiedType( 506cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall cast<ArrayType>(T)->getElementType()); 507cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 508cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall default: 509cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return false; 510cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } 511cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall} 512cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 513d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor/// \brief Retrieve the depth and index of a template parameter. 514dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic std::pair<unsigned, unsigned> 515d3731198193eee92796ddeb493973b7a598b003eDouglas GregorgetDepthAndIndex(NamedDecl *ND) { 516603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) 517603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 518dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 519603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) 520603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); 521dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 522603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); 523603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 524603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 525603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 526d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor/// \brief Retrieve the depth and index of an unexpanded parameter pack. 527dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic std::pair<unsigned, unsigned> 528d3731198193eee92796ddeb493973b7a598b003eDouglas GregorgetDepthAndIndex(UnexpandedParameterPack UPP) { 529d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (const TemplateTypeParmType *TTP 530d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor = UPP.first.dyn_cast<const TemplateTypeParmType *>()) 531d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 532dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 533d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor return getDepthAndIndex(UPP.first.get<NamedDecl *>()); 534d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor} 535d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 536603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Helper function to build a TemplateParameter when we don't 537603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// know its type statically. 538603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic TemplateParameter makeTemplateParameter(Decl *D) { 539603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D)) 540603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(TTP); 541603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) 542603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(NTTP); 543dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 544603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(cast<TemplateTemplateParmDecl>(D)); 545603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 546603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 5475429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor/// \brief Prepare to perform template argument deduction for all of the 5485429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor/// arguments in a set of argument packs. 549dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic void PrepareArgumentPackDeduction(Sema &S, 5505f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 5514fe5be028b723fedc28bb33be96cde1ab2574ee6Bill Wendling ArrayRef<unsigned> PackIndices, 5525f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, 5535f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl< 5545f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks) { 5555429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // Save the deduced template arguments for each parameter pack expanded 5565429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // by this pack expansion, then clear out the deduction. 5575429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 5585429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // Save the previously-deduced argument pack, then clear it out so that we 5595429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // can deduce a new argument pack. 5605429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor SavedPacks[I] = Deduced[PackIndices[I]]; 561dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Deduced[PackIndices[I]] = TemplateArgument(); 562dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 5635429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // If the template arugment pack was explicitly specified, add that to 5645429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // the set of deduced arguments. 5655429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor const TemplateArgument *ExplicitArgs; 5665429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor unsigned NumExplicitArgs; 567dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NamedDecl *PartiallySubstitutedPack 5685429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor = S.CurrentInstantiationScope->getPartiallySubstitutedPack( 5695429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor &ExplicitArgs, 5705429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor &NumExplicitArgs)) { 5715429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I]) 572dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks[I].append(ExplicitArgs, 5735429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor ExplicitArgs + NumExplicitArgs); 5745429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor } 5755429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor } 5765429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor} 5775429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor 5780216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// \brief Finish template argument deduction for a set of argument packs, 5790216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// producing the argument packs and checking for consistency with prior 5800216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// deductions. 5810216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregorstatic Sema::TemplateDeductionResult 5820216f8121df32b320cab659d5b703fee50cdfda5Douglas GregorFinishArgumentPackDeduction(Sema &S, 5830216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateParameterList *TemplateParams, 5840216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor bool HasAnyArguments, 5855f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 586341785ec52f87c0803ba52dc88faac4e136f8593Bill Wendling ArrayRef<unsigned> PackIndices, 5875f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, 5885f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl< 5895f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks, 5900216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateDeductionInfo &Info) { 5910216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 5920216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // pack expansion. 5930216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 5940216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { 5950216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // We were not able to deduce anything for this parameter pack, 5960216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // so just restore the saved argument pack. 5970216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced[PackIndices[I]] = SavedPacks[I]; 5980216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor continue; 5990216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 600dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6010216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor DeducedTemplateArgument NewPack; 602dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6030216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (NewlyDeducedPacks[I].empty()) { 6040216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // If we deduced an empty argument pack, create it now. 6050216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewPack = DeducedTemplateArgument(TemplateArgument(0, 0)); 6060216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } else { 6070216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateArgument *ArgumentPack 608203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; 6090216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), 6100216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor ArgumentPack); 6110216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewPack 612203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor = DeducedTemplateArgument(TemplateArgument(ArgumentPack, 613203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor NewlyDeducedPacks[I].size()), 614dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); 6150216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 616dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6170216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor DeducedTemplateArgument Result 6180216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); 6190216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Result.isNull()) { 6200216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.Param 6210216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); 6220216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.FirstArg = SavedPacks[I]; 6230216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.SecondArg = NewPack; 6240216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Sema::TDK_Inconsistent; 6250216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 626dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6270216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced[PackIndices[I]] = Result; 6280216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 629dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6300216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Sema::TDK_Success; 6310216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor} 6320216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 633603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Deduce the template arguments by comparing the list of parameter 634dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// types to the list of argument types, as in the parameter-type-lists of 635dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// function types (C++ [temp.deduct.type]p10). 636603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 637603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param S The semantic analysis object within which we are deducing 638603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 639603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TemplateParams The template parameters that we are deducing 640603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 641603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Params The list of parameter types 642603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 643603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumParams The number of types in \c Params 644603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 645603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Args The list of argument types 646603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 647603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumArgs The number of types in \c Args 648603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 649603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Info information about the template argument deduction itself 650603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 651603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Deduced the deduced template arguments 652603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 653603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 654603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// how template argument deduction is performed. 655603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 6565c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param PartialOrdering If true, we are performing template argument 657dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// deduction for during partial ordering for a call 6585c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// (C++0x [temp.deduct.partial]). 6595c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 660b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \param RefParamComparisons If we're performing template argument deduction 6615c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering, the set of qualifier comparisons. 6625c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 663603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 664603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 665603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// but it may still fail, later, for other reasons. 666603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 667603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 668603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 669603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Params, unsigned NumParams, 670603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Args, unsigned NumArgs, 671603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateDeductionInfo &Info, 6725f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 6735c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned TDF, 6745c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool PartialOrdering = false, 6755f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<RefParamPartialOrderingComparison> * 676b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons = 0) { 6770bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor // Fast-path check to see if we have too many/too few arguments. 6780bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor if (NumParams != NumArgs && 6790bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) && 6800bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1]))) 6813cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 682dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 683603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 684dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Similarly, if P has a form that contains (T), then each parameter type 685dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Pi of the respective parameter-type- list of P is compared with the 686dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // corresponding parameter type Ai of the corresponding parameter-type-list 687dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // of A. [...] 688603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 689603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ParamIdx != NumParams; ++ParamIdx) { 690603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Check argument types. 691dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const PackExpansionType *Expansion 692603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = dyn_cast<PackExpansionType>(Params[ParamIdx]); 693603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!Expansion) { 694603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Simple case: compare the parameter and argument types at this point. 695dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 696603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we have an argument. 697603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx >= NumArgs) 6983cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 699dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 70077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (isa<PackExpansionType>(Args[ArgIdx])) { 70177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // C++0x [temp.deduct.type]p22: 70277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the original function parameter associated with A is a function 70377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // parameter pack and the function parameter associated with P is not 70477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // a function parameter pack, then template argument deduction fails. 70577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor return Sema::TDK_NonDeducedMismatch; 70677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor } 707dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 708603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Sema::TemplateDeductionResult Result 709bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 710bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Params[ParamIdx], Args[ArgIdx], 711bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF, 712bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PartialOrdering, 713bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 714603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 715dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 716603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor ++ArgIdx; 717603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor continue; 718603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 719dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 7207d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // C++0x [temp.deduct.type]p5: 7217d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // The non-deduced contexts are: 722dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - A function parameter pack that does not occur at the end of the 7237d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // parameter-declaration-clause. 7247d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor if (ParamIdx + 1 < NumParams) 7257d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor return Sema::TDK_Success; 7267d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor 727603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 728dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the parameter-declaration corresponding to Pi is a function 729603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter pack, then the type of its declarator- id is compared with 730dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // each remaining parameter type in the parameter-type-list of A. Each 731603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // comparison deduces template arguments for subsequent positions in the 732603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // template parameter packs expanded by the function parameter pack. 733dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 734603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Compute the set of template parameter indices that correspond to 735603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter packs expanded by the pack expansion. 7365f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 737603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Pattern = Expansion->getPattern(); 738603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor { 739013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 7405f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 741603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 742603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 743603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned Depth, Index; 744603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 745603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 746603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor SawIndices[Index] = true; 747603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor PackIndices.push_back(Index); 748603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 749603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 750603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 751603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 752603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 753d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Keep track of the deduced template arguments for each parameter pack 754dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 755d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template argument (the inner SmallVectors). 7565f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2> 757d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 7585f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 7595429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor SavedPacks(PackIndices.size()); 760dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, 7615429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 762dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 763603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor bool HasAnyArguments = false; 764603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ArgIdx < NumArgs; ++ArgIdx) { 765603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor HasAnyArguments = true; 766dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 767603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Deduce template arguments from the pattern. 768dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (Sema::TemplateDeductionResult Result 769bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, 770bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Args[ArgIdx], Info, Deduced, 771bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TDF, PartialOrdering, 772bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 773603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 774dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 775603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 776603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 777603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // for that pack, then clear out the deduced argument. 778603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 779603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 780603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!DeducedArg.isNull()) { 781603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 782603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedArg = DeducedTemplateArgument(); 783603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 784603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 785603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 786dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 787603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 788603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // pack expansion. 7890216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 790dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, 7910216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 7920216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 793dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 794603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 795dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 796603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we don't have any extra arguments. 797603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx < NumArgs) 7983cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 799dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 800603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Sema::TDK_Success; 801603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 802603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 80361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor/// \brief Determine whether the parameter has qualifiers that are either 80461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor/// inconsistent with or a superset of the argument's qualifiers. 80561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregorstatic bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, 80661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor QualType ArgType) { 80761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ParamQs = ParamType.getQualifiers(); 80861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ArgQs = ArgType.getQualifiers(); 80961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 81061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs == ArgQs) 81161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return false; 81261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 81361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Mismatched (but not missing) Objective-C GC attributes. 81461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && 81561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ParamQs.hasObjCGCAttr()) 81661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return true; 81761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 81861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Mismatched (but not missing) address spaces. 81961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() && 82061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ParamQs.hasAddressSpace()) 82161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return true; 82261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 823f85e193739c953358c865005855253af4f68a497John McCall // Mismatched (but not missing) Objective-C lifetime qualifiers. 824f85e193739c953358c865005855253af4f68a497John McCall if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() && 825f85e193739c953358c865005855253af4f68a497John McCall ParamQs.hasObjCLifetime()) 826f85e193739c953358c865005855253af4f68a497John McCall return true; 827f85e193739c953358c865005855253af4f68a497John McCall 82861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // CVR qualifier superset. 82961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) && 83061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers()) 83161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor == ParamQs.getCVRQualifiers()); 83261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor} 83361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 834500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \brief Deduce the template arguments by comparing the parameter type and 835500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// the argument type (C++ [temp.deduct.type]). 836500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 837a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the semantic analysis object within which we are deducing 838500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 839500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param TemplateParams the template parameters that we are deducing 840500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 841500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ParamIn the parameter type 842500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 843500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ArgIn the argument type 844500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 845500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Info information about the template argument deduction itself 846500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 847500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Deduced the deduced template arguments 848500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 849508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 8501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// how template argument deduction is performed. 851500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 8525c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param PartialOrdering Whether we're performing template argument deduction 8535c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering (C++0x [temp.deduct.partial]). 8545c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 855b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \param RefParamComparisons If we're performing template argument deduction 8565c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering, the set of qualifier comparisons. 8575c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 858500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \returns the result of template argument deduction so far. Note that a 859500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// "success" result means that template argument deduction has not yet failed, 860500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// but it may still fail, later, for other reasons. 861f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 862bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian RedlDeduceTemplateArgumentsByTypeMatch(Sema &S, 863bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateParameterList *TemplateParams, 864bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType ParamIn, QualType ArgIn, 865bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateDeductionInfo &Info, 866bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<DeducedTemplateArgument> &Deduced, 867bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl unsigned TDF, 868bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool PartialOrdering, 869bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<RefParamPartialOrderingComparison> * 870bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons) { 8710b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // We only want to look at the canonical types, since typedefs and 8720b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // sugar are not part of template argument deduction. 873a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Param = S.Context.getCanonicalType(ParamIn); 874a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Arg = S.Context.getCanonicalType(ArgIn); 8750b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 87677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the argument type is a pack expansion, look at its pattern. 877dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // This isn't explicitly called out 87877d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (const PackExpansionType *ArgExpansion 87977d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor = dyn_cast<PackExpansionType>(Arg)) 88077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Arg = ArgExpansion->getPattern(); 881dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 8825c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (PartialOrdering) { 8835c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p5: 884dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Before the partial ordering is done, certain transformations are 885dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // performed on the types used for partial ordering: 886dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If P is a reference type, P is replaced by the type referred to. 8875c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor const ReferenceType *ParamRef = Param->getAs<ReferenceType>(); 8885c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (ParamRef) 8895c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = ParamRef->getPointeeType(); 890dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 8915c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If A is a reference type, A is replaced by the type referred to. 8925c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor const ReferenceType *ArgRef = Arg->getAs<ReferenceType>(); 8935c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (ArgRef) 8945c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Arg = ArgRef->getPointeeType(); 895dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 896b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (RefParamComparisons && ParamRef && ArgRef) { 8975c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p6: 898dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If both P and A were reference types (before being replaced with the 899dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // type referred to above), determine which of the two types (if any) is 9005c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // more cv-qualified than the other; otherwise the types are considered 901dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // to be equally cv-qualified for partial ordering purposes. The result 9025c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // of this determination will be used below. 9035c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // 904dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // We save this information for later, using it only when deduction 9055c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // succeeds in both directions. 906b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamPartialOrderingComparison Comparison; 907b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.ParamIsRvalueRef = ParamRef->getAs<RValueReferenceType>(); 908b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.ArgIsRvalueRef = ArgRef->getAs<RValueReferenceType>(); 909b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = NeitherMoreQualified; 910769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor 911769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor Qualifiers ParamQuals = Param.getQualifiers(); 912769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor Qualifiers ArgQuals = Arg.getQualifiers(); 913769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor if (ParamQuals.isStrictSupersetOf(ArgQuals)) 914b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = ParamMoreQualified; 915769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor else if (ArgQuals.isStrictSupersetOf(ParamQuals)) 916b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = ArgMoreQualified; 917b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons->push_back(Comparison); 9185c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } 919dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 9205c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p7: 9215c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // Remove any top-level cv-qualifiers: 922dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If P is a cv-qualified type, P is replaced by the cv-unqualified 9235c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // version of P. 9245c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = Param.getUnqualifiedType(); 925dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If A is a cv-qualified type, A is replaced by the cv-unqualified 9265c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // version of A. 9275c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Arg = Arg.getUnqualifiedType(); 9285c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } else { 9295c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.call]p4 bullet 1: 9305c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the type 9315c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // referred to by the reference) can be more cv-qualified than the 9325c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // transformed A. 9335c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (TDF & TDF_ParamWithReferenceType) { 9345c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Qualifiers Quals; 9355c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); 9365c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Quals.setCVRQualifiers(Quals.getCVRQualifiers() & 93762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Arg.getCVRQualifiers()); 9385c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = S.Context.getQualifiedType(UnqualParam, Quals); 9395c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } 940dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 94173b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) { 94273b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // C++0x [temp.deduct.type]p10: 94373b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // If P and A are function types that originated from deduction when 94473b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // taking the address of a function template (14.8.2.2) or when deducing 94573b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // template arguments from a function declaration (14.8.2.6) and Pi and 946dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Ai are parameters of the top-level parameter-type-list of P and A, 947dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // respectively, Pi is adjusted if it is an rvalue reference to a 948dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // cv-unqualified template parameter and Ai is an lvalue reference, in 949dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // which case the type of Pi is changed to be the template parameter 95073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // type (i.e., T&& is changed to simply T). [ Note: As a result, when 95173b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be 9520099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // deduced as X&. - end note ] 95373b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor TDF &= ~TDF_TopLevelParameterTypeList; 954dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 95573b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (const RValueReferenceType *ParamRef 95673b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor = Param->getAs<RValueReferenceType>()) { 95773b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) && 95873b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor !ParamRef->getPointeeType().getQualifiers()) 95973b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (Arg->isLValueReferenceType()) 96073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor Param = ParamRef->getPointeeType(); 96173b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor } 96273b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor } 963500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor } 964dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 965199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // C++ [temp.deduct.type]p9: 9661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // A template type argument T, a template template argument TT or a 9671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // template non-type argument i can be deduced if P and A have one of 968199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // the following forms: 969199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // 970199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T 971199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // cv-list T 9721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateTypeParmType *TemplateTypeParm 973183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Param->getAs<TemplateTypeParmType>()) { 974af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor // Just skip any attempts to deduce from a placeholder type. 975af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor if (Arg->isPlaceholderType()) 976af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor return Sema::TDK_Success; 977af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor 978f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor unsigned Index = TemplateTypeParm->getIndex(); 979f290e0db835a619014538c41ed552696efc0e977Douglas Gregor bool RecanonicalizeArg = false; 9801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9819e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // If the argument type is an array type, move the qualifiers up to the 9829e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // top level, so they can be matched with the qualifiers on the parameter. 983f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (isa<ArrayType>(Arg)) { 9840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals; 985a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); 9860953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Quals) { 987a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getQualifiedType(Arg, Quals); 988f290e0db835a619014538c41ed552696efc0e977Douglas Gregor RecanonicalizeArg = true; 989f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 990f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 9911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9920b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // The argument type can not be less qualified than the parameter 9930b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // type. 99461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (!(TDF & TDF_IgnoreQualifiers) && 99561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor hasInconsistentOrSupersetQualifiersOf(Param, Arg)) { 996f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 99757e97786433e70197a089360228d8f0d82e3ad4cJohn McCall Info.FirstArg = TemplateArgument(Param); 998833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(Arg); 99957e97786433e70197a089360228d8f0d82e3ad4cJohn McCall return Sema::TDK_Underqualified; 1000f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 10010b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 10020b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); 1003a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function"); 10040953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualType DeducedType = Arg; 100549f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall 100661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Remove any qualifiers on the parameter from the deduced type. 100761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // We checked the qualifiers for consistency above. 100861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers DeducedQs = DeducedType.getQualifiers(); 100961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ParamQs = Param.getQualifiers(); 101061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers()); 101161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.hasObjCGCAttr()) 101261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeObjCGCAttr(); 101361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.hasAddressSpace()) 101461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeAddressSpace(); 1015f85e193739c953358c865005855253af4f68a497John McCall if (ParamQs.hasObjCLifetime()) 1016f85e193739c953358c865005855253af4f68a497John McCall DeducedQs.removeObjCLifetime(); 1017e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor 1018e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // Objective-C ARC: 1019da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // If template deduction would produce a lifetime qualifier on a type 1020da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // that is not a lifetime type, template argument deduction fails. 1021da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() && 1022da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor !DeducedType->isDependentType()) { 1023da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 1024da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.FirstArg = TemplateArgument(Param); 1025da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.SecondArg = TemplateArgument(Arg); 1026da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor return Sema::TDK_Underqualified; 1027da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor } 1028da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor 1029da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // Objective-C ARC: 1030e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // If template deduction would produce an argument type with lifetime type 1031e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // but no lifetime qualifier, the __strong lifetime qualifier is inferred. 10324e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (S.getLangOpts().ObjCAutoRefCount && 1033e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor DeducedType->isObjCLifetimeType() && 1034e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor !DeducedQs.hasObjCLifetime()) 1035e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong); 1036e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor 103761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(), 103861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs); 103961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 1040f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (RecanonicalizeArg) 1041a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth DeducedType = S.Context.getCanonicalType(DeducedType); 10421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10430d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(DeducedType); 1044dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 10450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index], 10460d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 10470d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 10480d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 10490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[Index]; 10500d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 1051dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 10520b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 1053dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 10540d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index] = Result; 1055dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Success; 10560b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 10570b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1058f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // Set up the template argument deduction information for a failure. 1059833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.FirstArg = TemplateArgument(ParamIn); 1060833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(ArgIn); 1061f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 10620bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // If the parameter is an already-substituted template parameter 10630bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // pack, do nothing: we don't know which of its arguments to look 10640bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // at, so we have to wait until all of the parameter packs in this 10650bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // expansion have arguments. 10660bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor if (isa<SubstTemplateTypeParmPackType>(Param)) 10670bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor return Sema::TDK_Success; 10680bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor 1069508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // Check the cv-qualifiers on the parameter and argument types. 1070508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (!(TDF & TDF_IgnoreQualifiers)) { 1071508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (TDF & TDF_ParamWithReferenceType) { 107261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (hasInconsistentOrSupersetQualifiersOf(Param, Arg)) 1073508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1074cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { 1075508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) 10761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Sema::TDK_NonDeducedMismatch; 1077508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 1078fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1079fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // If the parameter type is not dependent, there is nothing to deduce. 1080fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (!Param->isDependentType()) { 1081fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (!(TDF & TDF_SkipNonDependent) && Param != Arg) 1082fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1083fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1084fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_Success; 1085fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1086fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } else if (!Param->isDependentType() && 1087fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Param.getUnqualifiedType() == Arg.getUnqualifiedType()) { 1088fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_Success; 1089508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 10900b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1091d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor switch (Param->getTypeClass()) { 10924ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Non-canonical types cannot appear here. 10934ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) \ 10944ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class); 10954ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#define TYPE(Class, Base) 10964ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#include "clang/AST/TypeNodes.def" 10974ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 10984ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::TemplateTypeParm: 10994ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::SubstTemplateTypeParmPack: 11004ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor llvm_unreachable("Type nodes handled above"); 1101fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1102fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // These types cannot be dependent, so simply check whether the types are 1103fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // the same. 1104199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::Builtin: 11054ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::VariableArray: 11064ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Vector: 11074ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::FunctionNoProto: 11084ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Record: 11094ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Enum: 11104ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ObjCObject: 11114ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ObjCInterface: 1112fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor case Type::ObjCObjectPointer: { 1113fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (TDF & TDF_SkipNonDependent) 1114fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_Success; 1115fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1116fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (TDF & TDF_IgnoreQualifiers) { 1117fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Param = Param.getUnqualifiedType(); 1118fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Arg = Arg.getUnqualifiedType(); 1119fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1120fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1121fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch; 1122fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1123fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 11244ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // _Complex T [placeholder extension] 11254ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Complex: 11264ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>()) 1127bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 11284ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor cast<ComplexType>(Param)->getElementType(), 1129bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ComplexArg->getElementType(), 1130bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 11314ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 11324ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1133b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1134b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // _Atomic T [extension] 1135b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 1136b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>()) 1137bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1138b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman cast<AtomicType>(Param)->getValueType(), 1139b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicArg->getValueType(), 1140b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Info, Deduced, TDF); 1141b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1142b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return Sema::TDK_NonDeducedMismatch; 1143b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1144199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T * 1145d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::Pointer: { 1146c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall QualType PointeeType; 1147c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall if (const PointerType *PointerArg = Arg->getAs<PointerType>()) { 1148c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 1149c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else if (const ObjCObjectPointerType *PointerArg 1150c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall = Arg->getAs<ObjCObjectPointerType>()) { 1151c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 1152c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else { 1153f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1154c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } 11551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11564112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); 1157bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1158bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl cast<PointerType>(Param)->getPointeeType(), 1159c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType, 11604112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor Info, Deduced, SubTDF); 1161d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 11621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1163199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T & 1164d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::LValueReference: { 11656217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>(); 1166d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 1167f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1169bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1170d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<LValueReferenceType>(Param)->getPointeeType(), 1171bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ReferenceArg->getPointeeType(), Info, Deduced, 0); 1172d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 11730b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1174199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T && [C++0x] 1175d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::RValueReference: { 11766217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>(); 1177d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 1178f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1180bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1181bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl cast<RValueReferenceType>(Param)->getPointeeType(), 1182bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ReferenceArg->getPointeeType(), 1183bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1184d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 11851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1186199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [] (implied, but not stated explicitly) 11874d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::IncompleteArray: { 11881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const IncompleteArrayType *IncompleteArrayArg = 1189a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsIncompleteArrayType(Arg); 11904d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!IncompleteArrayArg) 1191f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1193e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1194bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1195bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl S.Context.getAsIncompleteArrayType(Param)->getElementType(), 1196bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl IncompleteArrayArg->getElementType(), 1197bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF); 11984d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 1199199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1200199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [integer-constant] 12014d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::ConstantArray: { 12021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayArg = 1203a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Arg); 12044d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!ConstantArrayArg) 1205f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayParm = 1208a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Param); 12094d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) 1210f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1212e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1213bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1214bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ConstantArrayParm->getElementType(), 1215bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ConstantArrayArg->getElementType(), 1216bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF); 12174d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 12184d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 1219199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // type [i] 1220199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::DependentSizedArray: { 1221a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); 1222199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!ArrayArg) 1223f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1225e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1226e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall 1227199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Check the element type of the arrays 1228199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor const DependentSizedArrayType *DependentArrayParm 1229a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = S.Context.getAsDependentSizedArrayType(Param); 1230f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1231bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1232bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl DependentArrayParm->getElementType(), 1233bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ArrayArg->getElementType(), 1234bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF)) 1235f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 12361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1237199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Determine the array bound is something we can deduce. 12381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP 1239199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); 1240199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!NTTP) 1241f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 12421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We can perform template argument deduction for the given non-type 1244199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // template parameter. 12451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 1246199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument at depth > 0"); 12471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ConstantArrayType *ConstantArrayArg 1248335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson = dyn_cast<ConstantArrayType>(ArrayArg)) { 1249335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson llvm::APSInt Size(ConstantArrayArg->getSize()); 1250dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceNonTypeTemplateArgument(S, NTTP, Size, 12519d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor S.Context.getSizeType(), 125202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/true, 1253f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1254335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson } 1255199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (const DependentSizedArrayType *DependentArrayArg 1256199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = dyn_cast<DependentSizedArrayType>(ArrayArg)) 125734c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor if (DependentArrayArg->getSizeExpr()) 125834c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, 125934c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor DependentArrayArg->getSizeExpr(), 126034c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor Info, Deduced); 12611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1262199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Incomplete type does not match a dependently-sized array type 1263f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1264199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 12651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(*)(T) 12671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)() 12681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)(T) 1269a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson case Type::FunctionProto: { 127073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList; 12711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoArg = 1272a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson dyn_cast<FunctionProtoType>(Arg); 1273a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson if (!FunctionProtoArg) 1274f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoParam = 1277a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson cast<FunctionProtoType>(Param); 1278994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 1279dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (FunctionProtoParam->getTypeQuals() 1280e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor != FunctionProtoArg->getTypeQuals() || 1281dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionProtoParam->getRefQualifier() 1282e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor != FunctionProtoArg->getRefQualifier() || 1283e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) 1284f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1285994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 1286a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson // Check return types. 1287f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1288bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1289bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FunctionProtoParam->getResultType(), 1290bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FunctionProtoArg->getResultType(), 1291bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0)) 1292f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 12931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1294603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return DeduceTemplateArguments(S, TemplateParams, 1295603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->arg_type_begin(), 1296603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->getNumArgs(), 1297603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->arg_type_begin(), 1298603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->getNumArgs(), 129973b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor Info, Deduced, SubTDF); 1300a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson } 13011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13023cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case Type::InjectedClassName: { 13033cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // Treat a template's injected-class-name as if the template 13043cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // specialization type had been used. 130531f17ecbef57b5679c017c375db330546b7b5145John McCall Param = cast<InjectedClassNameType>(Param) 130631f17ecbef57b5679c017c375db330546b7b5145John McCall ->getInjectedSpecializationType(); 13073cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<TemplateSpecializationType>(Param) && 13083cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall "injected class name is not a template specialization type"); 13093cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // fall through 13103cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 13113cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 1312f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // template-name<T> (where template-name refers to a class template) 1313d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // template-name<i> 1314db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<T> 1315db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<i> 1316db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<> 1317d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor case Type::TemplateSpecialization: { 1318d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor const TemplateSpecializationType *SpecParam 1319d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor = cast<TemplateSpecializationType>(Param); 13201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1321de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Try to deduce template arguments from the template-id. 1322de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult Result 1323a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, 1324de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced); 13251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13264a5c15f75f76b95e1c2ceb6fa2737dcadd5f4be1Douglas Gregor if (Result && (TDF & TDF_DerivedClass)) { 1327de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // C++ [temp.deduct.call]p3b3: 1328de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If P is a class, and P has the form template-id, then A can be a 1329de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // derived class of the deduced A. Likewise, if P is a pointer to a 13301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // class of the form template-id, A can be a pointer to a derived 1331de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // class pointed to by the deduced A. 1332de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // 1333de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // More importantly: 13341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // These alternatives are considered only if type deduction would 1335de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // otherwise fail. 1336a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (const RecordType *RecordT = Arg->getAs<RecordType>()) { 1337a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // We cannot inspect base classes as part of deduction when the type 1338a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // is incomplete, so either instantiate any templates necessary to 1339a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // complete the type, or skip over it if it cannot be completed. 13405769d6195087229770d7ac90449443e026c47103John McCall if (S.RequireCompleteType(Info.getLocation(), Arg, 0)) 1341a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return Result; 1342a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth 1343de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Use data recursion to crawl through the list of base classes. 13441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Visited contains the set of nodes we have already visited, while 1345de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // ToVisit is our stack of records that we still need to visit. 1346de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallPtrSet<const RecordType *, 8> Visited; 13475f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<const RecordType *, 8> ToVisit; 1348de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.push_back(RecordT); 1349de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor bool Successful = false; 135074fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(), 135174fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer Deduced.end()); 1352de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor while (!ToVisit.empty()) { 1353de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Retrieve the next class in the inheritance hierarchy. 1354de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *NextT = ToVisit.back(); 1355de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.pop_back(); 13561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1357de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If we have already seen this type, skip it. 1358de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!Visited.insert(NextT)) 1359de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor continue; 13601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1361de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If this is a base class, try to perform template argument 1362de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // deduction from it. 1363de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (NextT != RecordT) { 1364de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult BaseResult 1365a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, 1366de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType(NextT, 0), Info, Deduced); 13671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1368de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If template argument deduction for this base was successful, 1369053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // note that we had some success. Otherwise, ignore any deductions 1370053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // from this base class. 1371053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor if (BaseResult == Sema::TDK_Success) { 1372de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Successful = true; 137374fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer DeducedOrig.clear(); 137474fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer DeducedOrig.append(Deduced.begin(), Deduced.end()); 1375053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor } 1376053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor else 1377053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor Deduced = DeducedOrig; 1378de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 13791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1380de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Visit base classes 1381de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl()); 1382de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), 1383de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor BaseEnd = Next->bases_end(); 13849994a34f6cf842721ba7723edc0b9036229fe387Sebastian Redl Base != BaseEnd; ++Base) { 13851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(Base->getType()->isRecordType() && 1386de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor "Base class that isn't a record?"); 13876217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek ToVisit.push_back(Base->getType()->getAs<RecordType>()); 1388de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 1389de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 13901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1391de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Successful) 1392de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_Success; 1393de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 13941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1395de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 13961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1397de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 1398d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor } 1399d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 1400637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T type::* 1401637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T T::* 1402637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)() 1403637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)() 1404637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (type::*)(T) 1405637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)(T) 1406637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)(T) 1407637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)() 1408637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)(T) 1409637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::MemberPointer: { 1410637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param); 1411637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg); 1412637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor if (!MemPtrArg) 1413f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1414f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1415f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1416bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1417bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl MemPtrParam->getPointeeType(), 1418bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl MemPtrArg->getPointeeType(), 1419bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 1420bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TDF & TDF_IgnoreQualifiers)) 1421f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 1422f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1423bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1424bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType(MemPtrParam->getClass(), 0), 1425bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType(MemPtrArg->getClass(), 0), 1426fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Info, Deduced, 1427fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor TDF & TDF_IgnoreQualifiers); 1428637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor } 1429637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 14309a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // (clang extension) 14319a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // 14321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(^)(T) 14331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)() 14341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)(T) 1435859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson case Type::BlockPointer: { 1436859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param); 1437859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg); 14381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1439859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson if (!BlockPtrArg) 1440f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 14411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1442bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1443bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl BlockPtrParam->getPointeeType(), 1444bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl BlockPtrArg->getPointeeType(), 1445bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1446859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson } 1447859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson 14484ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // (clang extension) 14494ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // 14504ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // T __attribute__(((ext_vector_type(<integral constant>)))) 14514ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ExtVector: { 14524ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor const ExtVectorType *VectorParam = cast<ExtVectorType>(Param); 14534ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) { 14544ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Make sure that the vectors have the same number of elements. 14554ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (VectorParam->getNumElements() != VectorArg->getNumElements()) 14564ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 14574ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 14584ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 1459bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1460bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1461bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1462bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 14634ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 14644ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 14654ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const DependentSizedExtVectorType *VectorArg 14664ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = dyn_cast<DependentSizedExtVectorType>(Arg)) { 14674ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // We can't check the number of elements, since the argument has a 14684ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // dependent number of elements. This can only occur during partial 14694ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // ordering. 14704ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 14714ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 1472bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1473bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1474bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1475bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 14764ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 14774ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 14784ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 14794ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 14804ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 14814ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // (clang extension) 14824ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // 14834ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // T __attribute__(((ext_vector_type(N)))) 14844ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::DependentSizedExtVector: { 14854ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor const DependentSizedExtVectorType *VectorParam 14864ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = cast<DependentSizedExtVectorType>(Param); 14874ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 14884ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) { 14894ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 14904ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (Sema::TemplateDeductionResult Result 1491bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1492bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1493bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1494bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 14954ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Result; 14964ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 14974ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the vector size, if we can. 14984ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor NonTypeTemplateParmDecl *NTTP 14994ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); 15004ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (!NTTP) 15014ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_Success; 15024ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15034ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); 15044ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor ArgSize = VectorArg->getNumElements(); 15054ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy, 15064ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor false, Info, Deduced); 15074ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15084ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15094ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const DependentSizedExtVectorType *VectorArg 15104ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = dyn_cast<DependentSizedExtVectorType>(Arg)) { 15114ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 15124ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (Sema::TemplateDeductionResult Result 1513bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1514bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1515bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1516bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 15174ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Result; 15184ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15194ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the vector size, if we can. 15204ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor NonTypeTemplateParmDecl *NTTP 15214ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); 15224ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (!NTTP) 15234ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_Success; 15244ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15254ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(), 15264ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor Info, Deduced); 15274ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15284ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15294ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 15304ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15314ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 1532637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOfExpr: 1533637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOf: 15344714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 15354ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::UnresolvedUsing: 15364ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Decltype: 15374ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::UnaryTransform: 15384ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Auto: 15394ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::DependentTemplateSpecialization: 15404ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::PackExpansion: 1541637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // No template argument deduction for these types 1542f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 15430b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 15440b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 15453026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid Type Class!"); 15460b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 15470b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1548f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 1549a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1550f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 1551f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 155277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor TemplateArgument Arg, 15532a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 15545f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 155577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the template argument is a pack expansion, perform template argument 155677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // deduction against the pattern of that expansion. This only occurs during 155777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // partial ordering. 155877d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (Arg.isPackExpansion()) 155977d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Arg = Arg.getPackExpansionPattern(); 1560dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 15610b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor switch (Param.getKind()) { 1562199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Null: 1563b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Null template argument in parameter list"); 15641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TemplateArgument::Type: 1566788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Type) 1567bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1568bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Param.getAsType(), 1569bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Arg.getAsType(), 1570bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1571788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1572788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1573788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1574a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1575788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1576db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (Arg.getKind() == TemplateArgument::Template) 1577dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 1578788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Param.getAsTemplate(), 1579db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Arg.getAsTemplate(), Info, Deduced); 1580788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1581788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1582788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1583a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1584a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1585a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor llvm_unreachable("caller should handle pack expansions"); 1586dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1587199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Declaration: 1588788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration && 1589d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl())) 1590788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_Success; 1591dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1592f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1593f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1594f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 15951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1596199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Integral: 1597199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) { 15989d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (hasSameExtendedValue(*Param.getAsIntegral(), *Arg.getAsIntegral())) 1599f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1600f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1601f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1602f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1603f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1604f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 1605f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1606f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) { 1607f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1608f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1609f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1610199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1611199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1612f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1613f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1614f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 16151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1616199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Expression: { 16171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (NonTypeTemplateParmDecl *NTTP 1618199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(Param.getAsExpr())) { 1619199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) 1620a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, 16211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump *Arg.getAsIntegral(), 16229d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Arg.getIntegralType(), 162302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/false, 1624f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1625199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) 1626a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(), 1627f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 162815755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration) 1629a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(), 163015755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor Info, Deduced); 1631dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1632f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1633f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1634f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1635199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 16361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1637199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Can't deduce anything, but that's okay. 1638f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1639199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1640d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 164120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor llvm_unreachable("Argument packs should be expanded by the caller!"); 16420b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 16431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16443026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 16450b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 16460b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 164720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \brief Determine whether there is a template argument to be used for 164820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// deduction. 164920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 165020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// This routine "expands" argument packs in-place, overriding its input 165120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// parameters so that \c Args[ArgIdx] will be the available template argument. 165220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 165320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \returns true if there is another template argument (which will be at 165420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \c Args[ArgIdx]), false otherwise. 1655dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args, 165620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &ArgIdx, 165720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &NumArgs) { 165820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (ArgIdx == NumArgs) 165920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return false; 1660dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 166120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 166220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Arg.getKind() != TemplateArgument::Pack) 166320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return true; 166420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 166520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?"); 166620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Args = Arg.pack_begin(); 166720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor NumArgs = Arg.pack_size(); 166820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgIdx = 0; 166920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return ArgIdx < NumArgs; 167020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 167120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 16727b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// \brief Determine whether the given set of template arguments has a pack 16737b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// expansion that is not the last template argument. 16747b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregorstatic bool hasPackExpansionBeforeEnd(const TemplateArgument *Args, 16757b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned NumArgs) { 16767b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned ArgIdx = 0; 16777b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor while (ArgIdx < NumArgs) { 16787b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 1679dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 16807b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // Unwrap argument packs. 16817b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Args[ArgIdx].getKind() == TemplateArgument::Pack) { 16827b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor Args = Arg.pack_begin(); 16837b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor NumArgs = Arg.pack_size(); 16847b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ArgIdx = 0; 16857b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor continue; 16867b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 1687dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 16887b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ++ArgIdx; 16897b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (ArgIdx == NumArgs) 16907b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 1691dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 16927b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Arg.isPackExpansion()) 16937b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return true; 16947b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 1695dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 16967b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 16977b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor} 16987b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 16991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic Sema::TemplateDeductionResult 1700a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1701f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 170220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 170320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 17042a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 17055f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 17060972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor bool NumberOfArgumentsMustMatch) { 1707e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1708dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 1709dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 1710e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // non-deduced context. 17117b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (hasPackExpansionBeforeEnd(Params, NumParams)) 17127b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return Sema::TDK_Success; 1713dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1714e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1715dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If P has a form that contains <T> or <i>, then each argument Pi of the 1716dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // respective template argument list P is compared with the corresponding 1717e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // argument Ai of the corresponding template argument list of A. 171820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 1719dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); 172020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ParamIdx) { 172120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!Params[ParamIdx].isPackExpansion()) { 1722e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The simple case: deduce template arguments by matching Pi and Ai. 1723dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 172420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Check whether we have enough arguments. 172520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) 17263cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return NumberOfArgumentsMustMatch? Sema::TDK_NonDeducedMismatch 17270972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor : Sema::TDK_Success; 1728dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 172977d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (Args[ArgIdx].isPackExpansion()) { 173077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here, 173177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // but applied to pack expansions that are template arguments. 173277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor return Sema::TDK_NonDeducedMismatch; 173377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor } 1734dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1735e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Perform deduction for this Pi/Ai pair. 173620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Sema::TemplateDeductionResult Result 173777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor = DeduceTemplateArguments(S, TemplateParams, 173877d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Params[ParamIdx], Args[ArgIdx], 173977d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Info, Deduced)) 1740dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 1741dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 174220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Move to the next argument. 174320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ArgIdx; 174420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor continue; 174520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor } 1746dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1747e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The parameter is a pack expansion. 1748dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1749e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1750dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If Pi is a pack expansion, then the pattern of Pi is compared with 1751dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // each remaining argument in the template argument list of A. Each 1752dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // comparison deduces template arguments for subsequent positions in the 1753e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template parameter packs expanded by Pi. 1754e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); 1755dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1756e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Compute the set of template parameter indices that correspond to 1757e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // parameter packs expanded by the pack expansion. 17585f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 1759e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor { 1760013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 17615f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1762e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 1763e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 1764e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned Depth, Index; 1765e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 1766e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 1767e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SawIndices[Index] = true; 1768e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor PackIndices.push_back(Index); 1769e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1770e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1771e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1772e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 1773dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1774e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // FIXME: If there are no remaining arguments, we can bail out early 1775e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // and set any deduced parameter packs to an empty argument pack. 1776e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The latter part of this is a (minor) correctness issue. 1777dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1778e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Save the deduced template arguments for each parameter pack expanded 1779e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, then clear out the deduction. 17805f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 1781e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SavedPacks(PackIndices.size()); 17825f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2> 17835429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 1784dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, 17855429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 1786e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1787e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Keep track of the deduced template arguments for each parameter pack 1788dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 1789e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template argument (the inner SmallVectors). 1790e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor bool HasAnyArguments = false; 1791e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) { 1792e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor HasAnyArguments = true; 1793dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1794e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Deduce template arguments from the pattern. 1795dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (Sema::TemplateDeductionResult Result 1796e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], 1797e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info, Deduced)) 1798e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Result; 1799dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1800e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 1801e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 1802e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // for that pack, then clear out the deduced argument. 1803e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 1804e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 1805e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (!DeducedArg.isNull()) { 1806e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 1807e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedArg = DeducedTemplateArgument(); 1808e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1809e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1810dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1811e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ++ArgIdx; 1812e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1813dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1814e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 1815e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // pack expansion. 18160216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 1817dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, 18180216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 18190216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 1820dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 18210b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 1822dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 182320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // If there is an argument remaining, then we had too many arguments. 18240972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor if (NumberOfArgumentsMustMatch && 18250972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) 18263cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1827dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1828f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 18290b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 18300b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 183120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 183220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas GregorDeduceTemplateArguments(Sema &S, 183320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateParameterList *TemplateParams, 183420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ParamList, 183520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ArgList, 183620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 18375f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 1838dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 183920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ParamList.data(), ParamList.size(), 184020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgList.data(), ArgList.size(), 184120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 184220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 184320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1844f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor/// \brief Determine whether two template arguments are the same. 18451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic bool isSameTemplateArg(ASTContext &Context, 1846f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &X, 1847f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &Y) { 1848f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.getKind() != Y.getKind()) 1849f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 18501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1851f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor switch (X.getKind()) { 1852f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Null: 1853b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Comparing NULL template argument"); 18541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1855f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Type: 1856f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Context.getCanonicalType(X.getAsType()) == 1857f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Context.getCanonicalType(Y.getAsType()); 18581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1859f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Declaration: 1860d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()); 18611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1862788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1863a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1864a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return Context.getCanonicalTemplateName( 1865a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == 1866a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Context.getCanonicalTemplateName( 1867a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); 1868dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1869f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Integral: 1870f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return *X.getAsIntegral() == *Y.getAsIntegral(); 18711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1872788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Expression: { 1873788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor llvm::FoldingSetNodeID XID, YID; 1874788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor X.getAsExpr()->Profile(XID, Context, true); 1875dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Y.getAsExpr()->Profile(YID, Context, true); 1876788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return XID == YID; 1877788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor } 18781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1879f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Pack: 1880f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.pack_size() != Y.pack_size()) 1881f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 18821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 18831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator XP = X.pack_begin(), 18841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XPEnd = X.pack_end(), 1885f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor YP = Y.pack_begin(); 18861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XP != XPEnd; ++XP, ++YP) 1887f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!isSameTemplateArg(Context, *XP, *YP)) 1888f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 1889f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 1890f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return true; 1891f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 1892f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 18933026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 1894f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor} 1895f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 189654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Allocate a TemplateArgumentLoc where all locations have 189754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// been initialized to the given location. 189854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 189954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param S The semantic analysis object. 190054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 190154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param The template argument we are producing template argument 190254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// location information for. 190354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 190454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param NTTPType For a declaration template argument, the type of 190554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// the non-type template parameter that corresponds to this template 190654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 190754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 190854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param Loc The source location to use for the resulting template 190954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 1910dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic TemplateArgumentLoc 191154c53cca105ed595e12fecf04e415c3712bda936Douglas GregorgetTrivialTemplateArgumentLoc(Sema &S, 1912dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const TemplateArgument &Arg, 191354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType, 191454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor SourceLocation Loc) { 191554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor switch (Arg.getKind()) { 191654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Null: 191754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm_unreachable("Can't get a NULL template argument here"); 1918dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 191954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Type: 1920dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return TemplateArgumentLoc(Arg, 192154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 1922dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 192354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Declaration: { 192454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 1925ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) 1926d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor .takeAs<Expr>(); 192754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 192854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 1929dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 193054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Integral: { 193154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 1932ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>(); 193354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 193454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 1935dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1936b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor case TemplateArgument::Template: 1937b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor case TemplateArgument::TemplateExpansion: { 1938b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor NestedNameSpecifierLocBuilder Builder; 1939b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor TemplateName Template = Arg.getAsTemplate(); 1940b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) 1941b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc); 1942b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 1943b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc); 1944b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 1945b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor if (Arg.getKind() == TemplateArgument::Template) 1946b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor return TemplateArgumentLoc(Arg, 1947b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.getWithLocInContext(S.Context), 1948b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Loc); 1949b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 1950b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 1951b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), 1952b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Loc, Loc); 1953b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor } 1954a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 195554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Expression: 195654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, Arg.getAsExpr()); 1957dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 195854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Pack: 195954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 196054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 1961dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 19623026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 196354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 196454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 196554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 196654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Convert the given deduced template argument and add it to the set of 196754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// fully-converted template arguments. 1968dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, 196954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument Arg, 1970dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NamedDecl *Template, 1971dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi QualType NTTPType, 19726952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor unsigned ArgumentPackIndex, 197354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateDeductionInfo &Info, 197454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor bool InFunctionTemplate, 19755f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<TemplateArgument> &Output) { 197654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 197754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // This is a template argument pack, so check each of its arguments against 197854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template parameter. 19795f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 2> PackedArgsBuilder; 1980dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (TemplateArgument::pack_iterator PA = Arg.pack_begin(), 1981135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor PAEnd = Arg.pack_end(); 198254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor PA != PAEnd; ++PA) { 1983d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // When converting the deduced template argument, append it to the 1984d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // general output list. We need to do this so that the template argument 1985d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // checking logic has all of the prior template arguments available. 198654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument InnerArg(*PA); 198754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); 1988dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, 19896952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTPType, PackedArgsBuilder.size(), 19906952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Info, InFunctionTemplate, Output)) 199154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return true; 1992dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1993d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // Move the converted template argument into our argument pack. 1994d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor PackedArgsBuilder.push_back(Output.back()); 1995d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Output.pop_back(); 199654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 1997dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 199854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Create the resulting argument pack. 1999dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Output.push_back(TemplateArgument::CreatePackCopy(S.Context, 2000203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor PackedArgsBuilder.data(), 2001203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor PackedArgsBuilder.size())); 200254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return false; 200354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2004dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 200554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Convert the deduced template argument into a template 200654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // argument that we can check, almost as if the user had written 200754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template argument explicitly. 200854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType, 200954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.getLocation()); 2010dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 201154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Check the template argument, converting it as necessary. 201254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return S.CheckTemplateArgument(Param, ArgLoc, 201354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template, 201454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getLocation(), 201554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getSourceRange().getEnd(), 20166952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ArgumentPackIndex, 201754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Output, 201854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InFunctionTemplate 201954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor ? (Arg.wasDeducedFromArrayBound() 2020dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ? Sema::CTAK_DeducedFromArrayBound 202154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Deduced) 202254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Specified); 202354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 202454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 202531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// Complete template argument deduction for a class template partial 202631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// specialization. 202731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregorstatic Sema::TemplateDeductionResult 2028dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA TakumiFinishTemplateArgumentDeduction(Sema &S, 202931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor ClassTemplatePartialSpecializationDecl *Partial, 203031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 20315f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 20322a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info) { 203359a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 203459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); 203531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::SFINAETrap Trap(S); 2036dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 203731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::ContextRAII SavedContext(S, Partial); 2038f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 203902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // C++ [temp.deduct.type]p2: 204002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // [...] or if any template argument remains neither deduced nor 204102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // explicitly specified, template argument deduction fails. 20425f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 2043033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor TemplateParameterList *PartialParams = Partial->getTemplateParameters(); 2044033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { 204554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NamedDecl *Param = PartialParams->getParam(I); 2046f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Deduced[I].isNull()) { 204754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 204831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Incomplete; 2049f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 2050dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 205154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // We have deduced this argument, so it still needs to be 205254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // checked and converted. 2053dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 205454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // First, for a non-type template parameter type that is 205554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // initialized by a declaration, we need the type of the 205654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // corresponding non-type template parameter. 205754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType; 2058dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NonTypeTemplateParmDecl *NTTP 2059d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 206054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NTTPType = NTTP->getType(); 2061d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType->isDependentType()) { 2062dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2063d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.data(), Builder.size()); 2064d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTPType = S.SubstType(NTTPType, 2065d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 2066d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getLocation(), 2067d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getDeclName()); 2068d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType.isNull()) { 2069d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Info.Param = makeTemplateParameter(Param); 2070d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // FIXME: These template arguments are temporary. Free them! 2071dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(S.Context, 2072dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.data(), 2073d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.size())); 2074d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor return Sema::TDK_SubstitutionFailure; 2075d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2076d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2077d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2078d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor 207954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], 20806952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Partial, NTTPType, 0, Info, false, 208154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Builder)) { 208254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 208354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2084dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 2085dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.size())); 208654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return Sema::TDK_SubstitutionFailure; 208754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 208802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 2089dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 209002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Form the template argument list from the deduced template arguments. 20911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 2092dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 2093910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size()); 2094910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor 2095f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.reset(DeducedArgumentList); 209602cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 209702cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Substitute the deduced template arguments into the template 209802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // arguments of the class template partial specialization, and 209902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // verify that the instantiated template arguments are both valid 210002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // and are equivalent to the template arguments originally provided 21011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // to the class template. 21022a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(S); 210302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); 2104833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall const TemplateArgumentLoc *PartialTemplateArgs 2105833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall = Partial->getTemplateArgsAsWritten(); 2106d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 2107d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall // Note that we don't provide the langle and rangle locations. 2108d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall TemplateArgumentListInfo InstArgs; 2109d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 2110e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (S.Subst(PartialTemplateArgs, 2111e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getNumTemplateArgsAsWritten(), 2112e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { 2113e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; 2114e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (ParamIdx >= Partial->getTemplateParameters()->size()) 2115e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ParamIdx = Partial->getTemplateParameters()->size() - 1; 2116e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 2117e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Decl *Param 2118e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = const_cast<NamedDecl *>( 2119e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getTemplateParameters()->getParam(ParamIdx)); 2120e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2121e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); 2122e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Sema::TDK_SubstitutionFailure; 2123833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 2124833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 21255f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> ConvertedInstArgs; 212631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(), 212754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InstArgs, false, ConvertedInstArgs)) 212831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2129dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 213054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateParameterList *TemplateParams 213154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor = ClassTemplate->getTemplateParameters(); 213254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { 2133910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument InstArg = ConvertedInstArgs.data()[I]; 213431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { 21352fdc5e8199e1e239620f2faae88997153703e16fDouglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); 2136f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = TemplateArgs[I]; 2137f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.SecondArg = InstArg; 213831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 2139f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 214002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 214102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 2142bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor if (Trap.hasErrorOccurred()) 214331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2144bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor 214531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Success; 214631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor} 214731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 214831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// \brief Perform template argument deduction to determine whether 214931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// the given template arguments match the given class template 215031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// partial specialization per C++ [temp.class.spec.match]. 215131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::TemplateDeductionResult 215231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, 215331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 215431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateDeductionInfo &Info) { 215531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // C++ [temp.class.spec.match]p2: 215631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // A partial specialization matches a given actual template 215731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // argument list if the template arguments of the partial 215831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specialization can be deduced from the actual template argument 215931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // list (14.8.2). 216059a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman 216159a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 216259a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 216331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor SFINAETrap Trap(*this); 216459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman 21655f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 216631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced.resize(Partial->getTemplateParameters()->size()); 216731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (TemplateDeductionResult Result 216831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor = ::DeduceTemplateArguments(*this, 216931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateParameters(), 217031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateArgs(), 217131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateArgs, Info, Deduced)) 217231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Result; 217331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 217431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, 21759b623639378d53a675921ddfa7316034d571881eDouglas Gregor Deduced.data(), Deduced.size(), Info); 217631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Inst) 217731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return TDK_InstantiationDepth; 217831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 217931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Trap.hasErrorOccurred()) 218031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2181dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2182dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, 218331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced, Info); 21840b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 2185031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 21864112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor/// \brief Determine whether the given type T is a simple-template-id type. 21874112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregorstatic bool isSimpleTemplateIdType(QualType T) { 21881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *Spec 2189183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = T->getAs<TemplateSpecializationType>()) 21904112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return Spec->getTemplateName().getAsTemplateDecl() != 0; 21911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21924112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return false; 21934112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor} 219483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 219583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Substitute the explicitly-provided template arguments into the 219683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// given function template according to C++ [temp.arg.explicit]. 219783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 219883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template into which the explicit 219983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template arguments will be substituted. 220083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 22011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ExplicitTemplateArguments the explicitly-specified template 220283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// arguments. 220383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 22041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param Deduced the deduced template arguments, which will be populated 220583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// with the converted and checked explicit template arguments. 220683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 22071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ParamTypes will be populated with the instantiated function 220883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// parameters. 220983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 221083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionType if non-NULL, the result type of the function template 221183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// will also be instantiated and the pointed-to value will be updated with 221283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the instantiated function type. 221383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 221483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info if substitution fails for any reason, this object will be 221583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// populated with more information about the failure. 221683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 221783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns TDK_Success if substitution was successful, or some failure 221883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// condition. 221983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 222083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::SubstituteExplicitTemplateArguments( 222183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplateDecl *FunctionTemplate, 222267714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo &ExplicitTemplateArgs, 22235f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 22245f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<QualType> &ParamTypes, 222583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType *FunctionType, 222683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 222783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 222883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 222983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 223083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 2231d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs.size() == 0) { 223283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // No arguments to substitute; just copy over the parameter types and 223383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // fill in the function type. 223483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (FunctionDecl::param_iterator P = Function->param_begin(), 223583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor PEnd = Function->param_end(); 223683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor P != PEnd; 223783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ++P) 223883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.push_back((*P)->getType()); 22391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 224083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) 224183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *FunctionType = Function->getType(); 224283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 224383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 22441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 224559a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 224659a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 22471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 22481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 224983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p3: 22501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Template arguments that are present shall be specified in the 22511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // declaration order of their corresponding template-parameters. The 225283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template argument list shall not specify more template-arguments than 22531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // there are corresponding template-parameters. 22545f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 22551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Enter a new template instantiation context where we check the 225783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments against this function template, 225883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // and then substitute them into the function parameter types. 22591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 226083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplate, Deduced.data(), Deduced.size(), 22619b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, 22629b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 226383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Inst) 226483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InstantiationDepth; 22651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 226683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (CheckTemplateArgumentList(FunctionTemplate, 226783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SourceLocation(), 2268d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall ExplicitTemplateArgs, 226983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor true, 2270f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor Builder) || Trap.hasErrorOccurred()) { 2271910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor unsigned Index = Builder.size(); 2272fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor if (Index >= TemplateParams->size()) 2273fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Index = TemplateParams->size() - 1; 2274fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); 227583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InvalidExplicitArguments; 2276f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor } 22771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 227883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the explicitly-specified 227983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments. 22801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *ExplicitArgumentList 2281910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 228283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(ExplicitArgumentList); 2283dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2284df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // Template argument deduction and the final substitution should be 2285df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // done in the context of the templated declaration. Explicit 2286df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // argument substitution, on the other hand, needs to happen in the 2287df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // calling context. 2288df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 2289df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall 2290dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If we deduced template arguments for a template parameter pack, 2291d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // note that the template argument pack is partially substituted and record 2292d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // the explicit template arguments. They'll be used as part of deduction 2293d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // for this template parameter pack. 2294d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor for (unsigned I = 0, N = Builder.size(); I != N; ++I) { 2295d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument &Arg = Builder[I]; 2296d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 2297d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor CurrentInstantiationScope->SetPartiallySubstitutedPack( 2298dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateParams->getParam(I), 2299d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Arg.pack_begin(), 2300d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Arg.pack_size()); 2301d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor break; 2302d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 2303d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 2304d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 2305eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith const FunctionProtoType *Proto 2306eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith = Function->getType()->getAs<FunctionProtoType>(); 2307eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith assert(Proto && "Function template does not have a prototype?"); 2308eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith 230983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Instantiate the types of each of the function parameters given the 2310eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // explicitly-specified template arguments. If the function has a trailing 2311eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // return type, substitute it after the arguments to ensure we substitute 2312eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // in lexical order. 2313cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (Proto->hasTrailingReturn()) { 2314cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (SubstParmTypes(Function->getLocation(), 2315cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->param_begin(), Function->getNumParams(), 2316cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2317cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ParamTypes)) 2318cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor return TDK_SubstitutionFailure; 2319cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2320cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2321eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // Instantiate the return type. 2322eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // FIXME: exception-specifications? 2323cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor QualType ResultType; 2324cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor { 2325cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // C++11 [expr.prim.general]p3: 2326cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // If a declaration declares a member function or member function 2327cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // template of a class X, the expression this is a prvalue of type 2328cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq 2329cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // and the end of the function-definition, member-declarator, or 2330cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // declarator. 2331cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor unsigned ThisTypeQuals = 0; 2332cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor CXXRecordDecl *ThisContext = 0; 2333cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) { 2334cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ThisContext = Method->getParent(); 2335cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ThisTypeQuals = Method->getTypeQualifiers(); 2336cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2337cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2338cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals, 2339cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor getLangOpts().CPlusPlus0x); 2340cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2341cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ResultType = SubstType(Proto->getResultType(), 2342cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2343cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->getTypeSpecStartLoc(), 2344cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->getDeclName()); 2345cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (ResultType.isNull() || Trap.hasErrorOccurred()) 2346cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor return TDK_SubstitutionFailure; 2347cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2348cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2349eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // Instantiate the types of each of the function parameters given the 2350eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // explicitly-specified template arguments if we didn't do so earlier. 2351eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith if (!Proto->hasTrailingReturn() && 2352eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith SubstParmTypes(Function->getLocation(), 2353eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith Function->param_begin(), Function->getNumParams(), 2354eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2355eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith ParamTypes)) 2356eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith return TDK_SubstitutionFailure; 2357eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith 2358eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith if (FunctionType) { 23591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump *FunctionType = BuildFunctionType(ResultType, 236083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.data(), ParamTypes.size(), 236183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->isVariadic(), 2362eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith Proto->hasTrailingReturn(), 236383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->getTypeQuals(), 2364c938c1668b4fd12af154e965dd935a89e4801a70Douglas Gregor Proto->getRefQualifier(), 236583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getLocation(), 2366fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Function->getDeclName(), 2367fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Proto->getExtInfo()); 236883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType->isNull() || Trap.hasErrorOccurred()) 236983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 237083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 23711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 237283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p2: 23731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Trailing template arguments that can be deduced (14.8.2) may be 23741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // omitted from the list of explicit template-arguments. If all of the 237583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments can be deduced, they may all be omitted; in this 237683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // case, the empty template argument list <> itself may also be omitted. 237783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // 2378d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Take all of the explicitly-specified arguments and put them into 2379d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // the set of deduced template arguments. Explicitly-specified 2380d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // parameter packs, however, will be set to NULL since the deduction 2381d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // mechanisms handle explicitly-specified argument packs directly. 238283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced.reserve(TemplateParams->size()); 2383d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) { 2384d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument &Arg = ExplicitArgumentList->get(I); 2385d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (Arg.getKind() == TemplateArgument::Pack) 2386d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Deduced.push_back(DeducedTemplateArgument()); 2387d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor else 2388d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Deduced.push_back(Arg); 2389d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 23901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 239183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 239283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 239383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 2394b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor/// \brief Check whether the deduced argument type for a call to a function 2395b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor/// template matches the actual argument type per C++ [temp.deduct.call]p4. 2396b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregorstatic bool 2397b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas GregorCheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg, 2398b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType DeducedA) { 2399b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor ASTContext &Context = S.Context; 2400b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2401b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType A = OriginalArg.OriginalArgType; 2402b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType OriginalParamType = OriginalArg.OriginalParamType; 2403b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2404b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Check for type equality (top-level cv-qualifiers are ignored). 2405b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (Context.hasSameUnqualifiedType(A, DeducedA)) 2406b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2407b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2408b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Strip off references on the argument types; they aren't needed for 2409b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // the following checks. 2410b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>()) 2411b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor DeducedA = DeducedARef->getPointeeType(); 2412b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *ARef = A->getAs<ReferenceType>()) 2413b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = ARef->getPointeeType(); 2414b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2415b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // C++ [temp.deduct.call]p4: 2416b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // [...] However, there are three cases that allow a difference: 2417b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 2418b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // type referred to by the reference) can be more cv-qualified than 2419b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // the transformed A. 2420b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *OriginalParamRef 2421b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor = OriginalParamType->getAs<ReferenceType>()) { 2422b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // We don't want to keep the reference around any more. 2423b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor OriginalParamType = OriginalParamRef->getPointeeType(); 2424b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2425b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor Qualifiers AQuals = A.getQualifiers(); 2426b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor Qualifiers DeducedAQuals = DeducedA.getQualifiers(); 2427b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (AQuals == DeducedAQuals) { 2428b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Qualifiers match; there's nothing to do. 2429b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) { 2430c99f0ec89fd9782cfafd14d7b1b0a80151eab24aDouglas Gregor return true; 2431b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } else { 2432b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Qualifiers are compatible, so have the argument type adopt the 2433b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // deduced argument type's qualifiers as if we had performed the 2434b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // qualification conversion. 2435b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals); 2436b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2437b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2438b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2439b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - The transformed A can be another pointer or pointer to member 2440b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // type that can be converted to the deduced A via a qualification 2441b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // conversion. 244218e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // 244318e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // Also allow conversions which merely strip [[noreturn]] from function types 244418e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // (recursively) as an extension. 244518e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // FIXME: Currently, this doesn't place nicely with qualfication conversions. 2446b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor bool ObjCLifetimeConversion = false; 244718e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth QualType ResultTy; 2448b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if ((A->isAnyPointerType() || A->isMemberPointerType()) && 244918e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth (S.IsQualificationConversion(A, DeducedA, false, 245018e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth ObjCLifetimeConversion) || 245118e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth S.IsNoReturnConversion(A, DeducedA, ResultTy))) 2452b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2453b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2454b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2455b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - If P is a class and P has the form simple-template-id, then the 2456b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // transformed A can be a derived class of the deduced A. [...] 2457b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // [...] Likewise, if P is a pointer to a class of the form 2458b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // simple-template-id, the transformed A can be a pointer to a 2459b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // derived class pointed to by the deduced A. 2460b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *OriginalParamPtr 2461b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor = OriginalParamType->getAs<PointerType>()) { 2462b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) { 2463b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *APtr = A->getAs<PointerType>()) { 2464b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (A->getPointeeType()->isRecordType()) { 2465b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor OriginalParamType = OriginalParamPtr->getPointeeType(); 2466b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor DeducedA = DeducedAPtr->getPointeeType(); 2467b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = APtr->getPointeeType(); 2468b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2469b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2470b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2471b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2472b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2473b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (Context.hasSameUnqualifiedType(A, DeducedA)) 2474b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2475b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2476b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) && 2477b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor S.IsDerivedFrom(A, DeducedA)) 2478b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2479b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2480b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return true; 2481b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor} 2482b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 24831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Finish template argument deduction for a function template, 248483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// checking the deduced template arguments for completeness and forming 248583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the function template specialization. 2486dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// 2487dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// \param OriginalCallArgs If non-NULL, the original call arguments against 2488dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// which the deduced argument types should be compared. 24891eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::TemplateDeductionResult 249083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, 24915f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 249202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified, 249383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 2494dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor TemplateDeductionInfo &Info, 24955f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs) { 249683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 249783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 24981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 249959a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 250059a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 250151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor SFINAETrap Trap(*this); 250251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 250351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Enter a new template instantiation context while we instantiate the 250451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // actual function declaration. 250551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 250651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate, Deduced.data(), Deduced.size(), 25079b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, 25089b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 250951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (Inst) 251051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_InstantiationDepth; 251151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 251296db310ab7ca59e1890ddef25a3701bc2909d20fJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 2513f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 251483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.deduct.type]p2: 251583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // [...] or if any template argument remains neither deduced nor 251683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly specified, template argument deduction fails. 25175f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 2518b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 2519b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NamedDecl *Param = TemplateParams->getParam(I); 2520dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 252151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (!Deduced[I].isNull()) { 25223273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor if (I < NumExplicitlySpecified) { 252302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have already fully type-checked and converted this 2524dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // argument, because it was explicitly-specified. Just record the 25253273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor // presence of this argument. 2526910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.push_back(Deduced[I]); 252702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor continue; 252802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 252902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 253002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have deduced this argument, so it still needs to be 253102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // checked and converted. 253202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 253302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // First, for a non-type template parameter type that is 253402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // initialized by a declaration, we need the type of the 253502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // corresponding non-type template parameter. 253602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor QualType NTTPType; 2537dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NonTypeTemplateParmDecl *NTTP 2538dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2539b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = NTTP->getType(); 2540b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType->isDependentType()) { 2541dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2542b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.data(), Builder.size()); 2543b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = SubstType(NTTPType, 2544b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 2545b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getLocation(), 2546b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getDeclName()); 2547b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType.isNull()) { 2548b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2549b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2550dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, 2551dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.data(), 2552b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.size())); 2553b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor return TDK_SubstitutionFailure; 255402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 255502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 255602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 255702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 2558b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I], 25596952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor FunctionTemplate, NTTPType, 0, Info, 256054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor true, Builder)) { 2561b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2562910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2563dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2564dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.size())); 256502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor return TDK_SubstitutionFailure; 256602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 256702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 256851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor continue; 256951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 2570dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2571ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // C++0x [temp.arg.explicit]p3: 2572dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // A trailing template parameter pack (14.5.3) not otherwise deduced will 2573ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // be deduced to an empty sequence of template arguments. 2574ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // FIXME: Where did the word "trailing" come from? 2575ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor if (Param->isTemplateParameterPack()) { 2576d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // We may have had explicitly-specified template arguments for this 2577d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template parameter pack. If so, our empty deduction extends the 2578d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // explicitly-specified set (C++0x [temp.arg.explicit]p9). 2579d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument *ExplicitArgs; 2580d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor unsigned NumExplicitArgs; 2581d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs, 2582d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor &NumExplicitArgs) 2583d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor == Param) 2584d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs)); 2585dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi else 2586d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Builder.push_back(TemplateArgument(0, 0)); 2587dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2588ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor continue; 2589ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor } 259051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 2591dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Substitute into the default template argument, if available. 259251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor TemplateArgumentLoc DefArg 259351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate, 259451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 259551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 259651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Param, 259751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Builder); 259851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 259951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If there was no default argument, deduction is incomplete. 260051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (DefArg.getArgument().isNull()) { 260183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.Param = makeTemplateParameter( 260251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 260383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Incomplete; 260483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 2605dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 260651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Check whether we can actually use the default argument. 260751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (CheckTemplateArgument(Param, DefArg, 260851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate, 260951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 261051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 26116952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor 0, Builder, 26128735b294a257a07ca158c28094d7324f0adf889aDouglas Gregor CTAK_Specified)) { 261351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Info.Param = makeTemplateParameter( 261451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 2615910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2616dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2617910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size())); 261851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_SubstitutionFailure; 261951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 26201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 262151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If we get here, we successfully used the default template argument. 262283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 26231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 262483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the deduced template arguments. 26251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 2626910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 262783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(DeducedArgumentList); 26281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 26291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Substitute the deduced template arguments into the function template 263083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration to produce the function template specialization. 2631d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor DeclContext *Owner = FunctionTemplate->getDeclContext(); 2632d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor if (FunctionTemplate->getFriendObjectKind()) 2633d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor Owner = FunctionTemplate->getLexicalDeclContext(); 263483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization = cast_or_null<FunctionDecl>( 2635d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, 2636357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor MultiLevelTemplateArgumentList(*DeducedArgumentList))); 26375fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor if (!Specialization || Specialization->isInvalidDecl()) 263883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 26391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2640dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == 2641f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor FunctionTemplate->getCanonicalDecl()); 2642dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 26431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the template argument list is owned by the function template 264483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // specialization, release it. 2645ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList && 2646ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor !Trap.hasErrorOccurred()) 264783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.take(); 26481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 26495fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // There may have been an error that did not prevent us from constructing a 26505fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // declaration. Mark the declaration invalid and return with a substitution 26515fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // failure. 26525fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor if (Trap.hasErrorOccurred()) { 26535fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor Specialization->setInvalidDecl(true); 26545fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor return TDK_SubstitutionFailure; 26555fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor } 26565fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor 2657dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (OriginalCallArgs) { 2658dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // C++ [temp.deduct.call]p4: 2659dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // In general, the deduction process attempts to find template argument 2660dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // values that will make the deduced A identical to A (after the type A 2661dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // is transformed as described above). [...] 2662dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) { 2663dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor OriginalCallArg OriginalArg = (*OriginalCallArgs)[I]; 2664dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor unsigned ParamIdx = OriginalArg.ArgIdx; 2665dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 2666dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (ParamIdx >= Specialization->getNumParams()) 2667dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor continue; 2668dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 2669dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType(); 2670b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) 2671b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return Sema::TDK_SubstitutionFailure; 2672dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor } 2673dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor } 2674dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 26759b623639378d53a675921ddfa7316034d571881eDouglas Gregor // If we suppressed any diagnostics while performing template argument 26769b623639378d53a675921ddfa7316034d571881eDouglas Gregor // deduction, and if we haven't already instantiated this declaration, 26779b623639378d53a675921ddfa7316034d571881eDouglas Gregor // keep track of these diagnostics. They'll be emitted if this specialization 26789b623639378d53a675921ddfa7316034d571881eDouglas Gregor // is actually used. 26799b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Info.diag_begin() != Info.diag_end()) { 26805f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >::iterator 26819b623639378d53a675921ddfa7316034d571881eDouglas Gregor Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); 26829b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Pos == SuppressedDiagnostics.end()) 26839b623639378d53a675921ddfa7316034d571881eDouglas Gregor SuppressedDiagnostics[Specialization->getCanonicalDecl()] 26849b623639378d53a675921ddfa7316034d571881eDouglas Gregor .append(Info.diag_begin(), Info.diag_end()); 2685dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi } 26869b623639378d53a675921ddfa7316034d571881eDouglas Gregor 26871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TDK_Success; 268883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 268983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 26909c72c6088d591ace8503b842d39448c2040f3033John McCall/// Gets the type of a function for template-argument-deducton 26919c72c6088d591ace8503b842d39448c2040f3033John McCall/// purposes when it's considered as part of an overload set. 2692eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType GetTypeOfFunction(ASTContext &Context, 26939c72c6088d591ace8503b842d39448c2040f3033John McCall const OverloadExpr::FindResult &R, 2694eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn) { 2695eff92135d32039c9874dc356f3e93143af6069c1John McCall if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) 26969c72c6088d591ace8503b842d39448c2040f3033John McCall if (Method->isInstance()) { 26979c72c6088d591ace8503b842d39448c2040f3033John McCall // An instance method that's referenced in a form that doesn't 26989c72c6088d591ace8503b842d39448c2040f3033John McCall // look like a member pointer is just invalid. 26999c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.HasFormOfMemberPointer) return QualType(); 27009c72c6088d591ace8503b842d39448c2040f3033John McCall 2701eff92135d32039c9874dc356f3e93143af6069c1John McCall return Context.getMemberPointerType(Fn->getType(), 2702eff92135d32039c9874dc356f3e93143af6069c1John McCall Context.getTypeDeclType(Method->getParent()).getTypePtr()); 27039c72c6088d591ace8503b842d39448c2040f3033John McCall } 27049c72c6088d591ace8503b842d39448c2040f3033John McCall 27059c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.IsAddressOfOperand) return Fn->getType(); 2706eff92135d32039c9874dc356f3e93143af6069c1John McCall return Context.getPointerType(Fn->getType()); 2707eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2708eff92135d32039c9874dc356f3e93143af6069c1John McCall 2709eff92135d32039c9874dc356f3e93143af6069c1John McCall/// Apply the deduction rules for overload sets. 2710eff92135d32039c9874dc356f3e93143af6069c1John McCall/// 2711eff92135d32039c9874dc356f3e93143af6069c1John McCall/// \return the null type if this argument should be treated as an 2712eff92135d32039c9874dc356f3e93143af6069c1John McCall/// undeduced context 2713eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType 2714eff92135d32039c9874dc356f3e93143af6069c1John McCallResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, 271575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor Expr *Arg, QualType ParamType, 271675f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor bool ParamWasReference) { 2717dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 27189c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr::FindResult R = OverloadExpr::find(Arg); 2719eff92135d32039c9874dc356f3e93143af6069c1John McCall 27209c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr *Ovl = R.Expression; 2721eff92135d32039c9874dc356f3e93143af6069c1John McCall 272275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // C++0x [temp.deduct.call]p4 272375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor unsigned TDF = 0; 272475f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (ParamWasReference) 272575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_ParamWithReferenceType; 272675f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (R.IsAddressOfOperand) 272775f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_IgnoreQualifiers; 272875f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 2729eff92135d32039c9874dc356f3e93143af6069c1John McCall // C++0x [temp.deduct.call]p6: 2730eff92135d32039c9874dc356f3e93143af6069c1John McCall // When P is a function type, pointer to function type, or pointer 2731eff92135d32039c9874dc356f3e93143af6069c1John McCall // to member function type: 2732eff92135d32039c9874dc356f3e93143af6069c1John McCall 2733eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!ParamType->isFunctionType() && 2734eff92135d32039c9874dc356f3e93143af6069c1John McCall !ParamType->isFunctionPointerType() && 2735860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor !ParamType->isMemberFunctionPointerType()) { 2736860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (Ovl->hasExplicitTemplateArgs()) { 2737860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // But we can still look for an explicit specialization. 2738860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (FunctionDecl *ExplicitSpec 2739860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor = S.ResolveSingleFunctionTemplateSpecialization(Ovl)) 2740860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor return GetTypeOfFunction(S.Context, R, ExplicitSpec); 2741860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 2742eff92135d32039c9874dc356f3e93143af6069c1John McCall 2743860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor return QualType(); 2744860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 2745860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 2746860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // Gather the explicit template arguments, if any. 2747860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor TemplateArgumentListInfo ExplicitTemplateArgs; 2748860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (Ovl->hasExplicitTemplateArgs()) 2749860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs); 2750eff92135d32039c9874dc356f3e93143af6069c1John McCall QualType Match; 27517bb12da2b0749eeebb21854c77877736969e59f2John McCall for (UnresolvedSetIterator I = Ovl->decls_begin(), 27527bb12da2b0749eeebb21854c77877736969e59f2John McCall E = Ovl->decls_end(); I != E; ++I) { 2753eff92135d32039c9874dc356f3e93143af6069c1John McCall NamedDecl *D = (*I)->getUnderlyingDecl(); 2754eff92135d32039c9874dc356f3e93143af6069c1John McCall 2755860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) { 2756860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // - If the argument is an overload set containing one or more 2757860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // function templates, the parameter is treated as a 2758860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // non-deduced context. 2759860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (!Ovl->hasExplicitTemplateArgs()) 2760860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor return QualType(); 2761860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 2762860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // Otherwise, see if we can resolve a function type 2763860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor FunctionDecl *Specialization = 0; 2764860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor TemplateDeductionInfo Info(S.Context, Ovl->getNameLoc()); 2765860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs, 2766860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor Specialization, Info)) 2767860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor continue; 2768860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 2769860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor D = Specialization; 2770860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 2771eff92135d32039c9874dc356f3e93143af6069c1John McCall 2772eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn = cast<FunctionDecl>(D); 27739c72c6088d591ace8503b842d39448c2040f3033John McCall QualType ArgType = GetTypeOfFunction(S.Context, R, Fn); 27749c72c6088d591ace8503b842d39448c2040f3033John McCall if (ArgType.isNull()) continue; 2775eff92135d32039c9874dc356f3e93143af6069c1John McCall 277675f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // Function-to-pointer conversion. 2777dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (!ParamWasReference && ParamType->isPointerType() && 277875f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType->isFunctionType()) 277975f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 2780dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2781eff92135d32039c9874dc356f3e93143af6069c1John McCall // - If the argument is an overload set (not containing function 2782eff92135d32039c9874dc356f3e93143af6069c1John McCall // templates), trial argument deduction is attempted using each 2783eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the members of the set. If deduction succeeds for only one 2784eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the overload set members, that member is used as the 2785eff92135d32039c9874dc356f3e93143af6069c1John McCall // argument value for the deduction. If deduction succeeds for 2786eff92135d32039c9874dc356f3e93143af6069c1John McCall // more than one member of the overload set the parameter is 2787eff92135d32039c9874dc356f3e93143af6069c1John McCall // treated as a non-deduced context. 2788eff92135d32039c9874dc356f3e93143af6069c1John McCall 2789eff92135d32039c9874dc356f3e93143af6069c1John McCall // We do all of this in a fresh context per C++0x [temp.deduct.type]p2: 2790eff92135d32039c9874dc356f3e93143af6069c1John McCall // Type deduction is done independently for each P/A pair, and 2791eff92135d32039c9874dc356f3e93143af6069c1John McCall // the deduced template argument values are then combined. 2792eff92135d32039c9874dc356f3e93143af6069c1John McCall // So we do not reject deductions which were made elsewhere. 27935f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 8> 279402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Deduced(TemplateParams->size()); 27952a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(S.Context, Ovl->getNameLoc()); 2796eff92135d32039c9874dc356f3e93143af6069c1John McCall Sema::TemplateDeductionResult Result 2797bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, 2798bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ArgType, Info, Deduced, TDF); 2799eff92135d32039c9874dc356f3e93143af6069c1John McCall if (Result) continue; 2800eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!Match.isNull()) return QualType(); 2801eff92135d32039c9874dc356f3e93143af6069c1John McCall Match = ArgType; 2802eff92135d32039c9874dc356f3e93143af6069c1John McCall } 2803eff92135d32039c9874dc356f3e93143af6069c1John McCall 2804eff92135d32039c9874dc356f3e93143af6069c1John McCall return Match; 2805eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2806eff92135d32039c9874dc356f3e93143af6069c1John McCall 2807dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \brief Perform the adjustments to the parameter and argument types 2808f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// described in C++ [temp.deduct.call]. 2809f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// 2810f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// \returns true if the caller should not attempt to perform any template 2811f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// argument deduction based on this P/A pair. 2812f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregorstatic bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, 2813f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TemplateParameterList *TemplateParams, 2814f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ParamType, 2815f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ArgType, 2816f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg, 2817f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned &TDF) { 2818f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 28190099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // If P is a cv-qualified type, the top level cv-qualifiers of P's type 2820f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // are ignored for type deduction. 2821a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor if (ParamType.hasQualifiers()) 2822a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor ParamType = ParamType.getUnqualifiedType(); 2823f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>(); 2824f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 282534b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType PointeeType = ParamRefType->getPointeeType(); 282634b41d939a1328f484511c6002ba2456db879a29Richard Smith 2827f15748a28c8443eef2924ef83689c358c661e9c5Douglas Gregor // If the argument has incomplete array type, try to complete it's type. 2828d10099e5c8238fa0327f03921cf2e3c8975c881eDouglas Gregor if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0)) 2829f15748a28c8443eef2924ef83689c358c661e9c5Douglas Gregor ArgType = Arg->getType(); 2830f15748a28c8443eef2924ef83689c358c661e9c5Douglas Gregor 28312ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // [C++0x] If P is an rvalue reference to a cv-unqualified 28322ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // template parameter and the argument is an lvalue, the type 28332ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // "lvalue reference to A" is used in place of A for type 28342ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // deduction. 283534b41d939a1328f484511c6002ba2456db879a29Richard Smith if (isa<RValueReferenceType>(ParamType)) { 283634b41d939a1328f484511c6002ba2456db879a29Richard Smith if (!PointeeType.getQualifiers() && 283734b41d939a1328f484511c6002ba2456db879a29Richard Smith isa<TemplateTypeParmType>(PointeeType) && 28389625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->Classify(S.Context).isLValue() && 28399625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->getType() != S.Context.OverloadTy && 28409625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->getType() != S.Context.BoundMemberTy) 28412ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor ArgType = S.Context.getLValueReferenceType(ArgType); 28422ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor } 28432ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor 2844f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is a reference type, the type referred to by P is used 2845f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for type deduction. 284634b41d939a1328f484511c6002ba2456db879a29Richard Smith ParamType = PointeeType; 2847f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2848dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2849f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Overload sets usually make this parameter an undeduced 2850f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // context, but there are sometimes special circumstances. 2851f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType == S.Context.OverloadTy) { 2852f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = ResolveOverloadForDeduction(S, TemplateParams, 2853f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg, ParamType, 2854f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType != 0); 2855f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType.isNull()) 2856f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return true; 2857f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2858dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2859f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 2860f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 2861f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is of the form T&&, where T is a template parameter, and 2862f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the argument is an lvalue, the type A& is used in place of A for 2863f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type deduction. 2864f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType->isRValueReferenceType() && 2865f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType->getAs<TemplateTypeParmType>() && 2866f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg->isLValue()) 2867f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getLValueReferenceType(ArgType); 2868f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } else { 2869f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++ [temp.deduct.call]p2: 2870f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // If P is not a reference type: 2871f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is an array type, the pointer type produced by the 2872f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // array-to-pointer standard conversion (4.2) is used in place of 2873f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // A for type deduction; otherwise, 2874f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isArrayType()) 2875f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getArrayDecayedType(ArgType); 2876f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is a function type, the pointer type produced by the 2877f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // function-to-pointer standard conversion (4.3) is used in place 2878f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // of A for type deduction; otherwise, 2879f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (ArgType->isFunctionType()) 2880f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 2881f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else { 28820099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // - If A is a cv-qualified type, the top level cv-qualifiers of A's 2883f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type are ignored for type deduction. 2884a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor ArgType = ArgType.getUnqualifiedType(); 2885f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2886f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2887dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2888f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p4: 2889f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // In general, the deduction process attempts to find template argument 2890f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // values that will make the deduced A identical to A (after the type A 2891f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // is transformed as described above). [...] 2892f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF = TDF_SkipNonDependent; 2893dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2894f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 2895f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type referred to by the reference) can be more cv-qualified than 2896f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the transformed A. 2897f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) 2898f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_ParamWithReferenceType; 2899f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - The transformed A can be another pointer or pointer to member 2900f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type that can be converted to the deduced A via a qualification 2901f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // conversion (4.4). 2902f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isPointerType() || ArgType->isMemberPointerType() || 2903f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType->isObjCObjectPointerType()) 2904f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_IgnoreQualifiers; 2905f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If P is a class and P has the form simple-template-id, then the 2906f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a derived class of the deduced A. Likewise, 2907f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // if P is a pointer to a class of the form simple-template-id, the 2908f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a pointer to a derived class pointed to by 2909f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the deduced A. 2910f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (isSimpleTemplateIdType(ParamType) || 2911f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor (isa<PointerType>(ParamType) && 2912f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor isSimpleTemplateIdType( 2913f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType->getAs<PointerType>()->getPointeeType()))) 2914f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_DerivedClass; 2915dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2916f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return false; 2917f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor} 2918f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2919dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregorstatic bool hasDeducibleTemplateParameters(Sema &S, 2920dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor FunctionTemplateDecl *FunctionTemplate, 2921dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType T); 2922dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 29234b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// \brief Perform template argument deduction by matching a parameter type 29244b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// against a single expression, where the expression is an element of 29254b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// an initializer list that was originally matched against the argument 29264b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// type. 29274b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redlstatic Sema::TemplateDeductionResult 29284b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian RedlDeduceTemplateArgumentByListElement(Sema &S, 29294b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl TemplateParameterList *TemplateParams, 29304b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl QualType ParamType, Expr *Arg, 29314b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl TemplateDeductionInfo &Info, 29324b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl SmallVectorImpl<DeducedTemplateArgument> &Deduced, 29334b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl unsigned TDF) { 29344b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // Handle the case where an init list contains another init list as the 29354b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // element. 29364b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 29374b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl QualType X; 29384b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X)) 29394b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Sema::TDK_Success; // Just ignore this expression. 29404b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 29414b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // Recurse down into the init list. 29424b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 29434b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (Sema::TemplateDeductionResult Result = 29444b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl DeduceTemplateArgumentByListElement(S, TemplateParams, X, 29454b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl ILE->getInit(i), 29464b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl Info, Deduced, TDF)) 29474b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Result; 29484b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl } 29494b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Sema::TDK_Success; 29504b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl } 29514b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 29524b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // For all other cases, just match by type. 2953d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor QualType ArgType = Arg->getType(); 2954d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, 2955d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor ArgType, Arg, TDF)) 2956d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor return Sema::TDK_FailedOverloadResolution; 29574b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, 2958d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor ArgType, Info, Deduced, TDF); 29594b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl} 29604b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 2961e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \brief Perform template argument deduction from a function call 2962e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// (C++ [temp.deduct.call]). 2963e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2964e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 2965e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 2966e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 296748026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// \param ExplicitTemplateArguments the explicit template arguments provided 296848026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// for this call. 29696db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// 2970e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Args the function call arguments 2971e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2972e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param NumArgs the number of arguments in Args 2973e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 297448026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// \param Name the name of the function being called. This is only significant 297548026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// when the function template is a conversion function template, in which 297648026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// case this routine will also perform template argument deduction based on 2977dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// the function to which 297848026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// 2979e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Specialization if template argument deduction was successful, 29801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 2981e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 2982e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2983e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Info the argument will be updated to provide additional information 2984e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// about template argument deduction. 2985e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2986e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \returns the result of template argument deduction. 2987e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::TemplateDeductionResult 2988e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 298967714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 299013a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles llvm::ArrayRef<Expr *> Args, 2991e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *&Specialization, 2992e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateDeductionInfo &Info) { 2993e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 29946db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor 2995e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++ [temp.deduct.call]p1: 2996e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // Template argument deduction is done by comparing each function template 2997e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // parameter type (call it P) with the type of the corresponding argument 2998e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // of the call (call it A) as described below. 299913a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles unsigned CheckArgs = Args.size(); 300013a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles if (Args.size() < Function->getMinRequiredArguments()) 3001e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooFewArguments; 300213a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles else if (Args.size() > Function->getNumParams()) { 30031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *Proto 3004183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Function->getType()->getAs<FunctionProtoType>(); 3005f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Proto->isTemplateVariadic()) 3006f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor /* Do nothing */; 3007f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (Proto->isVariadic()) 3008f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor CheckArgs = Function->getNumParams(); 3009dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi else 3010e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooManyArguments; 3011e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 30121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 30136db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // The types of the parameters from which we will perform template argument 30146db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // deduction. 30152a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 3016e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateParameterList *TemplateParams 3017e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor = FunctionTemplate->getTemplateParameters(); 30185f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 30195f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> ParamTypes; 302002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 3021d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 302283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionResult Result = 302383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SubstituteExplicitTemplateArguments(FunctionTemplate, 3024d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 302583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced, 302683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes, 302783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 0, 302883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info); 302983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Result) 303083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 303102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 303202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 30336db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } else { 30346db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Just fill in the parameter types from the function declaration. 3035f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 30366db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor ParamTypes.push_back(Function->getParamDecl(I)->getType()); 30376db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } 30381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 30396db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Deduce template arguments from the function parameters. 30401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 3041f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned ArgIdx = 0; 30425f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<OriginalCallArg, 4> OriginalCallArgs; 3043dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (unsigned ParamIdx = 0, NumParams = ParamTypes.size(); 3044f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamIdx != NumParams; ++ParamIdx) { 3045dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType OrigParamType = ParamTypes[ParamIdx]; 3046dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType ParamType = OrigParamType; 3047dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3048dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const PackExpansionType *ParamExpansion 3049f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = dyn_cast<PackExpansionType>(ParamType); 3050f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!ParamExpansion) { 3051f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Simple case: matching a function parameter to a function argument. 3052f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgIdx >= CheckArgs) 3053f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3054dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3055f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx++]; 3056f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 3057dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3058f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 3059f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 3060f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 3061f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 3062f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 3063dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3064d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor // If we have nothing to deduce, we're done. 3065d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) 3066d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor continue; 3067d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor 306884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // If the argument is an initializer list ... 306984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 307084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // ... then the parameter is an undeduced context, unless the parameter 307184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // type is (reference to cv) std::initializer_list<P'>, in which case 307284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // deduction is done for each element of the initializer list, and the 307384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // result is the deduced type if it's the same for all elements. 307484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl QualType X; 307584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Removing references was already done. 307684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (!isStdInitializerList(ParamType, &X)) 307784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl continue; 307884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 307984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 308084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result = 30814b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl DeduceTemplateArgumentByListElement(*this, TemplateParams, X, 30824b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl ILE->getInit(i), 30834b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl Info, Deduced, TDF)) 308484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 308584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 308684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Don't track the argument type, since an initializer list has none. 308784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl continue; 308884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 308984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 3090dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // Keep track of the argument type and corresponding parameter index, 3091dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // so we can check for compatibility between the deduced A and A. 3092d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1, 3093d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor ArgType)); 3094dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3095f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (TemplateDeductionResult Result 3096bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 3097bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ParamType, ArgType, 3098bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 3099f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return Result; 31001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3101f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 310275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor } 3103dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3104f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p1: 3105dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // For a function parameter pack that occurs at the end of the 3106dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // parameter-declaration-list, the type A of each remaining argument of 3107dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the call is compared with the type P of the declarator-id of the 3108dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // function parameter pack. Each comparison deduces template arguments 3109dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // for subsequent positions in the template parameter packs expanded by 31107d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // the function parameter pack. For a function parameter pack that does 3111dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // not occur at the end of the parameter-declaration-list, the type of 31127d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // the parameter pack is a non-deduced context. 31137d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor if (ParamIdx + 1 < NumParams) 31147d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor break; 3115dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3116f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ParamPattern = ParamExpansion->getPattern(); 31175f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 3118f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor { 3119013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 31205f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3121f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor collectUnexpandedParameterPacks(ParamPattern, Unexpanded); 3122f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 3123f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned Depth, Index; 3124f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 3125f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 3126f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor SawIndices[Index] = true; 3127f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor PackIndices.push_back(Index); 3128f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3129f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3130f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3131f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 3132dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3133d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Keep track of the deduced template arguments for each parameter pack 3134dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 3135d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template argument (the inner SmallVectors). 31365f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2> 3137d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 31385f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 3139d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor SavedPacks(PackIndices.size()); 31405429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks, 3141dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks); 3142f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor bool HasAnyArguments = false; 314313a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles for (; ArgIdx < Args.size(); ++ArgIdx) { 3144f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor HasAnyArguments = true; 3145dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3146dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType OrigParamType = ParamPattern; 3147dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor ParamType = OrigParamType; 3148f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx]; 3149f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 3150dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3151f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 3152f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 3153f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 3154f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) { 3155f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // We can't actually perform any deduction for this argument, so stop 3156f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // deduction at this point. 3157f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ++ArgIdx; 3158f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3159f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3160dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 316184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // As above, initializer lists need special handling. 316284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 316384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl QualType X; 316484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (!isStdInitializerList(ParamType, &X)) { 316584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ++ArgIdx; 316684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl break; 316784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 3168dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 316984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 317084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result = 317184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X, 317284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ILE->getInit(i)->getType(), 317384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl Info, Deduced, TDF)) 317484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 317584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 317684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } else { 317784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 317884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Keep track of the argument type and corresponding argument index, 317984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // so we can check for compatibility between the deduced A and A. 318084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) 318184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx, 318284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ArgType)); 318384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 318484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result 318584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 318684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ParamType, ArgType, Info, 318784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl Deduced, TDF)) 318884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 318984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 3190eff92135d32039c9874dc356f3e93143af6069c1John McCall 3191f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 3192f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 3193f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for that pack, then clear out the deduced argument. 3194f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 3195f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 3196f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!DeducedArg.isNull()) { 3197f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 3198f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedArg = DeducedTemplateArgument(); 3199f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3200e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 3201e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 3202dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3203f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 3204f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // pack expansion. 32050216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 3206dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments, 32070216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 32080216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 3209dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 32101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3211f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // After we've matching against a parameter pack, we're done. 3212f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3213e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 321465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 32151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 321602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified, 3217dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor Specialization, Info, &OriginalCallArgs); 321883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 3219127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor 322083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Deduce template arguments when taking the address of a function 32214b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to 32224b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// a template. 322383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 322483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template for which we are performing 322583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 322683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 3227dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \param ExplicitTemplateArguments the explicitly-specified template 32284b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 322983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 323083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ArgFunctionType the function type that will be used as the 323183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// "argument" type (A) when performing template argument deduction from the 32324b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// function template's function type. This type may be NULL, if there is no 32334b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// argument type to compare against, in C++0x [temp.arg.explicit]p3. 323483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 323583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Specialization if template argument deduction was successful, 32361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 323783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 323883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 323983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info the argument will be updated to provide additional information 324083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// about template argument deduction. 324183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 324283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns the result of template argument deduction. 324383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 324483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 324567714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 324683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType ArgFunctionType, 324783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 324883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 324983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 325083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 325183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 325283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType FunctionType = Function->getType(); 32531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 325483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitute any explicit template arguments. 32552a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 32565f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 325702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 32585f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> ParamTypes; 3259d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 32601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (TemplateDeductionResult Result 32611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump = SubstituteExplicitTemplateArguments(FunctionTemplate, 3262d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 32631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced, ParamTypes, 326483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor &FunctionType, Info)) 326583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 326602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 326702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 3268127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor } 326983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 327059a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 327159a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 32721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 32731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3274eff92135d32039c9874dc356f3e93143af6069c1John McCall Deduced.resize(TemplateParams->size()); 3275eff92135d32039c9874dc356f3e93143af6069c1John McCall 32764b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (!ArgFunctionType.isNull()) { 32774b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // Deduce template arguments from the function type. 32784b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (TemplateDeductionResult Result 3279bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 32804b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionType, ArgFunctionType, Info, 328173b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor Deduced, TDF_TopLevelParameterTypeList)) 32824b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return Result; 32834b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 3284fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 3285dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (TemplateDeductionResult Result 3286fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 3287fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor NumExplicitlySpecified, 3288fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor Specialization, Info)) 3289fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return Result; 3290fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 3291fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // If the requested function type does not match the actual type of the 3292fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // specialization, template argument deduction fails. 3293fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor if (!ArgFunctionType.isNull() && 3294fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor !Context.hasSameType(ArgFunctionType, Specialization->getType())) 3295fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_NonDeducedMismatch; 3296fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 3297fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_Success; 3298e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor} 3299e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 330065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \brief Deduce template arguments for a templated conversion 330165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// function (C++ [temp.deduct.conv]) and, if successful, produce a 330265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// conversion function template specialization. 330365ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::TemplateDeductionResult 330465ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 330565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType ToType, 330665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor CXXConversionDecl *&Specialization, 330765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionInfo &Info) { 33081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CXXConversionDecl *Conv 330965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()); 331065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType FromType = Conv->getConversionType(); 331165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 331265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Canonicalize the types for deduction. 331365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType P = Context.getCanonicalType(FromType); 331465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType A = Context.getCanonicalType(ToType); 331565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 33165453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p2: 331765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If P is a reference type, the type referred to by P is used for 331865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type deduction. 331965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *PRef = P->getAs<ReferenceType>()) 332065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = PRef->getPointeeType(); 332165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 33225453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p4: 33235453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // [...] If A is a reference type, the type referred to by A is used 332465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // for type deduction. 332565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *ARef = A->getAs<ReferenceType>()) 33265453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor A = ARef->getPointeeType().getUnqualifiedType(); 33275453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++ [temp.deduct.conv]p3: 332865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 33291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If A is not a reference type: 333065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else { 333165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor assert(!A->isReferenceType() && "Reference types were handled above"); 333265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 333365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is an array type, the pointer type produced by the 33341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // array-to-pointer standard conversion (4.2) is used in place 333565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // of P for type deduction; otherwise, 333665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (P->isArrayType()) 333765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getArrayDecayedType(P); 333865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a function type, the pointer type produced by the 333965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // function-to-pointer standard conversion (4.3) is used in 334065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // place of P for type deduction; otherwise, 334165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else if (P->isFunctionType()) 334265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getPointerType(P); 334365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a cv-qualified type, the top level cv-qualifiers of 33440099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // P's type are ignored for type deduction. 334565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else 334665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = P.getUnqualifiedType(); 334765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 33485453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p4: 33490099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // If A is a cv-qualified type, the top level cv-qualifiers of A's 33505453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // type are ignored for type deduction. If A is a reference type, the type 33515453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // referred to by A is used for type deduction. 335265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor A = A.getUnqualifiedType(); 335365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor } 335465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 335559a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 335659a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 33571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 335865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 335965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++ [temp.deduct.conv]p1: 336065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Template argument deduction is done by comparing the return 336165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type of the template conversion function (call it P) with the 336265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type that is required as the result of the conversion (call it 336365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A) as described in 14.8.2.4. 336465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateParameterList *TemplateParams 336565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = FunctionTemplate->getTemplateParameters(); 33665f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 33671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 336865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 336965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p4: 337065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // In general, the deduction process attempts to find template 337165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // argument values that will make the deduced A identical to 337265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A. However, there are two cases that allow a difference: 337365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor unsigned TDF = 0; 337465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If the original A is a reference type, A can be more 337565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // cv-qualified than the deduced A (i.e., the type referred to 337665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // by the reference) 337765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (ToType->isReferenceType()) 337865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_ParamWithReferenceType; 337965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - The deduced A can be another pointer or pointer to member 33800099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // type that can be converted to A via a qualification 338165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // conversion. 338265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 338365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when 338465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // both P and A are pointers or member pointers. In this case, we 338565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // just ignore cv-qualifiers completely). 338665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if ((P->isPointerType() && A->isPointerType()) || 33872cae1e216c12c7574f5ac59cb0844d22bed9401dDouglas Gregor (P->isMemberPointerType() && A->isMemberPointerType())) 338865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_IgnoreQualifiers; 338965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (TemplateDeductionResult Result 3390bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 3391bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl P, A, Info, Deduced, TDF)) 339265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 339365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 339465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Finish template argument deduction. 33952a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 339665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionDecl *Spec = 0; 339765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionResult Result 3398dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec, 339902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Info); 340065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor Specialization = cast_or_null<CXXConversionDecl>(Spec); 340165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 340265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 340365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 34044b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \brief Deduce template arguments for a function template when there is 34054b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// nothing to deduce against (C++0x [temp.arg.explicit]p3). 34064b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 34074b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 34084b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 34094b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 3410dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \param ExplicitTemplateArguments the explicitly-specified template 34114b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 34124b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 34134b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Specialization if template argument deduction was successful, 34144b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// this will be set to the function template specialization produced by 34154b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 34164b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 34174b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Info the argument will be updated to provide additional information 34184b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// about template argument deduction. 34194b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 34204b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \returns the result of template argument deduction. 34214b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::TemplateDeductionResult 34224b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 342367714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 34244b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionDecl *&Specialization, 34254b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor TemplateDeductionInfo &Info) { 34264b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, 34274b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor QualType(), Specialization, Info); 34284b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor} 34294b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor 343034b41d939a1328f484511c6002ba2456db879a29Richard Smithnamespace { 343134b41d939a1328f484511c6002ba2456db879a29Richard Smith /// Substitute the 'auto' type specifier within a type for a given replacement 343234b41d939a1328f484511c6002ba2456db879a29Richard Smith /// type. 343334b41d939a1328f484511c6002ba2456db879a29Richard Smith class SubstituteAutoTransform : 343434b41d939a1328f484511c6002ba2456db879a29Richard Smith public TreeTransform<SubstituteAutoTransform> { 343534b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType Replacement; 343634b41d939a1328f484511c6002ba2456db879a29Richard Smith public: 343734b41d939a1328f484511c6002ba2456db879a29Richard Smith SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) : 343834b41d939a1328f484511c6002ba2456db879a29Richard Smith TreeTransform<SubstituteAutoTransform>(SemaRef), Replacement(Replacement) { 343934b41d939a1328f484511c6002ba2456db879a29Richard Smith } 344034b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) { 344134b41d939a1328f484511c6002ba2456db879a29Richard Smith // If we're building the type pattern to deduce against, don't wrap the 344234b41d939a1328f484511c6002ba2456db879a29Richard Smith // substituted type in an AutoType. Certain template deduction rules 344334b41d939a1328f484511c6002ba2456db879a29Richard Smith // apply only when a template type parameter appears directly (and not if 344434b41d939a1328f484511c6002ba2456db879a29Richard Smith // the parameter is found through desugaring). For instance: 344534b41d939a1328f484511c6002ba2456db879a29Richard Smith // auto &&lref = lvalue; 344634b41d939a1328f484511c6002ba2456db879a29Richard Smith // must transform into "rvalue reference to T" not "rvalue reference to 344734b41d939a1328f484511c6002ba2456db879a29Richard Smith // auto type deduced as T" in order for [temp.deduct.call]p3 to apply. 344834b41d939a1328f484511c6002ba2456db879a29Richard Smith if (isa<TemplateTypeParmType>(Replacement)) { 344934b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType Result = Replacement; 345034b41d939a1328f484511c6002ba2456db879a29Richard Smith TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result); 345134b41d939a1328f484511c6002ba2456db879a29Richard Smith NewTL.setNameLoc(TL.getNameLoc()); 345234b41d939a1328f484511c6002ba2456db879a29Richard Smith return Result; 345334b41d939a1328f484511c6002ba2456db879a29Richard Smith } else { 345434b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType Result = RebuildAutoType(Replacement); 345534b41d939a1328f484511c6002ba2456db879a29Richard Smith AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); 345634b41d939a1328f484511c6002ba2456db879a29Richard Smith NewTL.setNameLoc(TL.getNameLoc()); 345734b41d939a1328f484511c6002ba2456db879a29Richard Smith return Result; 345834b41d939a1328f484511c6002ba2456db879a29Richard Smith } 345934b41d939a1328f484511c6002ba2456db879a29Richard Smith } 3460dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor 3461dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor ExprResult TransformLambdaExpr(LambdaExpr *E) { 3462dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor // Lambdas never need to be transformed. 3463dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor return E; 3464dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor } 346534b41d939a1328f484511c6002ba2456db879a29Richard Smith }; 346634b41d939a1328f484511c6002ba2456db879a29Richard Smith} 346734b41d939a1328f484511c6002ba2456db879a29Richard Smith 346834b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \brief Deduce the type for an auto type-specifier (C++0x [dcl.spec.auto]p6) 346934b41d939a1328f484511c6002ba2456db879a29Richard Smith/// 347034b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Type the type pattern using the auto type-specifier. 347134b41d939a1328f484511c6002ba2456db879a29Richard Smith/// 347234b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Init the initializer for the variable whose type is to be deduced. 347334b41d939a1328f484511c6002ba2456db879a29Richard Smith/// 347434b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Result if type deduction was successful, this will be set to the 347534b41d939a1328f484511c6002ba2456db879a29Richard Smith/// deduced type. This may still contain undeduced autos if the type is 3476a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith/// dependent. This will be set to null if deduction succeeded, but auto 3477a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith/// substitution failed; the appropriate diagnostic will already have been 3478a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith/// produced in that case. 3479b832f6dea893f25b40500a04781286236281cb20Sebastian RedlSema::DeduceAutoResult 348032509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCallSema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, 3481a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith TypeSourceInfo *&Result) { 348232509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall if (Init->getType()->isNonOverloadPlaceholderType()) { 348332509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall ExprResult result = CheckPlaceholderExpr(Init); 3484b832f6dea893f25b40500a04781286236281cb20Sebastian Redl if (result.isInvalid()) return DAR_FailedAlreadyDiagnosed; 348532509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall Init = result.take(); 348632509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall } 348732509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall 348834b41d939a1328f484511c6002ba2456db879a29Richard Smith if (Init->isTypeDependent()) { 348934b41d939a1328f484511c6002ba2456db879a29Richard Smith Result = Type; 3490b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Succeeded; 349134b41d939a1328f484511c6002ba2456db879a29Richard Smith } 349234b41d939a1328f484511c6002ba2456db879a29Richard Smith 349334b41d939a1328f484511c6002ba2456db879a29Richard Smith SourceLocation Loc = Init->getExprLoc(); 349434b41d939a1328f484511c6002ba2456db879a29Richard Smith 349534b41d939a1328f484511c6002ba2456db879a29Richard Smith LocalInstantiationScope InstScope(*this); 349634b41d939a1328f484511c6002ba2456db879a29Richard Smith 349734b41d939a1328f484511c6002ba2456db879a29Richard Smith // Build template<class TemplParam> void Func(FuncParam); 34984fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl *TemplParam = 34994fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0, 35004fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth false, false); 35014fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); 35024fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth NamedDecl *TemplParamPtr = TemplParam; 3503483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr, 3504483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith Loc); 3505483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith 3506a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith TypeSourceInfo *FuncParamInfo = 350734b41d939a1328f484511c6002ba2456db879a29Richard Smith SubstituteAutoTransform(*this, TemplArg).TransformType(Type); 3508a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith assert(FuncParamInfo && "substituting template parameter for 'auto' failed"); 3509a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith QualType FuncParam = FuncParamInfo->getType(); 351034b41d939a1328f484511c6002ba2456db879a29Richard Smith 351134b41d939a1328f484511c6002ba2456db879a29Richard Smith // Deduce type of TemplParam in Func(Init) 35125f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 1> Deduced; 351334b41d939a1328f484511c6002ba2456db879a29Richard Smith Deduced.resize(1); 351434b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType InitType = Init->getType(); 351534b41d939a1328f484511c6002ba2456db879a29Richard Smith unsigned TDF = 0; 351634b41d939a1328f484511c6002ba2456db879a29Richard Smith 351734b41d939a1328f484511c6002ba2456db879a29Richard Smith TemplateDeductionInfo Info(Context, Loc); 351862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 351962b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl InitListExpr * InitList = dyn_cast<InitListExpr>(Init); 352062b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (InitList) { 352162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) { 3522d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor if (DeduceTemplateArgumentByListElement(*this, &TemplateParams, 3523d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor TemplArg, 3524d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor InitList->getInit(i), 3525d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor Info, Deduced, TDF)) 3526b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 352762b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 352862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } else { 3529d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams, 3530d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor FuncParam, InitType, Init, 3531d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor TDF)) 3532d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor return DAR_Failed; 3533d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor 353462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam, 353562b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl InitType, Info, Deduced, TDF)) 3536b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 353762b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 353834b41d939a1328f484511c6002ba2456db879a29Richard Smith 353934b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType DeducedType = Deduced[0].getAsType(); 354034b41d939a1328f484511c6002ba2456db879a29Richard Smith if (DeducedType.isNull()) 3541b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 354262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 354362b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (InitList) { 354462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl DeducedType = BuildStdInitializerList(DeducedType, Loc); 354562b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (DeducedType.isNull()) 3546b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_FailedAlreadyDiagnosed; 354762b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 354862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 354934b41d939a1328f484511c6002ba2456db879a29Richard Smith Result = SubstituteAutoTransform(*this, DeducedType).TransformType(Type); 355062b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 35519a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor // Check that the deduced argument type is compatible with the original 35529a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor // argument type per C++ [temp.deduct.call]p4. 355362b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (!InitList && Result && 35549a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor CheckOriginalCallArgDeduction(*this, 35559a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor Sema::OriginalCallArg(FuncParam,0,InitType), 35569a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor Result->getType())) { 35579a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor Result = 0; 3558b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 35599a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor } 35609a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor 3561b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Succeeded; 356234b41d939a1328f484511c6002ba2456db879a29Richard Smith} 356334b41d939a1328f484511c6002ba2456db879a29Richard Smith 356462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redlvoid Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) { 356562b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (isa<InitListExpr>(Init)) 356662b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl Diag(VDecl->getLocation(), 356762b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl diag::err_auto_var_deduction_failure_from_init_list) 356862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange(); 356962b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl else 357062b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl Diag(VDecl->getLocation(), diag::err_auto_var_deduction_failure) 357162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << VDecl->getDeclName() << VDecl->getType() << Init->getType() 357262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << Init->getSourceRange(); 357362b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl} 357462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 35758a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic void 35766fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, QualType T, 3577e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3578ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Level, 3579013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Deduced); 3580dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3581dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \brief If this is a non-static member function, 358277bc572138543ef97ebec137522b763d6a6ee909Douglas Gregorstatic void MaybeAddImplicitObjectParameterType(ASTContext &Context, 358377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor CXXMethodDecl *Method, 35845f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<QualType> &ArgTypes) { 358577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor if (Method->isStatic()) 358677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor return; 358777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 358877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // C++ [over.match.funcs]p4: 358977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // 359077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // For non-static member functions, the type of the implicit 359177bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // object parameter is 35920099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // - "lvalue reference to cv X" for functions declared without a 359377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // ref-qualifier or with the & ref-qualifier 359477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // - "rvalue reference to cv X" for functions declared with the 359577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // && ref-qualifier 359677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // 359777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // FIXME: We don't have ref-qualifiers yet, so we don't do that part. 359877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor QualType ArgTy = Context.getTypeDeclType(Method->getParent()); 359977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTy = Context.getQualifiedType(ArgTy, 360077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Qualifiers::fromCVRMask(Method->getTypeQualifiers())); 360177bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTy = Context.getLValueReferenceType(ArgTy); 360277bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTypes.push_back(ArgTy); 360377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor} 360477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 36058a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \brief Determine whether the function template \p FT1 is at least as 36068a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// specialized as \p FT2. 36078a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic bool isAtLeastAsSpecializedAs(Sema &S, 36085769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 36098a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT1, 36108a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT2, 36118a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplatePartialOrderingContext TPOC, 3612dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi unsigned NumCallArguments, 36135f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) { 36148a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionDecl *FD1 = FT1->getTemplatedDecl(); 3615dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionDecl *FD2 = FT2->getTemplatedDecl(); 36168a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>(); 36178a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>(); 3618dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 36198a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(Proto1 && Proto2 && "Function templates must have prototypes"); 36208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); 36215f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 36228a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced.resize(TemplateParams->size()); 36238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 36248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p3: 36258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // The types used to determine the ordering depend on the context in which 36268a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // the partial ordering is done: 36272a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(S.Context, Loc); 36288d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method1 = 0; 36298d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method2 = 0; 36308d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic2 = false; 36318d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic1 = false; 36328d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor unsigned Skip2 = 0; 36338a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 36348a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 36358a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a function call, the function parameter types are 36368a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used. 36378d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method1 = dyn_cast<CXXMethodDecl>(FD1); 36388d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method2 = dyn_cast<CXXMethodDecl>(FD2); 36398d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic1 = Method1 && !Method1->isStatic(); 36408d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic2 = Method2 && !Method2->isStatic(); 36418d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor 36428d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // C++0x [temp.func.order]p3: 36438d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // [...] If only one of the function templates is a non-static 36448d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // member, that function template is considered to have a new 36458d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // first parameter inserted in its function parameter list. The 36468d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // new parameter is of type "reference to cv A," where cv are 36478d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the cv-qualifiers of the function template (if any) and A is 36488d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the class of which the function template is a member. 36498d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // 36508d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // C++98/03 doesn't have this provision, so instead we drop the 36518d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // first argument of the free function or static member, which 36528d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // seems to match existing practice. 36535f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> Args1; 36544e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie unsigned Skip1 = !S.getLangOpts().CPlusPlus0x && 36558d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic2 && !IsNonStatic1; 36564e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (S.getLangOpts().CPlusPlus0x && IsNonStatic1 && !IsNonStatic2) 3657dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi MaybeAddImplicitObjectParameterType(S.Context, Method1, Args1); 3658dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Args1.insert(Args1.end(), 36598d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end()); 366077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 36615f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> Args2; 36624e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie Skip2 = !S.getLangOpts().CPlusPlus0x && 36638d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic1 && !IsNonStatic2; 36644e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (S.getLangOpts().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1) 366577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor MaybeAddImplicitObjectParameterType(S.Context, Method2, Args2); 3666dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Args2.insert(Args2.end(), 36678d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end()); 3668dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 36695c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++ [temp.func.order]p5: 36705c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // The presence of unused ellipsis and default arguments has no effect on 36715c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // the partial ordering of function templates. 36725c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Args1.size() > NumCallArguments) 36735c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args1.resize(NumCallArguments); 36745c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Args2.size() > NumCallArguments) 36755c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args2.resize(NumCallArguments); 36765c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(), 36775c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args1.data(), Args1.size(), Info, Deduced, 36785c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TDF_None, /*PartialOrdering=*/true, 3679b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons)) 36808a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 3681dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 36828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 36838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3684dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 36858a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 36868a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a call to a conversion operator, the return types 36878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // of the conversion function templates are used. 3688bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 3689bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Proto2->getResultType(), 3690bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Proto1->getResultType(), 3691bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF_None, 3692bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl /*PartialOrdering=*/true, 3693bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 36948a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 36958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 3696dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 36978a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 36980099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // - In other contexts (14.6.6.2) the function template's function type 36998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // is used. 3700bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 3701bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FD2->getType(), FD1->getType(), 3702bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF_None, 3703bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl /*PartialOrdering=*/true, 3704bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 37058a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 37068a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 37078a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3708dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37098a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p11: 3710dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // In most cases, all template parameters must have values in order for 3711dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // deduction to succeed, but for partial ordering purposes a template 3712dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // parameter may remain without a value provided it is not used in the 37138a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // types being used for partial ordering. [ Note: a template parameter used 37148a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // in a non-deduced context is considered used. -end note] 37158a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor unsigned ArgIdx = 0, NumArgs = Deduced.size(); 37168a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 37178a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull()) 37188a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 37198a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 37208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (ArgIdx == NumArgs) { 3721dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // All template arguments were deduced. FT1 is at least as specialized 37228a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // as FT2. 37238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 37248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 37258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 3726e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // Figure out which template parameters were used. 3727013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector UsedParameters(TemplateParams->size()); 37288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 37298a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 3730dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi unsigned NumParams = std::min(NumCallArguments, 3731dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi std::min(Proto1->getNumArgs(), 37325c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Proto2->getNumArgs())); 37334e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (S.getLangOpts().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1) 37346fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Method2->getThisType(S.Context), 37356fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis false, 37368d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor TemplateParams->getDepth(), UsedParameters); 37378d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor for (unsigned I = Skip2; I < NumParams; ++I) 37386fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Proto2->getArgType(I), false, 3739ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3740e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 37418a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 37428a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3743dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37448a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 37456fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Proto2->getResultType(), false, 3746ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3747e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 37488a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 3749dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37508a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 37516fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false, 3752ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3753ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor UsedParameters); 37548a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 37558a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3756dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37578a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 37588a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If this argument had no value deduced but was used in one of the types 37598a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used for partial ordering, then deduction fails. 37608a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) 37618a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 3762dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37638a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 37648a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor} 3765dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37669da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor/// \brief Determine whether this a function template whose parameter-type-list 37679da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor/// ends with a function parameter pack. 37689da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregorstatic bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { 37699da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor FunctionDecl *Function = FunTmpl->getTemplatedDecl(); 37709da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor unsigned NumParams = Function->getNumParams(); 37719da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (NumParams == 0) 37729da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 3773dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37749da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor ParmVarDecl *Last = Function->getParamDecl(NumParams - 1); 37759da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (!Last->isParameterPack()) 37769da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 3777dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37789da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // Make sure that no previous parameter is a parameter pack. 37799da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor while (--NumParams > 0) { 37809da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (Function->getParamDecl(NumParams - 1)->isParameterPack()) 37819da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 37829da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor } 3783dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37849da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return true; 37859da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor} 3786dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3787bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized function template according 378865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// to the rules of function template partial ordering (C++ [temp.func.order]). 378965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 379065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT1 the first function template 379165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 379265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT2 the second function template 379365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 37948a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param TPOC the context in which we are performing partial ordering of 37958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// function templates. 37961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 37975c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param NumCallArguments The number of arguments in a call, used only 37985c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when \c TPOC is \c TPOC_Call. 37995c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 3800bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized function template. If neither 380165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// template is more specialized, returns NULL. 380265ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorFunctionTemplateDecl * 380365ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, 380465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionTemplateDecl *FT2, 38055769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 38065c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TemplatePartialOrderingContext TPOC, 38075c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumCallArguments) { 38085f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons; 3809dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, 38105c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NumCallArguments, 0); 3811dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, 38125c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NumCallArguments, 3813b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor &RefParamComparisons); 3814dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38158a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better1 != Better2) // We have a clear winner 38168a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return Better1? FT1 : FT2; 3817dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38188a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (!Better1 && !Better2) // Neither is better than the other 381965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return 0; 38208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 38218a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p10: 3822dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If for each type being considered a given template is at least as 38238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized for all types and more specialized for some set of types and 3824dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the other template is not more specialized for any types or is not at 38258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // least as specialized for any types, then the given template is more 38268a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other template. Otherwise, neither template is more 38278a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other. 38288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better1 = false; 38298a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better2 = false; 3830b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) { 38318a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p9: 38328a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If, for a given type, deduction succeeds in both directions (i.e., the 3833b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // types are identical after the transformations above) and both P and A 3834b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // were reference types (before being replaced with the type referred to 3835b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // above): 3836b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 3837dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // -- if the type from the argument template was an lvalue reference 3838b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // and the type from the parameter template was not, the argument 3839b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // type is considered to be more specialized than the other; 3840b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // otherwise, 3841b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (!RefParamComparisons[I].ArgIsRvalueRef && 3842b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons[I].ParamIsRvalueRef) { 3843b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better2 = true; 3844b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better1) 3845b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 3846b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 3847b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor } else if (!RefParamComparisons[I].ParamIsRvalueRef && 3848b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons[I].ArgIsRvalueRef) { 3849b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better1 = true; 3850b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better2) 3851b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 3852b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 3853b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor } 3854dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3855b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // -- if the type from the argument template is more cv-qualified than 3856b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // the type from the parameter template (as described above), the 3857b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // argument type is considered to be more specialized than the 3858b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // other; otherwise, 3859b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor switch (RefParamComparisons[I].Qualifiers) { 3860b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case NeitherMoreQualified: 3861b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor break; 3862dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3863b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case ParamMoreQualified: 3864b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better1 = true; 3865b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better2) 3866b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 3867b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 3868dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3869b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case ArgMoreQualified: 3870b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better2 = true; 3871b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better1) 3872b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 3873b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 38748a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3875dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3876b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // -- neither type is more specialized than the other. 38778a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3878dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38798a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(!(Better1 && Better2) && "Should have broken out in the loop above"); 388065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (Better1) 388165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return FT1; 38828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor else if (Better2) 38838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return FT2; 3884dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38859da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // FIXME: This mimics what GCC implements, but doesn't match up with the 38869da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // proposed resolution for core issue 692. This area needs to be sorted out, 38879da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // but for now we attempt to maintain compatibility. 38889da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor bool Variadic1 = isVariadicFunctionTemplate(FT1); 38899da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor bool Variadic2 = isVariadicFunctionTemplate(FT2); 38909da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (Variadic1 != Variadic2) 38919da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return Variadic1? FT2 : FT1; 3892dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38939da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return 0; 389465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 389583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 3896d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Determine if the two templates are equivalent. 3897d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregorstatic bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { 3898d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (T1 == T2) 3899d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return true; 3900dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3901d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!T1 || !T2) 3902d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return false; 3903dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3904d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return T1->getCanonicalDecl() == T2->getCanonicalDecl(); 3905d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 3906d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3907d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Retrieve the most specialized of the given function template 3908d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specializations. 3909d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3910c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecBegin the start iterator of the function template 3911c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations that we will be comparing. 3912d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3913c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecEnd the end iterator of the function template 3914c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations, paired with \p SpecBegin. 3915d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3916d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param TPOC the partial ordering context to use to compare the function 3917d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template specializations. 3918d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 39195c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param NumCallArguments The number of arguments in a call, used only 39205c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when \c TPOC is \c TPOC_Call. 39215c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 3922dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \param Loc the location where the ambiguity or no-specializations 3923d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// diagnostic should occur. 3924d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3925d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param NoneDiag partial diagnostic used to diagnose cases where there are 3926d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// no matching candidates. 3927d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3928d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one 3929d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// occurs. 3930d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3931d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param CandidateDiag partial diagnostic used for each function template 3932d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specialization that is a candidate in the ambiguous ordering. One parameter 3933d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// in this diagnostic should be unbound, which will correspond to the string 3934d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// describing the template arguments for the function template specialization. 3935d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3936dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \param Index if non-NULL and the result of this function is non-nULL, 3937d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// receives the index corresponding to the resulting function template 3938d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specialization. 3939d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3940dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \returns the most specialized function template specialization, if 3941c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// found. Otherwise, returns SpecEnd. 3942d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3943dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \todo FIXME: Consider passing in the "also-ran" candidates that failed 3944d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template argument deduction. 3945c373d48502ca7683ab55385f5bd624d778eb288dJohn McCallUnresolvedSetIterator 3946c373d48502ca7683ab55385f5bd624d778eb288dJohn McCallSema::getMostSpecialized(UnresolvedSetIterator SpecBegin, 39475c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor UnresolvedSetIterator SpecEnd, 3948c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall TemplatePartialOrderingContext TPOC, 39495c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumCallArguments, 3950c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall SourceLocation Loc, 3951c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &NoneDiag, 3952c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &AmbigDiag, 39531be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor const PartialDiagnostic &CandidateDiag, 39546efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu bool Complain, 39556efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu QualType TargetType) { 3956c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (SpecBegin == SpecEnd) { 39571be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor if (Complain) 39581be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor Diag(Loc, NoneDiag); 3959c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 3960d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3961dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3962dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (SpecBegin + 1 == SpecEnd) 3963c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecBegin; 3964dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3965d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Find the function template that is better than all of the templates it 3966d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // has been compared to. 3967c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall UnresolvedSetIterator Best = SpecBegin; 3968dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionTemplateDecl *BestTemplate 3969c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*Best)->getPrimaryTemplate(); 3970d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(BestTemplate && "Not a function template specialization?"); 3971c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) { 3972c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 3973c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 3974d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(Challenger && "Not a function template specialization?"); 3975c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 39765c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Loc, TPOC, NumCallArguments), 3977d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Challenger)) { 3978d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Best = I; 3979d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate = Challenger; 3980d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3981d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3982dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3983d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Make sure that the "best" function template is more specialized than all 3984d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // of the others. 3985d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor bool Ambiguous = false; 3986c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { 3987c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 3988c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 3989d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (I != Best && 3990dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 39915c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Loc, TPOC, NumCallArguments), 3992d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate)) { 3993d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Ambiguous = true; 3994d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor break; 3995d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3996d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3997dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3998d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!Ambiguous) { 3999d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // We found an answer. Return it. 4000c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return Best; 4001d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4002dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4003d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Diagnose the ambiguity. 40041be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor if (Complain) 40051be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor Diag(Loc, AmbigDiag); 4006dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 40071be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor if (Complain) 4008d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // FIXME: Can we order the candidates in some sane way? 40096efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { 40106efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu PartialDiagnostic PD = CandidateDiag; 40116efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu PD << getTemplateArgumentBindingsText( 40121be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(), 4013c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs()); 40146efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu if (!TargetType.isNull()) 40156efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu HandleFunctionTypeMismatch(PD, cast<FunctionDecl>(*I)->getType(), 40166efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu TargetType); 40176efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu Diag((*I)->getLocation(), PD); 40186efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu } 4019dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4020c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 4021d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 4022d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 4023bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized class template partial specialization 4024bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// according to the rules of partial ordering of class template partial 4025bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// specializations (C++ [temp.class.order]). 4026bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4027bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS1 the first class template partial specialization 4028bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4029bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS2 the second class template partial specialization 4030bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4031bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized class template partial specialization. If 4032bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// neither partial specialization is more specialized, returns NULL. 4033bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorClassTemplatePartialSpecializationDecl * 4034bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorSema::getMoreSpecializedPartialSpecialization( 4035bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor ClassTemplatePartialSpecializationDecl *PS1, 40365769d6195087229770d7ac90449443e026c47103John McCall ClassTemplatePartialSpecializationDecl *PS2, 40375769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc) { 4038bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // C++ [temp.class.order]p1: 4039bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // For two class template partial specializations, the first is at least as 4040dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // specialized as the second if, given the following rewrite to two 4041dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // function templates, the first function template is at least as 4042dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // specialized as the second according to the ordering rules for function 4043bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // templates (14.6.6.2): 4044bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the first function template has the same template parameters as the 4045dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // first partial specialization and has a single function parameter 4046dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // whose type is a class template specialization with the template 4047bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the first partial specialization, and 4048bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the second function template has the same template parameters as the 4049dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // second partial specialization and has a single function parameter 4050dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // whose type is a class template specialization with the template 4051bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the second partial specialization. 4052bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // 405331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // Rather than synthesize function templates, we merely perform the 405431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // equivalent partial ordering by performing deduction directly on 405531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // the template arguments of the class template partial 405631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specializations. This computation is slightly simpler than the 405731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // general problem of function template partial ordering, because 405831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // class template partial specializations are more constrained. We 405931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // know that every template parameter is deducible from the class 406031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // template partial specialization's template arguments, for 406131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // example. 40625f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 40632a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(Context, Loc); 406431f17ecbef57b5679c017c375db330546b7b5145John McCall 406531f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT1 = PS1->getInjectedSpecializationType(); 406631f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT2 = PS2->getInjectedSpecializationType(); 4067dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4068bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS1 is at least as specialized as PS2 4069bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS2->getTemplateParameters()->size()); 4070bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this, 4071bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PS2->getTemplateParameters(), 40725c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PT2, PT1, Info, Deduced, TDF_None, 4073dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi /*PartialOrdering=*/true, 4074b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /*RefParamComparisons=*/0); 40752c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better1) { 40762c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, 40772c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis Deduced.data(), Deduced.size(), Info); 4078dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, 4079dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PS1->getTemplateArgs(), 4080516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 40812c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 4082dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4083bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS2 is at least as specialized as PS1 4084db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Deduced.clear(); 4085bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS1->getTemplateParameters()->size()); 4086bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this, 4087bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PS1->getTemplateParameters(), 40885c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PT1, PT2, Info, Deduced, TDF_None, 40895c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor /*PartialOrdering=*/true, 4090b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /*RefParamComparisons=*/0); 40912c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better2) { 40922c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, 40932c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis Deduced.data(), Deduced.size(), Info); 4094dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, 4095dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PS2->getTemplateArgs(), 4096516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 40972c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 4098dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4099bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor if (Better1 == Better2) 4100bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return 0; 4101dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4102bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return Better1? PS1 : PS2; 4103bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor} 4104bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 41051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 41066fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4107e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 4108e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4109ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4110013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used); 4111031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4112e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4113031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// expression. 41141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 41156fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4116e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const Expr *E, 4117e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4118ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4119013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4120be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor // We can deduce from a pack expansion. 4121be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E)) 4122be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor E = Expansion->getPattern(); 4123dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 412454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Skip through any implicit casts we added while type-checking. 412554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 412654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor E = ICE->getSubExpr(); 4127dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4128dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to 4129e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // find other occurrences of template parameters. 4130f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 4131c781f9cd854f3d5d1c826f4a13382c6abca4cff7Douglas Gregor if (!DRE) 4132031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4133031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 41341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const NonTypeTemplateParmDecl *NTTP 4135031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 4136031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!NTTP) 4137031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4138031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4139ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (NTTP->getDepth() == Depth) 4140ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[NTTP->getIndex()] = true; 4141031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4142031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4143e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4144e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// nested name specifier. 4145e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 41466fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4147e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor NestedNameSpecifier *NNS, 4148e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4149ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4150013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4151e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!NNS) 4152e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4153dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41546fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth, 4155ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 41566fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0), 4157ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4158e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 4159dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4160e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4161e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// template name. 4162e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 41636fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4164e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor TemplateName Name, 4165e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4166ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4167013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4168e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 4169e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateTemplateParmDecl *TTP 4170ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(Template)) { 4171ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 4172ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 4173ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 4174e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4175e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 4176dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4177788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) 41786fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced, 4179788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Depth, Used); 4180e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) 41816fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced, 4182ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4183e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 4184e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 4185e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4186031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// type. 41871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 41886fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, QualType T, 4189e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4190ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4191013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4192e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (T.isNull()) 4193e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4194dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4195031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Non-dependent types have nothing deducible 4196031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!T->isDependentType()) 4197031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4198031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 41996fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis T = Ctx.getCanonicalType(T); 4200031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (T->getTypeClass()) { 4201031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Pointer: 42026fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4203e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<PointerType>(T)->getPointeeType(), 4204e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4205ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4206e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4207031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4208031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4209031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::BlockPointer: 42106fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4211e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<BlockPointerType>(T)->getPointeeType(), 4212e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4213ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4214e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4215031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4216031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4217031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::LValueReference: 4218031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::RValueReference: 42196fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4220e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ReferenceType>(T)->getPointeeType(), 4221e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4222ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4223e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4224031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4225031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4226031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::MemberPointer: { 4227031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr()); 42286fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced, 4229ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 42306fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0), 4231ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4232031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4233031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4234031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4235031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::DependentSizedArray: 42366fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4237e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<DependentSizedArrayType>(T)->getSizeExpr(), 4238ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4239031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Fall through to check the element type 4240031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4241031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ConstantArray: 4242031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::IncompleteArray: 42436fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4244e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ArrayType>(T)->getElementType(), 4245ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4246031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4247031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4248031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Vector: 4249031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ExtVector: 42506fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4251e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<VectorType>(T)->getElementType(), 4252ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4253031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4254031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 42559cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor case Type::DependentSizedExtVector: { 42569cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor const DependentSizedExtVectorType *VecType 4257f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<DependentSizedExtVectorType>(T); 42586fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, 4259ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 42606fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, 4261ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 42629cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor break; 42639cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 42649cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 4265031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionProto: { 4266f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 42676fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Proto->getResultType(), OnlyDeduced, 4268ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4269031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I) 42706fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Proto->getArgType(I), OnlyDeduced, 4271ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4272031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4273031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4274031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4275ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor case Type::TemplateTypeParm: { 4276ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T); 4277ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 4278ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 4279031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4280ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 4281031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 42820bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor case Type::SubstTemplateTypeParmPack: { 42830bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor const SubstTemplateTypeParmPackType *Subst 42840bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor = cast<SubstTemplateTypeParmPackType>(T); 42856fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 42860bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor QualType(Subst->getReplacedParameter(), 0), 42870bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor OnlyDeduced, Depth, Used); 42886fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(), 42890bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor OnlyDeduced, Depth, Used); 42900bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor break; 42910bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor } 42920bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor 429331f17ecbef57b5679c017c375db330546b7b5145John McCall case Type::InjectedClassName: 429431f17ecbef57b5679c017c375db330546b7b5145John McCall T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType(); 429531f17ecbef57b5679c017c375db330546b7b5145John McCall // fall through 429631f17ecbef57b5679c017c375db330546b7b5145John McCall 4297031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::TemplateSpecialization: { 42981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const TemplateSpecializationType *Spec 4299f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<TemplateSpecializationType>(T); 43006fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced, 4301ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4302dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 43037b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4304dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4305dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 43067b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4307dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 43087b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 43097b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 43107b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 4311e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 43126fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, 4313ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 4314e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 4315e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 43161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4317e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor case Type::Complex: 4318e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 43196fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4320e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ComplexType>(T)->getElementType(), 4321ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4322e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 4323031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4324b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 4325b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (!OnlyDeduced) 43266fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4327b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman cast<AtomicType>(T)->getValueType(), 4328b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman OnlyDeduced, Depth, Used); 4329b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 4330b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 43314714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 4332e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 43336fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 43344714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor cast<DependentNameType>(T)->getQualifier(), 4335ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4336031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4337031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 433833500955d731c73717af52088b7fc0e7a85681e7John McCall case Type::DependentTemplateSpecialization: { 433933500955d731c73717af52088b7fc0e7a85681e7John McCall const DependentTemplateSpecializationType *Spec 434033500955d731c73717af52088b7fc0e7a85681e7John McCall = cast<DependentTemplateSpecializationType>(T); 434133500955d731c73717af52088b7fc0e7a85681e7John McCall if (!OnlyDeduced) 43426fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getQualifier(), 434333500955d731c73717af52088b7fc0e7a85681e7John McCall OnlyDeduced, Depth, Used); 4344dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 43457b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4346dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4347dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 43487b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4349dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 43507b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 43517b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 43527b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 435333500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 43546fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, 435533500955d731c73717af52088b7fc0e7a85681e7John McCall Used); 435633500955d731c73717af52088b7fc0e7a85681e7John McCall break; 435733500955d731c73717af52088b7fc0e7a85681e7John McCall } 435833500955d731c73717af52088b7fc0e7a85681e7John McCall 4359ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOf: 4360ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 43616fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4362ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfType>(T)->getUnderlyingType(), 4363ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4364ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4365ad5e73887052193afda72db8efcb812bd083a4a8John McCall 4366ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOfExpr: 4367ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 43686fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4369ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfExprType>(T)->getUnderlyingExpr(), 4370ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4371ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4372ad5e73887052193afda72db8efcb812bd083a4a8John McCall 4373ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::Decltype: 4374ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 43756fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4376ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<DecltypeType>(T)->getUnderlyingExpr(), 4377ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4378ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4379ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 4380ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 4381ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt if (!OnlyDeduced) 43826fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4383ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt cast<UnaryTransformType>(T)->getUnderlyingType(), 4384ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt OnlyDeduced, Depth, Used); 4385ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt break; 4386ad5e73887052193afda72db8efcb812bd083a4a8John McCall 43877536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor case Type::PackExpansion: 43886fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 43897536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor cast<PackExpansionType>(T)->getPattern(), 43907536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor OnlyDeduced, Depth, Used); 43917536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor break; 43927536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 439334b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: 43946fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 439534b41d939a1328f484511c6002ba2456db879a29Richard Smith cast<AutoType>(T)->getDeducedType(), 439634b41d939a1328f484511c6002ba2456db879a29Richard Smith OnlyDeduced, Depth, Used); 439734b41d939a1328f484511c6002ba2456db879a29Richard Smith 4398e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // None of these types have any template parameters in them. 4399031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Builtin: 4400031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::VariableArray: 4401031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionNoProto: 4402031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Record: 4403031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Enum: 4404031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ObjCInterface: 4405c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 4406d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 4407ed97649e9574b9d854fa4d6109c9333ae0993554John McCall case Type::UnresolvedUsing: 4408031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define TYPE(Class, Base) 4409031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 4410031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define DEPENDENT_TYPE(Class, Base) 4411031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 4412031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#include "clang/AST/TypeNodes.def" 4413031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4414031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4415031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4416031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4417e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by this 4418031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument. 44191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 44206fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4421e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 4422e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4423ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4424013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4425031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (TemplateArg.getKind()) { 4426031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Null: 4427031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Integral: 4428d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor case TemplateArgument::Declaration: 4429031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 44301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4431031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Type: 44326fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced, 4433ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4434031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4435031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4436788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 4437a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 44386fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4439dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArg.getAsTemplateOrTemplatePattern(), 4440788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor OnlyDeduced, Depth, Used); 4441031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4442031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4443031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Expression: 44446fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced, 4445ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4446031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4447dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4448d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 4449e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(), 4450e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor PEnd = TemplateArg.pack_end(); 4451e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor P != PEnd; ++P) 44526fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used); 4453d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson break; 4454031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4455031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4456031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4457031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \brief Mark the template parameters can be deduced by the given 4458031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument list. 4459031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 4460031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param TemplateArgs the template argument list from which template 4461031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// parameters will be deduced. 4462031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 4463031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param Deduced a bit vector whose elements will be set to \c true 4464031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// to indicate when the corresponding template parameter will be 4465031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// deduced. 44661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 4467e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorSema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, 4468ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor bool OnlyDeduced, unsigned Depth, 4469013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 44707b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4471dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4472dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 44737b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4474dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 44757b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size())) 44767b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return; 44777b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 4478031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 44796fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced, 4480ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4481031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 448263f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor 448363f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// \brief Marks all of the template parameters that will be deduced by a 448463f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// call to the given function template. 4485dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumivoid 44866fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisSema::MarkDeducedTemplateParameters(ASTContext &Ctx, 44876fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis FunctionTemplateDecl *FunctionTemplate, 4488013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Deduced) { 4489dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateParameterList *TemplateParams 449063f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor = FunctionTemplate->getTemplateParameters(); 449163f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.clear(); 449263f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.resize(TemplateParams->size()); 4493dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 449463f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 449563f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 44966fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(), 4497ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor true, TemplateParams->getDepth(), Deduced); 449863f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor} 4499dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4500dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregorbool hasDeducibleTemplateParameters(Sema &S, 4501dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor FunctionTemplateDecl *FunctionTemplate, 4502dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType T) { 4503dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (!T->isDependentType()) 4504dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor return false; 4505dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4506dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor TemplateParameterList *TemplateParams 4507dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor = FunctionTemplate->getTemplateParameters(); 4508013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector Deduced(TemplateParams->size()); 45096fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), 4510dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor Deduced); 4511dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4512013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer return Deduced.any(); 4513dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor} 4514