SemaTemplateDeduction.cpp revision f5c65ffbd7374b6c8d9f1e361041578640cab320
10b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/ 20b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 30b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// The LLVM Compiler Infrastructure 40b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 50b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// This file is distributed under the University of Illinois Open Source 60b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// License. See LICENSE.TXT for details. 70b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===----------------------------------------------------------------------===/ 80b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 90b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// This file implements C++ template argument deduction. 100b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 110b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===----------------------------------------------------------------------===/ 120b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 13e737f5041a36d0befb39ffeed8d50ba15916d3daDouglas Gregor#include "clang/Sema/Sema.h" 1419510856727e0e14a3696b2a72c35163bff2a71fJohn McCall#include "clang/Sema/DeclSpec.h" 1520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor#include "clang/Sema/SemaDiagnostic.h" // FIXME: temporary! 167cd088e519d7e6caa4c4c12db52e0e4ae35d25c2John McCall#include "clang/Sema/Template.h" 172a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall#include "clang/Sema/TemplateDeduction.h" 180b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ASTContext.h" 197cd088e519d7e6caa4c4c12db52e0e4ae35d25c2John McCall#include "clang/AST/DeclObjC.h" 200b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/DeclTemplate.h" 210b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/StmtVisitor.h" 220b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/Expr.h" 230b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ExprCXX.h" 24e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor#include "llvm/ADT/BitVector.h" 258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor#include <algorithm> 26508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 27508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregornamespace clang { 282a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall using namespace sema; 292a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall 30508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Various flags that control template argument deduction. 31508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// 32508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// These flags can be bitwise-OR'd together. 33508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor enum TemplateDeductionFlags { 34508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief No template argument deduction flags, which indicates the 35508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// strictest results for template argument deduction (as used for, e.g., 36508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// matching class template partial specializations). 37508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_None = 0, 38508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, we are 39508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// matching with a parameter type for which the original parameter was 40508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// a reference. 41508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_ParamWithReferenceType = 0x1, 42508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, we 43508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// are matching in a case where we ignore cv-qualifiers. 44508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_IgnoreQualifiers = 0x02, 45508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, 46508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// we are matching in a case where we can perform template argument 474112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor /// deduction from a template-id of a derived class of the argument type. 481282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor TDF_DerivedClass = 0x04, 491282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// \brief Allow non-dependent types to differ, e.g., when performing 501282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// template argument deduction from a function call where conversions 511282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// may apply. 521282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor TDF_SkipNonDependent = 0x08 53508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor }; 54508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor} 55508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 560b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregorusing namespace clang; 570b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 589d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// \brief Compare two APSInts, extending and switching the sign as 599d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// necessary to compare their values regardless of underlying type. 609d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregorstatic bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { 619d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (Y.getBitWidth() > X.getBitWidth()) 629f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad X = X.extend(Y.getBitWidth()); 639d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor else if (Y.getBitWidth() < X.getBitWidth()) 649f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad Y = Y.extend(X.getBitWidth()); 659d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 669d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If there is a signedness mismatch, correct it. 679d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (X.isSigned() != Y.isSigned()) { 689d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If the signed value is negative, then the values cannot be the same. 699d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) 709d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return false; 719d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 729d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Y.setIsSigned(true); 739d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor X.setIsSigned(true); 749d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor } 759d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 769d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return X == Y; 779d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor} 789d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 79f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 80a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 81f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 82f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 83d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor const TemplateArgument &Arg, 842a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 850972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced); 86d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 8720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 8820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas GregorDeduceTemplateArguments(Sema &S, 8920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateParameterList *TemplateParams, 90603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Param, 91603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Arg, 92603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateDeductionInfo &Info, 93603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 94603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned TDF); 95603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 96603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 97603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 98603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 9920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 10020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 10120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 1020972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 1030972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor bool NumberOfArgumentsMustMatch = true); 10420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 105199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \brief If the given expression is of a form that permits the deduction 106199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// of a non-type template parameter, return the declaration of that 107199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// non-type template parameter. 108199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregorstatic NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { 109199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E)) 110199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor E = IC->getSubExpr(); 1111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 112199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 113199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 1141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 115199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return 0; 116199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 117199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1180d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Determine whether two declaration pointers refer to the same 1190d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// declaration. 1200d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregorstatic bool isSameDeclaration(Decl *X, Decl *Y) { 1210d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (!X || !Y) 1220d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return !X && !Y; 1230d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1240d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NX = dyn_cast<NamedDecl>(X)) 1250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X = NX->getUnderlyingDecl(); 1260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NY = dyn_cast<NamedDecl>(Y)) 1270d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y = NY->getUnderlyingDecl(); 1280d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X->getCanonicalDecl() == Y->getCanonicalDecl(); 1300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 1310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Verify that the given, deduced template arguments are compatible. 1330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// 1340d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \returns The deduced template argument, or a NULL template argument if 1350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// the deduced template arguments were incompatible. 1360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregorstatic DeducedTemplateArgument 1370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas GregorcheckDeducedTemplateArguments(ASTContext &Context, 1380d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &X, 1390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &Y) { 1400d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // We have no deduction for one or both of the arguments; they're compatible. 1410d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (X.isNull()) 1420d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 1430d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.isNull()) 1440d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 1450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1460d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor switch (X.getKind()) { 1470d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Null: 1480d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm_unreachable("Non-deduced template arguments handled above"); 1490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1500d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Type: 1510d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If two template type arguments have the same type, they're compatible. 1520d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Type && 1530d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameType(X.getAsType(), Y.getAsType())) 1540d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 1550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1560d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 1570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Integral: 1590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a constant in one case and either a dependent expression or 1600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration in another case, keep the integral constant. 1610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If both are integral constants with the same value, keep that value. 1620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression || 1630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration || 1640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor (Y.getKind() == TemplateArgument::Integral && 1650d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor hasSameExtendedValue(*X.getAsIntegral(), *Y.getAsIntegral()))) 1660d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(X, 1670d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.wasDeducedFromArrayBound() && 1680d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 1690d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1700d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 1710d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 1720d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1730d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Template: 1740d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Template && 1750d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) 1760d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 1770d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 1790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 180a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 181a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 182a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor if (Y.getKind() == TemplateArgument::TemplateExpansion && 183a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), 184a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern())) 185a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return X; 186a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 187a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor // All other combinations are incompatible. 188a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return DeducedTemplateArgument(); 189a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Expression: 1910d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a dependent expression in one case and either an integral 1920d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // constant or a declaration in another case, keep the integral constant 1930d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // or declaration. 1940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral || 1950d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration) 1960d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() && 1970d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 1980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1990d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) { 2000d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // Compare the expressions for equality 2010d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm::FoldingSetNodeID ID1, ID2; 2020d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.getAsExpr()->Profile(ID1, Context, true); 2030d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getAsExpr()->Profile(ID2, Context, true); 2040d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (ID1 == ID2) 2050d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2060d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 2070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2080d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2090d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2100d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2110d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Declaration: 2120d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and a dependent expression, keep the 2130d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration. 2140d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) 2150d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2160d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2170d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and an integral constant, keep the 2180d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // integral constant. 2190d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral) 2200d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 2210d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2220d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced two declarations, make sure they they refer to the 2230d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // same declaration. 2240d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Declaration && 2250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor isSameDeclaration(X.getAsDecl(), Y.getAsDecl())) 2260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2270d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2280d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Pack: 2320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() != TemplateArgument::Pack || 2330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.pack_size() != Y.pack_size()) 2340d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor for (TemplateArgument::pack_iterator XA = X.pack_begin(), 2370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XAEnd = X.pack_end(), 2380d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor YA = Y.pack_begin(); 2390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XA != XAEnd; ++XA, ++YA) { 240135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor if (checkDeducedTemplateArguments(Context, 241135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), 242135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) 243135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor .isNull()) 2440d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 2460d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2470d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2480d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 2490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2500d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2510d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 2520d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 254199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given constant. 255f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 256a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 2571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP, 2589d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor llvm::APSInt Value, QualType ValueType, 25902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor bool DeducedFromArrayBound, 2602a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 26102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 2621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 263199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 2641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2650d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(Value, ValueType, DeducedFromArrayBound); 2660d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 2670d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 2680d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 2690d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 270f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = NTTP; 271f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 2720d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 2730d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 274f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 2750d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2760d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 277f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 278199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 279199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 2801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 281199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given type- or value-dependent expression. 282199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// 283199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \returns true if deduction succeeded, false otherwise. 284f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 285a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 286f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor NonTypeTemplateParmDecl *NTTP, 287f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Expr *Value, 2882a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 28902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 2901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 291199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 292199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert((Value->isTypeDependent() || Value->isValueDependent()) && 293199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Expression template argument must be type- or value-dependent."); 2941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2950d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(Value); 2960d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 2970d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 2980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 2990d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 3000d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3010d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3020d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3030d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 3040d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 3059eea08ba72f8b1e7faf38e43376b9157fc4a2af2Douglas Gregor } 3060d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 3070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 308f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 309199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 310199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 31115755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \brief Deduce the value of the given non-type template parameter 31215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// from the given declaration. 31315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// 31415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \returns true if deduction succeeded, false otherwise. 31515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregorstatic Sema::TemplateDeductionResult 316a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 31715755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor NonTypeTemplateParmDecl *NTTP, 31815755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor Decl *D, 3192a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 32002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 32115755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor assert(NTTP->getDepth() == 0 && 32215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor "Cannot deduce non-type template argument with depth > 0"); 32315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 3240d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(D? D->getCanonicalDecl() : 0); 3250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 3270d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3280d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 3320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 33315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor } 33415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 3350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 33615755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor return Sema::TDK_Success; 33715755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor} 33815755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 339f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 340a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 341db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParameterList *TemplateParams, 342f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Param, 343f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Arg, 3442a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 34502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 346d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); 347db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (!ParamDecl) { 348db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // The parameter type is dependent and is not a template template parameter, 349db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // so there is nothing that we can deduce. 350db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 351f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 352db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 353db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (TemplateTemplateParmDecl *TempParam 354db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) { 3550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); 3560d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()], 3580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = TempParam; 3610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[TempParam->getIndex()]; 3620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 3630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 364db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor } 365db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 3660d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()] = Result; 3670d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Success; 368f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 369db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 370db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Verify that the two template names are equivalent. 371a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (S.Context.hasSameTemplateName(Param, Arg)) 372db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 373db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 374db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Mismatch of non-dependent template parameter to argument. 375db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.FirstArg = TemplateArgument(Param); 376db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.SecondArg = TemplateArgument(Arg); 377db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_NonDeducedMismatch; 378d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor} 379d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 3801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the template arguments by comparing the template parameter 381de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// type (which is a template-id) with the template argument type. 382de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 383a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the Sema 384de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 385de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param TemplateParams the template parameters that we are deducing 386de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 387de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Param the parameter type 388de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 389de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Arg the argument type 390de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 391de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Info information about the template argument deduction itself 392de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 393de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Deduced the deduced template arguments 394de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 395de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 396de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 397de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// but it may still fail, later, for other reasons. 398de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregorstatic Sema::TemplateDeductionResult 399a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 400de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateParameterList *TemplateParams, 401de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const TemplateSpecializationType *Param, 402de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType Arg, 4032a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 40402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 405467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Arg.isCanonical() && "Argument type must be canonical"); 4061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 407de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Check whether the template argument is a dependent template-id. 4081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *SpecArg 409de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<TemplateSpecializationType>(Arg)) { 410de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 411de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 412a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 413de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 414de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor SpecArg->getTemplateName(), 415de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 416de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 4171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 419de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction on each template 4200972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // argument. Ignore any missing/extra arguments, since they could be 4210972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // filled in by default arguments. 42220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return DeduceTemplateArguments(S, TemplateParams, 4230972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor Param->getArgs(), Param->getNumArgs(), 4240972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor SpecArg->getArgs(), SpecArg->getNumArgs(), 4250972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor Info, Deduced, 4260972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor /*NumberOfArgumentsMustMatch=*/false); 427de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 4281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 429de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If the argument type is a class template specialization, we 430de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // perform template argument deduction using its template 431de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // arguments. 432de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *RecordArg = dyn_cast<RecordType>(Arg); 433de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!RecordArg) 434de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 4351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ClassTemplateSpecializationDecl *SpecArg 437de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl()); 438de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!SpecArg) 439de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 4401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 441de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 442de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 443a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, 444db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParams, 445de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 446de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateName(SpecArg->getSpecializedTemplate()), 447de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 448de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 4491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Perform template argument deduction for the template arguments. 45120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return DeduceTemplateArguments(S, TemplateParams, 45220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Param->getArgs(), Param->getNumArgs(), 45320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().data(), 45420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().size(), 45520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 456de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor} 457de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 458cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// \brief Determines whether the given type is an opaque type that 459cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// might be more qualified when instantiated. 460cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCallstatic bool IsPossiblyOpaquelyQualifiedType(QualType T) { 461cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall switch (T->getTypeClass()) { 462cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOfExpr: 463cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOf: 464cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentName: 465cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::Decltype: 466cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::UnresolvedUsing: 467cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return true; 468cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 469cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::ConstantArray: 470cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::IncompleteArray: 471cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::VariableArray: 472cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentSizedArray: 473cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return IsPossiblyOpaquelyQualifiedType( 474cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall cast<ArrayType>(T)->getElementType()); 475cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 476cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall default: 477cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return false; 478cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } 479cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall} 480cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 481603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Retrieve the depth and index of an unexpanded parameter pack. 482603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic std::pair<unsigned, unsigned> 483603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorgetDepthAndIndex(UnexpandedParameterPack UPP) { 484603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (const TemplateTypeParmType *TTP 485603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = UPP.first.dyn_cast<const TemplateTypeParmType *>()) 486603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 487603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 488603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NamedDecl *ND = UPP.first.get<NamedDecl *>(); 489603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) 490603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 491603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 492603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) 493603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); 494603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 495603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); 496603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 497603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 498603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 499603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Helper function to build a TemplateParameter when we don't 500603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// know its type statically. 501603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic TemplateParameter makeTemplateParameter(Decl *D) { 502603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D)) 503603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(TTP); 504603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) 505603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(NTTP); 506603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 507603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(cast<TemplateTemplateParmDecl>(D)); 508603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 509603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 510603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Deduce the template arguments by comparing the list of parameter 511603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// types to the list of argument types, as in the parameter-type-lists of 512603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// function types (C++ [temp.deduct.type]p10). 513603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 514603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param S The semantic analysis object within which we are deducing 515603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 516603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TemplateParams The template parameters that we are deducing 517603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 518603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Params The list of parameter types 519603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 520603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumParams The number of types in \c Params 521603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 522603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Args The list of argument types 523603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 524603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumArgs The number of types in \c Args 525603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 526603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Info information about the template argument deduction itself 527603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 528603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Deduced the deduced template arguments 529603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 530603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 531603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// how template argument deduction is performed. 532603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 533603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 534603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 535603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// but it may still fail, later, for other reasons. 536603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 537603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 538603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 539603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Params, unsigned NumParams, 540603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Args, unsigned NumArgs, 541603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateDeductionInfo &Info, 542603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 543603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned TDF) { 5440bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor // Fast-path check to see if we have too many/too few arguments. 545f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // FIXME: Variadic templates broken! 5460bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor if (NumParams != NumArgs && 5470bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) && 5480bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1]))) 5490bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor return NumArgs < NumParams ? Sema::TDK_TooFewArguments 5500bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor : Sema::TDK_TooManyArguments; 551603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 552603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 553603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Similarly, if P has a form that contains (T), then each parameter type 554603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Pi of the respective parameter-type- list of P is compared with the 555603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // corresponding parameter type Ai of the corresponding parameter-type-list 556603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // of A. [...] 557603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 558603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ParamIdx != NumParams; ++ParamIdx) { 559603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Check argument types. 560603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const PackExpansionType *Expansion 561603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = dyn_cast<PackExpansionType>(Params[ParamIdx]); 562603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!Expansion) { 563603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Simple case: compare the parameter and argument types at this point. 564603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 565603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we have an argument. 566603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx >= NumArgs) 567603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Sema::TDK_TooFewArguments; 568603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 569603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Sema::TemplateDeductionResult Result 570603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, 571603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Params[ParamIdx], 572603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Args[ArgIdx], 573603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Info, Deduced, TDF)) 574603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 575603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 576603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor ++ArgIdx; 577603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor continue; 578603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 579603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 580603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 581603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // If the parameter-declaration corresponding to Pi is a function 582603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter pack, then the type of its declarator- id is compared with 583603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // each remaining parameter type in the parameter-type-list of A. Each 584603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // comparison deduces template arguments for subsequent positions in the 585603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // template parameter packs expanded by the function parameter pack. 586603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 587603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Compute the set of template parameter indices that correspond to 588603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter packs expanded by the pack expansion. 589603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVector<unsigned, 2> PackIndices; 590603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Pattern = Expansion->getPattern(); 591603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor { 592603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::BitVector SawIndices(TemplateParams->size()); 593603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 594603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 595603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 596603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned Depth, Index; 597603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 598603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 599603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor SawIndices[Index] = true; 600603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor PackIndices.push_back(Index); 601603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 602603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 603603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 604603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 605603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 606603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Save the deduced template arguments for each parameter pack expanded 607603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // by this pack expansion, then clear out the deduction. 608603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 2> 609603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor SavedPacks(PackIndices.size()); 610603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 611603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor SavedPacks[I] = Deduced[PackIndices[I]]; 612603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Deduced[PackIndices[I]] = DeducedTemplateArgument(); 613603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 614603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 615603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Keep track of the deduced template arguments for each parameter pack 616603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // expanded by this pack expansion (the outer index) and for each 617603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // template argument (the inner SmallVectors). 618603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2> 619603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewlyDeducedPacks(PackIndices.size()); 620603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor bool HasAnyArguments = false; 621603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ArgIdx < NumArgs; ++ArgIdx) { 622603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor HasAnyArguments = true; 623603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 624603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Deduce template arguments from the pattern. 625603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Sema::TemplateDeductionResult Result 626603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], 627603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Info, Deduced)) 628603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 629603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 630603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 631603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 632603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // for that pack, then clear out the deduced argument. 633603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 634603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 635603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!DeducedArg.isNull()) { 636603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 637603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedArg = DeducedTemplateArgument(); 638603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 639603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 640603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 641603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 642603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 643603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // pack expansion. 644603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 645603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { 646603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // We were not able to deduce anything for this parameter pack, 647603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // so just restore the saved argument pack. 648603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Deduced[PackIndices[I]] = SavedPacks[I]; 649603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor continue; 650603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 651603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 652603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedTemplateArgument NewPack; 653603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 654603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (NewlyDeducedPacks[I].empty()) { 655603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // If we deduced an empty argument pack, create it now. 656603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewPack = DeducedTemplateArgument(TemplateArgument(0, 0)); 657603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } else { 658603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateArgument *ArgumentPack 659603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; 660603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), 661603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor ArgumentPack); 662603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewPack 663603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = DeducedTemplateArgument(TemplateArgument(ArgumentPack, 664603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewlyDeducedPacks[I].size()), 665603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); 666603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 667603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 668603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedTemplateArgument Result 669603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); 670603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Result.isNull()) { 671603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Info.Param 672603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); 673603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Info.FirstArg = SavedPacks[I]; 674603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Info.SecondArg = NewPack; 675603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Sema::TDK_Inconsistent; 676603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 677603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 678603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Deduced[PackIndices[I]] = Result; 679603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 680603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 681603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 682603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we don't have any extra arguments. 683603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx < NumArgs) 684603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Sema::TDK_TooManyArguments; 685603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 686603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Sema::TDK_Success; 687603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 688603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 689500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \brief Deduce the template arguments by comparing the parameter type and 690500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// the argument type (C++ [temp.deduct.type]). 691500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 692a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the semantic analysis object within which we are deducing 693500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 694500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param TemplateParams the template parameters that we are deducing 695500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 696500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ParamIn the parameter type 697500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 698500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ArgIn the argument type 699500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 700500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Info information about the template argument deduction itself 701500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 702500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Deduced the deduced template arguments 703500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 704508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 7051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// how template argument deduction is performed. 706500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 707500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \returns the result of template argument deduction so far. Note that a 708500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// "success" result means that template argument deduction has not yet failed, 709500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// but it may still fail, later, for other reasons. 710f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 711a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 712f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 713f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType ParamIn, QualType ArgIn, 7142a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 71502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 716508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor unsigned TDF) { 7170b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // We only want to look at the canonical types, since typedefs and 7180b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // sugar are not part of template argument deduction. 719a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Param = S.Context.getCanonicalType(ParamIn); 720a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Arg = S.Context.getCanonicalType(ArgIn); 7210b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 722500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor // C++0x [temp.deduct.call]p4 bullet 1: 723500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor // - If the original P is a reference type, the deduced A (i.e., the type 7241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // referred to by the reference) can be more cv-qualified than the 725500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor // transformed A. 726508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (TDF & TDF_ParamWithReferenceType) { 727e724246b9f655801bd96b727daf9dddc44beef4dChandler Carruth Qualifiers Quals; 728a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); 729e724246b9f655801bd96b727daf9dddc44beef4dChandler Carruth Quals.setCVRQualifiers(Quals.getCVRQualifiers() & 730e724246b9f655801bd96b727daf9dddc44beef4dChandler Carruth Arg.getCVRQualifiersThroughArrayTypes()); 731a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Param = S.Context.getQualifiedType(UnqualParam, Quals); 732500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor } 7331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 734f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // If the parameter type is not dependent, there is nothing to deduce. 7351282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor if (!Param->isDependentType()) { 7361282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor if (!(TDF & TDF_SkipNonDependent) && Param != Arg) { 7371282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor 7381282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor return Sema::TDK_NonDeducedMismatch; 7391282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor } 7401282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor 741f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Sema::TDK_Success; 7421282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor } 7430b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 744199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // C++ [temp.deduct.type]p9: 7451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // A template type argument T, a template template argument TT or a 7461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // template non-type argument i can be deduced if P and A have one of 747199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // the following forms: 748199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // 749199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T 750199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // cv-list T 7511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateTypeParmType *TemplateTypeParm 752183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Param->getAs<TemplateTypeParmType>()) { 753f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor unsigned Index = TemplateTypeParm->getIndex(); 754f290e0db835a619014538c41ed552696efc0e977Douglas Gregor bool RecanonicalizeArg = false; 7551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7569e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // If the argument type is an array type, move the qualifiers up to the 7579e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // top level, so they can be matched with the qualifiers on the parameter. 7589e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // FIXME: address spaces, ObjC GC qualifiers 759f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (isa<ArrayType>(Arg)) { 7600953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals; 761a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); 7620953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Quals) { 763a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getQualifiedType(Arg, Quals); 764f290e0db835a619014538c41ed552696efc0e977Douglas Gregor RecanonicalizeArg = true; 765f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 766f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 7671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7680b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // The argument type can not be less qualified than the parameter 7690b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // type. 770508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.isMoreQualifiedThan(Arg) && !(TDF & TDF_IgnoreQualifiers)) { 771f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 77257e97786433e70197a089360228d8f0d82e3ad4cJohn McCall Info.FirstArg = TemplateArgument(Param); 773833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(Arg); 77457e97786433e70197a089360228d8f0d82e3ad4cJohn McCall return Sema::TDK_Underqualified; 775f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 7760b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 7770b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); 778a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function"); 7790953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualType DeducedType = Arg; 78049f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall 78149f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall // local manipulation is okay because it's canonical 78249f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall DeducedType.removeLocalCVRQualifiers(Param.getCVRQualifiers()); 783f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (RecanonicalizeArg) 784a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth DeducedType = S.Context.getCanonicalType(DeducedType); 7851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7860d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(DeducedType); 7870d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 7880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index], 7890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 7900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 7910d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 7920d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[Index]; 7930d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 7940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 7950b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 7960d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 7970d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index] = Result; 7980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Success; 7990b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 8000b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 801f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // Set up the template argument deduction information for a failure. 802833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.FirstArg = TemplateArgument(ParamIn); 803833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(ArgIn); 804f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 805508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // Check the cv-qualifiers on the parameter and argument types. 806508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (!(TDF & TDF_IgnoreQualifiers)) { 807508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (TDF & TDF_ParamWithReferenceType) { 808508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.isMoreQualifiedThan(Arg)) 809508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor return Sema::TDK_NonDeducedMismatch; 810cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { 811508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) 8121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Sema::TDK_NonDeducedMismatch; 813508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 814508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 8150b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 816d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor switch (Param->getTypeClass()) { 817199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // No deduction possible for these types 818199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::Builtin: 819f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 8201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 821199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T * 822d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::Pointer: { 823c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall QualType PointeeType; 824c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall if (const PointerType *PointerArg = Arg->getAs<PointerType>()) { 825c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 826c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else if (const ObjCObjectPointerType *PointerArg 827c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall = Arg->getAs<ObjCObjectPointerType>()) { 828c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 829c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else { 830f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 831c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } 8321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8334112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); 834a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 835d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<PointerType>(Param)->getPointeeType(), 836c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType, 8374112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor Info, Deduced, SubTDF); 838d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 8391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 840199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T & 841d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::LValueReference: { 8426217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>(); 843d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 844f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 8451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 846a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 847d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<LValueReferenceType>(Param)->getPointeeType(), 848d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor ReferenceArg->getPointeeType(), 849508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 850d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 8510b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 852199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T && [C++0x] 853d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::RValueReference: { 8546217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>(); 855d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 856f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 8571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 858a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 859d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<RValueReferenceType>(Param)->getPointeeType(), 860d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor ReferenceArg->getPointeeType(), 861508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 862d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 8631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 864199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [] (implied, but not stated explicitly) 8654d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::IncompleteArray: { 8661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const IncompleteArrayType *IncompleteArrayArg = 867a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsIncompleteArrayType(Arg); 8684d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!IncompleteArrayArg) 869f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 8701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 871e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 872a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 873a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsIncompleteArrayType(Param)->getElementType(), 8744d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson IncompleteArrayArg->getElementType(), 875e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall Info, Deduced, SubTDF); 8764d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 877199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 878199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [integer-constant] 8794d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::ConstantArray: { 8801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayArg = 881a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Arg); 8824d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!ConstantArrayArg) 883f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 8841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayParm = 886a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Param); 8874d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) 888f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 8891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 890e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 891a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 8924d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson ConstantArrayParm->getElementType(), 8934d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson ConstantArrayArg->getElementType(), 894e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall Info, Deduced, SubTDF); 8954d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 8964d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 897199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // type [i] 898199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::DependentSizedArray: { 899a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); 900199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!ArrayArg) 901f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 9021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 903e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 904e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall 905199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Check the element type of the arrays 906199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor const DependentSizedArrayType *DependentArrayParm 907a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = S.Context.getAsDependentSizedArrayType(Param); 908f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 909a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 910f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor DependentArrayParm->getElementType(), 911f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor ArrayArg->getElementType(), 912e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall Info, Deduced, SubTDF)) 913f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 9141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 915199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Determine the array bound is something we can deduce. 9161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP 917199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); 918199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!NTTP) 919f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 9201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We can perform template argument deduction for the given non-type 922199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // template parameter. 9231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 924199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument at depth > 0"); 9251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ConstantArrayType *ConstantArrayArg 926335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson = dyn_cast<ConstantArrayType>(ArrayArg)) { 927335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson llvm::APSInt Size(ConstantArrayArg->getSize()); 9289d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, Size, 9299d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor S.Context.getSizeType(), 93002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/true, 931f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 932335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson } 933199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (const DependentSizedArrayType *DependentArrayArg 934199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = dyn_cast<DependentSizedArrayType>(ArrayArg)) 93534c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor if (DependentArrayArg->getSizeExpr()) 93634c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, 93734c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor DependentArrayArg->getSizeExpr(), 93834c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor Info, Deduced); 9391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 940199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Incomplete type does not match a dependently-sized array type 941f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 942199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 9431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(*)(T) 9451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)() 9461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)(T) 947a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson case Type::FunctionProto: { 9481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoArg = 949a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson dyn_cast<FunctionProtoType>(Arg); 950a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson if (!FunctionProtoArg) 951f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 9521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoParam = 954a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson cast<FunctionProtoType>(Param); 955994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 9561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionProtoParam->getTypeQuals() != 957994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson FunctionProtoArg->getTypeQuals()) 958f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 9591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 960994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson if (FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) 961f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 962994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 963a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson // Check return types. 964f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 965a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 966f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor FunctionProtoParam->getResultType(), 967f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor FunctionProtoArg->getResultType(), 968508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0)) 969f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 9701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 971603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return DeduceTemplateArguments(S, TemplateParams, 972603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->arg_type_begin(), 973603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->getNumArgs(), 974603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->arg_type_begin(), 975603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->getNumArgs(), 976603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Info, Deduced, 0); 977a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson } 9781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9793cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case Type::InjectedClassName: { 9803cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // Treat a template's injected-class-name as if the template 9813cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // specialization type had been used. 98231f17ecbef57b5679c017c375db330546b7b5145John McCall Param = cast<InjectedClassNameType>(Param) 98331f17ecbef57b5679c017c375db330546b7b5145John McCall ->getInjectedSpecializationType(); 9843cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<TemplateSpecializationType>(Param) && 9853cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall "injected class name is not a template specialization type"); 9863cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // fall through 9873cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 9883cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 989f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // template-name<T> (where template-name refers to a class template) 990d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // template-name<i> 991db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<T> 992db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<i> 993db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<> 994d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor case Type::TemplateSpecialization: { 995d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor const TemplateSpecializationType *SpecParam 996d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor = cast<TemplateSpecializationType>(Param); 9971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 998de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Try to deduce template arguments from the template-id. 999de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult Result 1000a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, 1001de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced); 10021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10034a5c15f75f76b95e1c2ceb6fa2737dcadd5f4be1Douglas Gregor if (Result && (TDF & TDF_DerivedClass)) { 1004de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // C++ [temp.deduct.call]p3b3: 1005de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If P is a class, and P has the form template-id, then A can be a 1006de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // derived class of the deduced A. Likewise, if P is a pointer to a 10071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // class of the form template-id, A can be a pointer to a derived 1008de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // class pointed to by the deduced A. 1009de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // 1010de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // More importantly: 10111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // These alternatives are considered only if type deduction would 1012de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // otherwise fail. 1013a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (const RecordType *RecordT = Arg->getAs<RecordType>()) { 1014a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // We cannot inspect base classes as part of deduction when the type 1015a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // is incomplete, so either instantiate any templates necessary to 1016a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // complete the type, or skip over it if it cannot be completed. 10175769d6195087229770d7ac90449443e026c47103John McCall if (S.RequireCompleteType(Info.getLocation(), Arg, 0)) 1018a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return Result; 1019a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth 1020de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Use data recursion to crawl through the list of base classes. 10211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Visited contains the set of nodes we have already visited, while 1022de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // ToVisit is our stack of records that we still need to visit. 1023de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallPtrSet<const RecordType *, 8> Visited; 1024de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallVector<const RecordType *, 8> ToVisit; 1025de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.push_back(RecordT); 1026de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor bool Successful = false; 1027053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> DeducedOrig(0); 1028053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor DeducedOrig = Deduced; 1029de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor while (!ToVisit.empty()) { 1030de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Retrieve the next class in the inheritance hierarchy. 1031de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *NextT = ToVisit.back(); 1032de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.pop_back(); 10331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1034de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If we have already seen this type, skip it. 1035de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!Visited.insert(NextT)) 1036de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor continue; 10371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1038de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If this is a base class, try to perform template argument 1039de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // deduction from it. 1040de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (NextT != RecordT) { 1041de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult BaseResult 1042a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, 1043de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType(NextT, 0), Info, Deduced); 10441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1045de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If template argument deduction for this base was successful, 1046053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // note that we had some success. Otherwise, ignore any deductions 1047053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // from this base class. 1048053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor if (BaseResult == Sema::TDK_Success) { 1049de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Successful = true; 1050053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor DeducedOrig = Deduced; 1051053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor } 1052053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor else 1053053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor Deduced = DeducedOrig; 1054de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 10551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1056de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Visit base classes 1057de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl()); 1058de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), 1059de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor BaseEnd = Next->bases_end(); 10609994a34f6cf842721ba7723edc0b9036229fe387Sebastian Redl Base != BaseEnd; ++Base) { 10611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(Base->getType()->isRecordType() && 1062de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor "Base class that isn't a record?"); 10636217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek ToVisit.push_back(Base->getType()->getAs<RecordType>()); 1064de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 1065de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 10661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1067de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Successful) 1068de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_Success; 1069de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 10701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1071de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 10721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1073de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 1074d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor } 1075d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 1076637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T type::* 1077637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T T::* 1078637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)() 1079637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)() 1080637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (type::*)(T) 1081637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)(T) 1082637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)(T) 1083637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)() 1084637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)(T) 1085637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::MemberPointer: { 1086637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param); 1087637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg); 1088637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor if (!MemPtrArg) 1089f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1090f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1091f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1092a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 1093f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor MemPtrParam->getPointeeType(), 1094f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor MemPtrArg->getPointeeType(), 1095508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 1096508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF & TDF_IgnoreQualifiers)) 1097f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 1098f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1099a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1100f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType(MemPtrParam->getClass(), 0), 1101f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType(MemPtrArg->getClass(), 0), 1102508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 1103637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor } 1104637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 11059a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // (clang extension) 11069a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // 11071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(^)(T) 11081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)() 11091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)(T) 1110859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson case Type::BlockPointer: { 1111859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param); 1112859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg); 11131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1114859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson if (!BlockPtrArg) 1115f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1117a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1118859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson BlockPtrParam->getPointeeType(), 1119f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor BlockPtrArg->getPointeeType(), Info, 1120508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Deduced, 0); 1121859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson } 1122859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson 1123637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOfExpr: 1124637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOf: 11254714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 1126637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // No template argument deduction for these types 1127f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1128637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 1129d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor default: 1130d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor break; 11310b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 11320b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 11330b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // FIXME: Many more cases to go (to go). 1134f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Sema::TDK_Success; 11350b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 11360b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1137f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 1138a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1139f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 1140f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 11410b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor const TemplateArgument &Arg, 11422a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 114302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 11440b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor switch (Param.getKind()) { 1145199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Null: 1146199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(false && "Null template argument in parameter list"); 1147199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor break; 11481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TemplateArgument::Type: 1150788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Type) 1151a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, Param.getAsType(), 1152788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Arg.getAsType(), Info, Deduced, 0); 1153788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1154788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1155788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1156a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1157788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1158db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (Arg.getKind() == TemplateArgument::Template) 1159a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1160788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Param.getAsTemplate(), 1161db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Arg.getAsTemplate(), Info, Deduced); 1162788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1163788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1164788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1165a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1166a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1167a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor llvm_unreachable("caller should handle pack expansions"); 1168a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor break; 1169788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor 1170199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Declaration: 1171788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration && 1172788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Param.getAsDecl()->getCanonicalDecl() == 1173788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Arg.getAsDecl()->getCanonicalDecl()) 1174788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_Success; 1175788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor 1176f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1177f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1178f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1180199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Integral: 1181199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) { 11829d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (hasSameExtendedValue(*Param.getAsIntegral(), *Arg.getAsIntegral())) 1183f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1184f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1185f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1186f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1187f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1188f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 1189f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1190f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) { 1191f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1192f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1193f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1194199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1195199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1196f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1197f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1198f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1200199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Expression: { 12011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (NonTypeTemplateParmDecl *NTTP 1202199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(Param.getAsExpr())) { 1203199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) 1204a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, 12051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump *Arg.getAsIntegral(), 12069d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Arg.getIntegralType(), 120702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/false, 1208f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1209199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) 1210a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(), 1211f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 121215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration) 1213a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(), 121415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor Info, Deduced); 121515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 1216f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1217f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1218f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1219199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 12201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1221199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Can't deduce anything, but that's okay. 1222f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1223199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1224d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 122520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor llvm_unreachable("Argument packs should be expanded by the caller!"); 12260b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 12271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1228f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 12290b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 12300b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 123120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \brief Determine whether there is a template argument to be used for 123220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// deduction. 123320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 123420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// This routine "expands" argument packs in-place, overriding its input 123520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// parameters so that \c Args[ArgIdx] will be the available template argument. 123620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 123720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \returns true if there is another template argument (which will be at 123820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \c Args[ArgIdx]), false otherwise. 123920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args, 124020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &ArgIdx, 124120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &NumArgs) { 124220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (ArgIdx == NumArgs) 124320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return false; 124420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 124520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 124620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Arg.getKind() != TemplateArgument::Pack) 124720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return true; 124820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 124920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?"); 125020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Args = Arg.pack_begin(); 125120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor NumArgs = Arg.pack_size(); 125220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgIdx = 0; 125320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return ArgIdx < NumArgs; 125420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 125520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 12567b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// \brief Determine whether the given set of template arguments has a pack 12577b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// expansion that is not the last template argument. 12587b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregorstatic bool hasPackExpansionBeforeEnd(const TemplateArgument *Args, 12597b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned NumArgs) { 12607b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned ArgIdx = 0; 12617b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor while (ArgIdx < NumArgs) { 12627b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 12637b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 12647b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // Unwrap argument packs. 12657b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Args[ArgIdx].getKind() == TemplateArgument::Pack) { 12667b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor Args = Arg.pack_begin(); 12677b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor NumArgs = Arg.pack_size(); 12687b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ArgIdx = 0; 12697b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor continue; 12707b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 12717b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 12727b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ++ArgIdx; 12737b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (ArgIdx == NumArgs) 12747b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 12757b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 12767b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Arg.isPackExpansion()) 12777b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return true; 12787b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 12797b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 12807b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 12817b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor} 12827b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 12831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic Sema::TemplateDeductionResult 1284a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1285f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 128620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 128720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 12882a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 12890972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 12900972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor bool NumberOfArgumentsMustMatch) { 1291e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1292e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // If the template argument list of P contains a pack expansion that is not 1293e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // the last template argument, the entire template argument list is a 1294e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // non-deduced context. 12957b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (hasPackExpansionBeforeEnd(Params, NumParams)) 12967b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return Sema::TDK_Success; 12977b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 1298e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1299e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // If P has a form that contains <T> or <i>, then each argument Pi of the 1300e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // respective template argument list P is compared with the corresponding 1301e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // argument Ai of the corresponding template argument list of A. 130220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 130320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); 130420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ParamIdx) { 1305e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // FIXME: Variadic templates. 1306e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // What do we do if the argument is a pack expansion? 1307e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 130820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!Params[ParamIdx].isPackExpansion()) { 1309e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The simple case: deduce template arguments by matching Pi and Ai. 131020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 131120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Check whether we have enough arguments. 131220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) 13130972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor return NumberOfArgumentsMustMatch? Sema::TDK_TooFewArguments 13140972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor : Sema::TDK_Success; 131520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1316e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Perform deduction for this Pi/Ai pair. 131720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Sema::TemplateDeductionResult Result 1318a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 131920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Params[ParamIdx], Args[ArgIdx], 1320f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced)) 132120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return Result; 132220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 132320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Move to the next argument. 132420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ArgIdx; 132520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor continue; 132620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor } 132720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1328e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The parameter is a pack expansion. 1329e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1330e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1331e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // If Pi is a pack expansion, then the pattern of Pi is compared with 1332e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // each remaining argument in the template argument list of A. Each 1333e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // comparison deduces template arguments for subsequent positions in the 1334e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template parameter packs expanded by Pi. 1335e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); 1336e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1337e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Compute the set of template parameter indices that correspond to 1338e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // parameter packs expanded by the pack expansion. 1339e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::SmallVector<unsigned, 2> PackIndices; 1340e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor { 1341e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::BitVector SawIndices(TemplateParams->size()); 1342e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1343e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 1344e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 1345e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned Depth, Index; 1346e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 1347e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 1348e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SawIndices[Index] = true; 1349e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor PackIndices.push_back(Index); 1350e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1351e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1352e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1353e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 1354e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1355e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // FIXME: If there are no remaining arguments, we can bail out early 1356e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // and set any deduced parameter packs to an empty argument pack. 1357e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The latter part of this is a (minor) correctness issue. 1358e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1359e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Save the deduced template arguments for each parameter pack expanded 1360e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, then clear out the deduction. 1361e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 2> 1362e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SavedPacks(PackIndices.size()); 1363e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 1364e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SavedPacks[I] = Deduced[PackIndices[I]]; 1365e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Deduced[PackIndices[I]] = DeducedTemplateArgument(); 1366e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1367e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1368e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Keep track of the deduced template arguments for each parameter pack 1369e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // expanded by this pack expansion (the outer index) and for each 1370e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template argument (the inner SmallVectors). 1371e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2> 1372e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor NewlyDeducedPacks(PackIndices.size()); 1373e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor bool HasAnyArguments = false; 1374e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) { 1375e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor HasAnyArguments = true; 1376e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1377e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Deduce template arguments from the pattern. 1378e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (Sema::TemplateDeductionResult Result 1379e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], 1380e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info, Deduced)) 1381e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Result; 1382e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1383e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 1384e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 1385e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // for that pack, then clear out the deduced argument. 1386e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 1387e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 1388e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (!DeducedArg.isNull()) { 1389e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 1390e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedArg = DeducedTemplateArgument(); 1391e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1392e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1393e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1394e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ++ArgIdx; 1395e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1396e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1397e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 1398e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // pack expansion. 1399e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 1400e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { 1401e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // We were not able to deduce anything for this parameter pack, 1402e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // so just restore the saved argument pack. 1403e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Deduced[PackIndices[I]] = SavedPacks[I]; 1404e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor continue; 1405e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1406e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 14070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewPack; 1408e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1409e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (NewlyDeducedPacks[I].empty()) { 1410e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // If we deduced an empty argument pack, create it now. 14110d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewPack = DeducedTemplateArgument(TemplateArgument(0, 0)); 14120d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } else { 14130d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor TemplateArgument *ArgumentPack 14140d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; 14150d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), 14160d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor ArgumentPack); 14170d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewPack 14180d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor = DeducedTemplateArgument(TemplateArgument(ArgumentPack, 1419e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor NewlyDeducedPacks[I].size()), 14200d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); 14210d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 14220d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 14230d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result 14240d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); 14250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 14260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param 14270d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); 14280d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = SavedPacks[I]; 14290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewPack; 14300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 14310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 14320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 14330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[PackIndices[I]] = Result; 1434e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 14350b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 143620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 143720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // If there is an argument remaining, then we had too many arguments. 14380972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor if (NumberOfArgumentsMustMatch && 14390972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) 144020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return Sema::TDK_TooManyArguments; 144120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1442f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 14430b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 14440b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 144520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 144620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas GregorDeduceTemplateArguments(Sema &S, 144720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateParameterList *TemplateParams, 144820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ParamList, 144920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ArgList, 145020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 145120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 145220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return DeduceTemplateArguments(S, TemplateParams, 145320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ParamList.data(), ParamList.size(), 145420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgList.data(), ArgList.size(), 145520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 145620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 145720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1458f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor/// \brief Determine whether two template arguments are the same. 14591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic bool isSameTemplateArg(ASTContext &Context, 1460f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &X, 1461f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &Y) { 1462f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.getKind() != Y.getKind()) 1463f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 14641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1465f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor switch (X.getKind()) { 1466f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Null: 1467f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor assert(false && "Comparing NULL template argument"); 1468f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor break; 14691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1470f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Type: 1471f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Context.getCanonicalType(X.getAsType()) == 1472f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Context.getCanonicalType(Y.getAsType()); 14731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1474f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Declaration: 147597fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis return X.getAsDecl()->getCanonicalDecl() == 147697fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis Y.getAsDecl()->getCanonicalDecl(); 14771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1478788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1479a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1480a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return Context.getCanonicalTemplateName( 1481a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == 1482a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Context.getCanonicalTemplateName( 1483a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); 1484788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor 1485f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Integral: 1486f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return *X.getAsIntegral() == *Y.getAsIntegral(); 14871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1488788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Expression: { 1489788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor llvm::FoldingSetNodeID XID, YID; 1490788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor X.getAsExpr()->Profile(XID, Context, true); 1491788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Y.getAsExpr()->Profile(YID, Context, true); 1492788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return XID == YID; 1493788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor } 14941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1495f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Pack: 1496f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.pack_size() != Y.pack_size()) 1497f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 14981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator XP = X.pack_begin(), 15001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XPEnd = X.pack_end(), 1501f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor YP = Y.pack_begin(); 15021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XP != XPEnd; ++XP, ++YP) 1503f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!isSameTemplateArg(Context, *XP, *YP)) 1504f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 1505f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 1506f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return true; 1507f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 1508f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 1509f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 1510f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor} 1511f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 151254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Allocate a TemplateArgumentLoc where all locations have 151354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// been initialized to the given location. 151454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 151554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param S The semantic analysis object. 151654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 151754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param The template argument we are producing template argument 151854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// location information for. 151954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 152054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param NTTPType For a declaration template argument, the type of 152154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// the non-type template parameter that corresponds to this template 152254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 152354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 152454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param Loc The source location to use for the resulting template 152554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 152654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregorstatic TemplateArgumentLoc 152754c53cca105ed595e12fecf04e415c3712bda936Douglas GregorgetTrivialTemplateArgumentLoc(Sema &S, 152854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor const TemplateArgument &Arg, 152954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType, 153054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor SourceLocation Loc) { 153154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor switch (Arg.getKind()) { 153254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Null: 153354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm_unreachable("Can't get a NULL template argument here"); 153454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor break; 153554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 153654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Type: 153754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, 153854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 153954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 154054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Declaration: { 154154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 1542ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) 154354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor .takeAs<Expr>(); 154454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 154554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 154654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 154754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Integral: { 154854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 1549ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>(); 155054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 155154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 155254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 155354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Template: 1554a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgumentLoc(Arg, SourceRange(), Loc); 1555a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1556a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1557a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgumentLoc(Arg, SourceRange(), Loc, Loc); 1558a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 155954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Expression: 156054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, Arg.getAsExpr()); 156154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 156254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Pack: 156354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 156454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 156554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 156654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(); 156754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 156854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 156954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 157054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Convert the given deduced template argument and add it to the set of 157154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// fully-converted template arguments. 157254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregorstatic bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, 157354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument Arg, 157454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NamedDecl *Template, 157554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType, 157654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateDeductionInfo &Info, 157754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor bool InFunctionTemplate, 157854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Output) { 157954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 158054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // This is a template argument pack, so check each of its arguments against 158154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template parameter. 158254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm::SmallVector<TemplateArgument, 2> PackedArgsBuilder; 158354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor for (TemplateArgument::pack_iterator PA = Arg.pack_begin(), 1584135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor PAEnd = Arg.pack_end(); 158554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor PA != PAEnd; ++PA) { 1586d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // When converting the deduced template argument, append it to the 1587d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // general output list. We need to do this so that the template argument 1588d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // checking logic has all of the prior template arguments available. 158954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument InnerArg(*PA); 159054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); 159154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, 159254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NTTPType, Info, 1593d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor InFunctionTemplate, Output)) 159454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return true; 1595d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor 1596d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // Move the converted template argument into our argument pack. 1597d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor PackedArgsBuilder.push_back(Output.back()); 1598d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Output.pop_back(); 159954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 160054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 160154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Create the resulting argument pack. 160254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateArgument *PackedArgs = 0; 160354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (!PackedArgsBuilder.empty()) { 160454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor PackedArgs = new (S.Context) TemplateArgument[PackedArgsBuilder.size()]; 160554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor std::copy(PackedArgsBuilder.begin(), PackedArgsBuilder.end(), PackedArgs); 160654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 160754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Output.push_back(TemplateArgument(PackedArgs, PackedArgsBuilder.size())); 160854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return false; 160954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 161054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 161154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Convert the deduced template argument into a template 161254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // argument that we can check, almost as if the user had written 161354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template argument explicitly. 161454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType, 161554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.getLocation()); 161654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 161754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Check the template argument, converting it as necessary. 161854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return S.CheckTemplateArgument(Param, ArgLoc, 161954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template, 162054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getLocation(), 162154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getSourceRange().getEnd(), 162254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Output, 162354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InFunctionTemplate 162454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor ? (Arg.wasDeducedFromArrayBound() 162554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor ? Sema::CTAK_DeducedFromArrayBound 162654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Deduced) 162754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Specified); 162854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 162954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 163031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// Complete template argument deduction for a class template partial 163131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// specialization. 163231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregorstatic Sema::TemplateDeductionResult 163331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorFinishTemplateArgumentDeduction(Sema &S, 163431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor ClassTemplatePartialSpecializationDecl *Partial, 163531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 163631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 16372a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info) { 163831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // Trap errors. 163931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::SFINAETrap Trap(S); 164031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 164131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::ContextRAII SavedContext(S, Partial); 1642f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 164302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // C++ [temp.deduct.type]p2: 164402cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // [...] or if any template argument remains neither deduced nor 164502cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // explicitly specified, template argument deduction fails. 1646910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor llvm::SmallVector<TemplateArgument, 4> Builder; 1647033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor TemplateParameterList *PartialParams = Partial->getTemplateParameters(); 1648033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { 164954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NamedDecl *Param = PartialParams->getParam(I); 1650f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Deduced[I].isNull()) { 165154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 165231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Incomplete; 1653f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 165431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 165554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // We have deduced this argument, so it still needs to be 165654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // checked and converted. 165754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 165854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // First, for a non-type template parameter type that is 165954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // initialized by a declaration, we need the type of the 166054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // corresponding non-type template parameter. 166154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType; 166254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (NonTypeTemplateParmDecl *NTTP 1663d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 166454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NTTPType = NTTP->getType(); 1665d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType->isDependentType()) { 1666d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 1667d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.data(), Builder.size()); 1668d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTPType = S.SubstType(NTTPType, 1669d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 1670d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getLocation(), 1671d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getDeclName()); 1672d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType.isNull()) { 1673d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Info.Param = makeTemplateParameter(Param); 1674d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // FIXME: These template arguments are temporary. Free them! 1675d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Info.reset(TemplateArgumentList::CreateCopy(S.Context, 1676d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.data(), 1677d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.size())); 1678d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor return Sema::TDK_SubstitutionFailure; 1679d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 1680d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 1681d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 1682d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor 168354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], 168454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Partial, NTTPType, Info, false, 168554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Builder)) { 168654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 168754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // FIXME: These template arguments are temporary. Free them! 168854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 168954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Builder.size())); 169054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return Sema::TDK_SubstitutionFailure; 169154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 169202cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 169331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 169402cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Form the template argument list from the deduced template arguments. 16951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 1696910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 1697910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size()); 1698910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor 1699f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.reset(DeducedArgumentList); 170002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 170102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Substitute the deduced template arguments into the template 170202cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // arguments of the class template partial specialization, and 170302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // verify that the instantiated template arguments are both valid 170402cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // and are equivalent to the template arguments originally provided 17051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // to the class template. 17062a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(S); 170702cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); 1708833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall const TemplateArgumentLoc *PartialTemplateArgs 1709833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall = Partial->getTemplateArgsAsWritten(); 1710d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 1711d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall // Note that we don't provide the langle and rangle locations. 1712d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall TemplateArgumentListInfo InstArgs; 1713d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 1714e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (S.Subst(PartialTemplateArgs, 1715e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getNumTemplateArgsAsWritten(), 1716e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { 1717e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; 1718e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (ParamIdx >= Partial->getTemplateParameters()->size()) 1719e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ParamIdx = Partial->getTemplateParameters()->size() - 1; 1720e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1721e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Decl *Param 1722e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = const_cast<NamedDecl *>( 1723e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getTemplateParameters()->getParam(ParamIdx)); 1724e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.Param = makeTemplateParameter(Param); 1725e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); 1726e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Sema::TDK_SubstitutionFailure; 1727833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 1728833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 1729910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor llvm::SmallVector<TemplateArgument, 4> ConvertedInstArgs; 173031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(), 173154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InstArgs, false, ConvertedInstArgs)) 173231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 1733833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 173454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateParameterList *TemplateParams 173554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor = ClassTemplate->getTemplateParameters(); 173654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { 1737910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument InstArg = ConvertedInstArgs.data()[I]; 173831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { 17392fdc5e8199e1e239620f2faae88997153703e16fDouglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); 1740f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = TemplateArgs[I]; 1741f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.SecondArg = InstArg; 174231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1743f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 174402cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 174502cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 1746bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor if (Trap.hasErrorOccurred()) 174731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 1748bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor 174931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Success; 175031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor} 175131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 175231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// \brief Perform template argument deduction to determine whether 175331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// the given template arguments match the given class template 175431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// partial specialization per C++ [temp.class.spec.match]. 175531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::TemplateDeductionResult 175631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, 175731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 175831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateDeductionInfo &Info) { 175931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // C++ [temp.class.spec.match]p2: 176031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // A partial specialization matches a given actual template 176131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // argument list if the template arguments of the partial 176231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specialization can be deduced from the actual template argument 176331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // list (14.8.2). 176431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor SFINAETrap Trap(*this); 176531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 176631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced.resize(Partial->getTemplateParameters()->size()); 176731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (TemplateDeductionResult Result 176831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor = ::DeduceTemplateArguments(*this, 176931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateParameters(), 177031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateArgs(), 177131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateArgs, Info, Deduced)) 177231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Result; 177331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 177431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, 17759b623639378d53a675921ddfa7316034d571881eDouglas Gregor Deduced.data(), Deduced.size(), Info); 177631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Inst) 177731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return TDK_InstantiationDepth; 177831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 177931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Trap.hasErrorOccurred()) 178031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 178131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 178231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, 178331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced, Info); 17840b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 1785031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 17864112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor/// \brief Determine whether the given type T is a simple-template-id type. 17874112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregorstatic bool isSimpleTemplateIdType(QualType T) { 17881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *Spec 1789183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = T->getAs<TemplateSpecializationType>()) 17904112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return Spec->getTemplateName().getAsTemplateDecl() != 0; 17911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 17924112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return false; 17934112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor} 179483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 179583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Substitute the explicitly-provided template arguments into the 179683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// given function template according to C++ [temp.arg.explicit]. 179783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 179883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template into which the explicit 179983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template arguments will be substituted. 180083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 18011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ExplicitTemplateArguments the explicitly-specified template 180283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// arguments. 180383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 18041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param Deduced the deduced template arguments, which will be populated 180583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// with the converted and checked explicit template arguments. 180683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 18071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ParamTypes will be populated with the instantiated function 180883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// parameters. 180983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 181083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionType if non-NULL, the result type of the function template 181183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// will also be instantiated and the pointed-to value will be updated with 181283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the instantiated function type. 181383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 181483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info if substitution fails for any reason, this object will be 181583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// populated with more information about the failure. 181683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 181783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns TDK_Success if substitution was successful, or some failure 181883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// condition. 181983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 182083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::SubstituteExplicitTemplateArguments( 182183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplateDecl *FunctionTemplate, 1822d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo &ExplicitTemplateArgs, 182302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 182483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVectorImpl<QualType> &ParamTypes, 182583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType *FunctionType, 182683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 182783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 182883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 182983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 183083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 1831d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs.size() == 0) { 183283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // No arguments to substitute; just copy over the parameter types and 183383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // fill in the function type. 183483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (FunctionDecl::param_iterator P = Function->param_begin(), 183583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor PEnd = Function->param_end(); 183683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor P != PEnd; 183783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ++P) 183883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.push_back((*P)->getType()); 18391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 184083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) 184183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *FunctionType = Function->getType(); 184283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 184383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 18441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 184583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitution of the explicit template arguments into a function template 184683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor /// is a SFINAE context. Trap any errors that might occur. 18471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 18481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 184983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p3: 18501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Template arguments that are present shall be specified in the 18511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // declaration order of their corresponding template-parameters. The 185283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template argument list shall not specify more template-arguments than 18531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // there are corresponding template-parameters. 1854910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor llvm::SmallVector<TemplateArgument, 4> Builder; 18551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 18561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Enter a new template instantiation context where we check the 185783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments against this function template, 185883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // and then substitute them into the function parameter types. 18591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 186083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplate, Deduced.data(), Deduced.size(), 18619b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, 18629b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 186383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Inst) 186483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InstantiationDepth; 18651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 186683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (CheckTemplateArgumentList(FunctionTemplate, 186783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SourceLocation(), 1868d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall ExplicitTemplateArgs, 186983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor true, 1870f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor Builder) || Trap.hasErrorOccurred()) { 1871910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor unsigned Index = Builder.size(); 1872fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor if (Index >= TemplateParams->size()) 1873fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Index = TemplateParams->size() - 1; 1874fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); 187583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InvalidExplicitArguments; 1876f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor } 18771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 187883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the explicitly-specified 187983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments. 18801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *ExplicitArgumentList 1881910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 188283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(ExplicitArgumentList); 18831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1884df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // Template argument deduction and the final substitution should be 1885df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // done in the context of the templated declaration. Explicit 1886df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // argument substitution, on the other hand, needs to happen in the 1887df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // calling context. 1888df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 1889df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall 189083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Instantiate the types of each of the function parameters given the 189183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments. 189283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (FunctionDecl::param_iterator P = Function->param_begin(), 189383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor PEnd = Function->param_end(); 189483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor P != PEnd; 189583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ++P) { 18961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType ParamType 18971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump = SubstType((*P)->getType(), 1898357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 1899357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor (*P)->getLocation(), (*P)->getDeclName()); 190083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (ParamType.isNull() || Trap.hasErrorOccurred()) 190183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 19021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 190383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.push_back(ParamType); 190483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 190583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 190683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // If the caller wants a full function type back, instantiate the return 190783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // type and form that function type. 190883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) { 190983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // FIXME: exception-specifications? 19101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *Proto 1911183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Function->getType()->getAs<FunctionProtoType>(); 191283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor assert(Proto && "Function template does not have a prototype?"); 19131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType ResultType 1915357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor = SubstType(Proto->getResultType(), 1916357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 1917357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor Function->getTypeSpecStartLoc(), 1918357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor Function->getDeclName()); 191983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (ResultType.isNull() || Trap.hasErrorOccurred()) 192083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 19211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump *FunctionType = BuildFunctionType(ResultType, 192383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.data(), ParamTypes.size(), 192483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->isVariadic(), 192583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->getTypeQuals(), 192683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getLocation(), 1927fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Function->getDeclName(), 1928fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Proto->getExtInfo()); 192983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType->isNull() || Trap.hasErrorOccurred()) 193083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 193183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 19321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 193383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p2: 19341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Trailing template arguments that can be deduced (14.8.2) may be 19351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // omitted from the list of explicit template-arguments. If all of the 193683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments can be deduced, they may all be omitted; in this 193783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // case, the empty template argument list <> itself may also be omitted. 193883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // 193983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Take all of the explicitly-specified arguments and put them into the 19401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // set of deduced template arguments. 194183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced.reserve(TemplateParams->size()); 194283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) 19431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.push_back(ExplicitArgumentList->get(I)); 19441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 194583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 194683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 194783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 19481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Finish template argument deduction for a function template, 194983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// checking the deduced template arguments for completeness and forming 195083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the function template specialization. 19511eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::TemplateDeductionResult 195283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, 195302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 195402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified, 195583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 195683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 195783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 195883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 19591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 196051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Template argument deduction for function templates in a SFINAE context. 196151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Trap any errors that might occur. 196251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor SFINAETrap Trap(*this); 196351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 196451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Enter a new template instantiation context while we instantiate the 196551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // actual function declaration. 196651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 196751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate, Deduced.data(), Deduced.size(), 19689b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, 19699b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 197051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (Inst) 197151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_InstantiationDepth; 197251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 197396db310ab7ca59e1890ddef25a3701bc2909d20fJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 1974f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 197583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.deduct.type]p2: 197683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // [...] or if any template argument remains neither deduced nor 197783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly specified, template argument deduction fails. 1978910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor llvm::SmallVector<TemplateArgument, 4> Builder; 1979b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 1980b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NamedDecl *Param = TemplateParams->getParam(I); 1981ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor 198251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (!Deduced[I].isNull()) { 19833273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor if (I < NumExplicitlySpecified) { 198402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have already fully type-checked and converted this 19853273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor // argument, because it was explicitly-specified. Just record the 19863273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor // presence of this argument. 1987910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.push_back(Deduced[I]); 198802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor continue; 198902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 199002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 199102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have deduced this argument, so it still needs to be 199202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // checked and converted. 199302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 199402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // First, for a non-type template parameter type that is 199502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // initialized by a declaration, we need the type of the 199602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // corresponding non-type template parameter. 199702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor QualType NTTPType; 199802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor if (NonTypeTemplateParmDecl *NTTP 199902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2000b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = NTTP->getType(); 2001b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType->isDependentType()) { 2002b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2003b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.data(), Builder.size()); 2004b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = SubstType(NTTPType, 2005b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 2006b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getLocation(), 2007b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getDeclName()); 2008b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType.isNull()) { 2009b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2010b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2011b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.reset(TemplateArgumentList::CreateCopy(Context, 2012b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.data(), 2013b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.size())); 2014b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor return TDK_SubstitutionFailure; 201502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 201602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 201702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 201802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 2019b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I], 2020b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor FunctionTemplate, NTTPType, Info, 202154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor true, Builder)) { 2022b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2023910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2024910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2025b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.size())); 202602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor return TDK_SubstitutionFailure; 202702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 202802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 202951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor continue; 203051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 2031ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor 2032ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // C++0x [temp.arg.explicit]p3: 2033ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // A trailing template parameter pack (14.5.3) not otherwise deduced will 2034ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // be deduced to an empty sequence of template arguments. 2035ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // FIXME: Where did the word "trailing" come from? 2036ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor if (Param->isTemplateParameterPack()) { 2037ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor Builder.push_back(TemplateArgument(0, 0)); 2038ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor continue; 2039ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor } 204051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 204151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Substitute into the default template argument, if available. 204251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor TemplateArgumentLoc DefArg 204351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate, 204451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 204551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 204651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Param, 204751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Builder); 204851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 204951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If there was no default argument, deduction is incomplete. 205051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (DefArg.getArgument().isNull()) { 205183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.Param = makeTemplateParameter( 205251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 205383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Incomplete; 205483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 205551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 205651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Check whether we can actually use the default argument. 205751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (CheckTemplateArgument(Param, DefArg, 205851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate, 205951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 206051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 206102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Builder, 206202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor CTAK_Deduced)) { 206351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Info.Param = makeTemplateParameter( 206451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 2065910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2066910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2067910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size())); 206851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_SubstitutionFailure; 206951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 20701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 207151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If we get here, we successfully used the default template argument. 207283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 20731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 207483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the deduced template arguments. 20751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 2076910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 207783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(DeducedArgumentList); 20781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Substitute the deduced template arguments into the function template 208083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration to produce the function template specialization. 2081d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor DeclContext *Owner = FunctionTemplate->getDeclContext(); 2082d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor if (FunctionTemplate->getFriendObjectKind()) 2083d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor Owner = FunctionTemplate->getLexicalDeclContext(); 208483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization = cast_or_null<FunctionDecl>( 2085d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, 2086357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor MultiLevelTemplateArgumentList(*DeducedArgumentList))); 208783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (!Specialization) 208883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 20891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2090f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == 2091f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor FunctionTemplate->getCanonicalDecl()); 2092f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor 20931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the template argument list is owned by the function template 209483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // specialization, release it. 2095ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList && 2096ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor !Trap.hasErrorOccurred()) 209783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.take(); 20981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 209983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // There may have been an error that did not prevent us from constructing a 210083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration. Mark the declaration invalid and return with a substitution 210183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // failure. 210283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Trap.hasErrorOccurred()) { 210383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization->setInvalidDecl(true); 210483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 210583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 21061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21079b623639378d53a675921ddfa7316034d571881eDouglas Gregor // If we suppressed any diagnostics while performing template argument 21089b623639378d53a675921ddfa7316034d571881eDouglas Gregor // deduction, and if we haven't already instantiated this declaration, 21099b623639378d53a675921ddfa7316034d571881eDouglas Gregor // keep track of these diagnostics. They'll be emitted if this specialization 21109b623639378d53a675921ddfa7316034d571881eDouglas Gregor // is actually used. 21119b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Info.diag_begin() != Info.diag_end()) { 21129b623639378d53a675921ddfa7316034d571881eDouglas Gregor llvm::DenseMap<Decl *, llvm::SmallVector<PartialDiagnosticAt, 1> >::iterator 21139b623639378d53a675921ddfa7316034d571881eDouglas Gregor Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); 21149b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Pos == SuppressedDiagnostics.end()) 21159b623639378d53a675921ddfa7316034d571881eDouglas Gregor SuppressedDiagnostics[Specialization->getCanonicalDecl()] 21169b623639378d53a675921ddfa7316034d571881eDouglas Gregor .append(Info.diag_begin(), Info.diag_end()); 21179b623639378d53a675921ddfa7316034d571881eDouglas Gregor } 21189b623639378d53a675921ddfa7316034d571881eDouglas Gregor 21191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TDK_Success; 212083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 212183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 21229c72c6088d591ace8503b842d39448c2040f3033John McCall/// Gets the type of a function for template-argument-deducton 21239c72c6088d591ace8503b842d39448c2040f3033John McCall/// purposes when it's considered as part of an overload set. 2124eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType GetTypeOfFunction(ASTContext &Context, 21259c72c6088d591ace8503b842d39448c2040f3033John McCall const OverloadExpr::FindResult &R, 2126eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn) { 2127eff92135d32039c9874dc356f3e93143af6069c1John McCall if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) 21289c72c6088d591ace8503b842d39448c2040f3033John McCall if (Method->isInstance()) { 21299c72c6088d591ace8503b842d39448c2040f3033John McCall // An instance method that's referenced in a form that doesn't 21309c72c6088d591ace8503b842d39448c2040f3033John McCall // look like a member pointer is just invalid. 21319c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.HasFormOfMemberPointer) return QualType(); 21329c72c6088d591ace8503b842d39448c2040f3033John McCall 2133eff92135d32039c9874dc356f3e93143af6069c1John McCall return Context.getMemberPointerType(Fn->getType(), 2134eff92135d32039c9874dc356f3e93143af6069c1John McCall Context.getTypeDeclType(Method->getParent()).getTypePtr()); 21359c72c6088d591ace8503b842d39448c2040f3033John McCall } 21369c72c6088d591ace8503b842d39448c2040f3033John McCall 21379c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.IsAddressOfOperand) return Fn->getType(); 2138eff92135d32039c9874dc356f3e93143af6069c1John McCall return Context.getPointerType(Fn->getType()); 2139eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2140eff92135d32039c9874dc356f3e93143af6069c1John McCall 2141eff92135d32039c9874dc356f3e93143af6069c1John McCall/// Apply the deduction rules for overload sets. 2142eff92135d32039c9874dc356f3e93143af6069c1John McCall/// 2143eff92135d32039c9874dc356f3e93143af6069c1John McCall/// \return the null type if this argument should be treated as an 2144eff92135d32039c9874dc356f3e93143af6069c1John McCall/// undeduced context 2145eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType 2146eff92135d32039c9874dc356f3e93143af6069c1John McCallResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, 214775f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor Expr *Arg, QualType ParamType, 214875f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor bool ParamWasReference) { 21499c72c6088d591ace8503b842d39448c2040f3033John McCall 21509c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr::FindResult R = OverloadExpr::find(Arg); 2151eff92135d32039c9874dc356f3e93143af6069c1John McCall 21529c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr *Ovl = R.Expression; 2153eff92135d32039c9874dc356f3e93143af6069c1John McCall 215475f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // C++0x [temp.deduct.call]p4 215575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor unsigned TDF = 0; 215675f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (ParamWasReference) 215775f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_ParamWithReferenceType; 215875f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (R.IsAddressOfOperand) 215975f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_IgnoreQualifiers; 216075f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 2161eff92135d32039c9874dc356f3e93143af6069c1John McCall // If there were explicit template arguments, we can only find 2162eff92135d32039c9874dc356f3e93143af6069c1John McCall // something via C++ [temp.arg.explicit]p3, i.e. if the arguments 2163eff92135d32039c9874dc356f3e93143af6069c1John McCall // unambiguously name a full specialization. 21647bb12da2b0749eeebb21854c77877736969e59f2John McCall if (Ovl->hasExplicitTemplateArgs()) { 2165eff92135d32039c9874dc356f3e93143af6069c1John McCall // But we can still look for an explicit specialization. 2166eff92135d32039c9874dc356f3e93143af6069c1John McCall if (FunctionDecl *ExplicitSpec 21677bb12da2b0749eeebb21854c77877736969e59f2John McCall = S.ResolveSingleFunctionTemplateSpecialization(Ovl)) 21689c72c6088d591ace8503b842d39448c2040f3033John McCall return GetTypeOfFunction(S.Context, R, ExplicitSpec); 2169eff92135d32039c9874dc356f3e93143af6069c1John McCall return QualType(); 2170eff92135d32039c9874dc356f3e93143af6069c1John McCall } 2171eff92135d32039c9874dc356f3e93143af6069c1John McCall 2172eff92135d32039c9874dc356f3e93143af6069c1John McCall // C++0x [temp.deduct.call]p6: 2173eff92135d32039c9874dc356f3e93143af6069c1John McCall // When P is a function type, pointer to function type, or pointer 2174eff92135d32039c9874dc356f3e93143af6069c1John McCall // to member function type: 2175eff92135d32039c9874dc356f3e93143af6069c1John McCall 2176eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!ParamType->isFunctionType() && 2177eff92135d32039c9874dc356f3e93143af6069c1John McCall !ParamType->isFunctionPointerType() && 2178eff92135d32039c9874dc356f3e93143af6069c1John McCall !ParamType->isMemberFunctionPointerType()) 2179eff92135d32039c9874dc356f3e93143af6069c1John McCall return QualType(); 2180eff92135d32039c9874dc356f3e93143af6069c1John McCall 2181eff92135d32039c9874dc356f3e93143af6069c1John McCall QualType Match; 21827bb12da2b0749eeebb21854c77877736969e59f2John McCall for (UnresolvedSetIterator I = Ovl->decls_begin(), 21837bb12da2b0749eeebb21854c77877736969e59f2John McCall E = Ovl->decls_end(); I != E; ++I) { 2184eff92135d32039c9874dc356f3e93143af6069c1John McCall NamedDecl *D = (*I)->getUnderlyingDecl(); 2185eff92135d32039c9874dc356f3e93143af6069c1John McCall 2186eff92135d32039c9874dc356f3e93143af6069c1John McCall // - If the argument is an overload set containing one or more 2187eff92135d32039c9874dc356f3e93143af6069c1John McCall // function templates, the parameter is treated as a 2188eff92135d32039c9874dc356f3e93143af6069c1John McCall // non-deduced context. 2189eff92135d32039c9874dc356f3e93143af6069c1John McCall if (isa<FunctionTemplateDecl>(D)) 2190eff92135d32039c9874dc356f3e93143af6069c1John McCall return QualType(); 2191eff92135d32039c9874dc356f3e93143af6069c1John McCall 2192eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn = cast<FunctionDecl>(D); 21939c72c6088d591ace8503b842d39448c2040f3033John McCall QualType ArgType = GetTypeOfFunction(S.Context, R, Fn); 21949c72c6088d591ace8503b842d39448c2040f3033John McCall if (ArgType.isNull()) continue; 2195eff92135d32039c9874dc356f3e93143af6069c1John McCall 219675f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // Function-to-pointer conversion. 219775f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (!ParamWasReference && ParamType->isPointerType() && 219875f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType->isFunctionType()) 219975f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 220075f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 2201eff92135d32039c9874dc356f3e93143af6069c1John McCall // - If the argument is an overload set (not containing function 2202eff92135d32039c9874dc356f3e93143af6069c1John McCall // templates), trial argument deduction is attempted using each 2203eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the members of the set. If deduction succeeds for only one 2204eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the overload set members, that member is used as the 2205eff92135d32039c9874dc356f3e93143af6069c1John McCall // argument value for the deduction. If deduction succeeds for 2206eff92135d32039c9874dc356f3e93143af6069c1John McCall // more than one member of the overload set the parameter is 2207eff92135d32039c9874dc356f3e93143af6069c1John McCall // treated as a non-deduced context. 2208eff92135d32039c9874dc356f3e93143af6069c1John McCall 2209eff92135d32039c9874dc356f3e93143af6069c1John McCall // We do all of this in a fresh context per C++0x [temp.deduct.type]p2: 2210eff92135d32039c9874dc356f3e93143af6069c1John McCall // Type deduction is done independently for each P/A pair, and 2211eff92135d32039c9874dc356f3e93143af6069c1John McCall // the deduced template argument values are then combined. 2212eff92135d32039c9874dc356f3e93143af6069c1John McCall // So we do not reject deductions which were made elsewhere. 221302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 8> 221402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Deduced(TemplateParams->size()); 22152a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(S.Context, Ovl->getNameLoc()); 2216eff92135d32039c9874dc356f3e93143af6069c1John McCall Sema::TemplateDeductionResult Result 2217a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 2218eff92135d32039c9874dc356f3e93143af6069c1John McCall ParamType, ArgType, 2219eff92135d32039c9874dc356f3e93143af6069c1John McCall Info, Deduced, TDF); 2220eff92135d32039c9874dc356f3e93143af6069c1John McCall if (Result) continue; 2221eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!Match.isNull()) return QualType(); 2222eff92135d32039c9874dc356f3e93143af6069c1John McCall Match = ArgType; 2223eff92135d32039c9874dc356f3e93143af6069c1John McCall } 2224eff92135d32039c9874dc356f3e93143af6069c1John McCall 2225eff92135d32039c9874dc356f3e93143af6069c1John McCall return Match; 2226eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2227eff92135d32039c9874dc356f3e93143af6069c1John McCall 2228f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// \brief Perform the adjustments to the parameter and argument types 2229f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// described in C++ [temp.deduct.call]. 2230f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// 2231f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// \returns true if the caller should not attempt to perform any template 2232f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// argument deduction based on this P/A pair. 2233f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregorstatic bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, 2234f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TemplateParameterList *TemplateParams, 2235f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ParamType, 2236f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ArgType, 2237f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg, 2238f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned &TDF) { 2239f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 2240f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // If P is a cv-qualified type, the top level cv-qualifiers of P’s type 2241f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // are ignored for type deduction. 2242f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamType.getCVRQualifiers()) 2243f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType = ParamType.getLocalUnqualifiedType(); 2244f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>(); 2245f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 2246f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is a reference type, the type referred to by P is used 2247f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for type deduction. 2248f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType = ParamRefType->getPointeeType(); 2249f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2250f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2251f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Overload sets usually make this parameter an undeduced 2252f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // context, but there are sometimes special circumstances. 2253f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType == S.Context.OverloadTy) { 2254f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = ResolveOverloadForDeduction(S, TemplateParams, 2255f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg, ParamType, 2256f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType != 0); 2257f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType.isNull()) 2258f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return true; 2259f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2260f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2261f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 2262f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 2263f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is of the form T&&, where T is a template parameter, and 2264f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the argument is an lvalue, the type A& is used in place of A for 2265f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type deduction. 2266f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType->isRValueReferenceType() && 2267f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType->getAs<TemplateTypeParmType>() && 2268f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg->isLValue()) 2269f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getLValueReferenceType(ArgType); 2270f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } else { 2271f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++ [temp.deduct.call]p2: 2272f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // If P is not a reference type: 2273f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is an array type, the pointer type produced by the 2274f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // array-to-pointer standard conversion (4.2) is used in place of 2275f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // A for type deduction; otherwise, 2276f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isArrayType()) 2277f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getArrayDecayedType(ArgType); 2278f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is a function type, the pointer type produced by the 2279f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // function-to-pointer standard conversion (4.3) is used in place 2280f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // of A for type deduction; otherwise, 2281f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (ArgType->isFunctionType()) 2282f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 2283f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else { 2284f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is a cv-qualified type, the top level cv-qualifiers of A’s 2285f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type are ignored for type deduction. 2286f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType CanonArgType = S.Context.getCanonicalType(ArgType); 2287f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType.getCVRQualifiers()) 2288f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = ArgType.getUnqualifiedType(); 2289f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2290f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2291f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2292f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p4: 2293f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // In general, the deduction process attempts to find template argument 2294f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // values that will make the deduced A identical to A (after the type A 2295f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // is transformed as described above). [...] 2296f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF = TDF_SkipNonDependent; 2297f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2298f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 2299f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type referred to by the reference) can be more cv-qualified than 2300f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the transformed A. 2301f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) 2302f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_ParamWithReferenceType; 2303f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - The transformed A can be another pointer or pointer to member 2304f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type that can be converted to the deduced A via a qualification 2305f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // conversion (4.4). 2306f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isPointerType() || ArgType->isMemberPointerType() || 2307f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType->isObjCObjectPointerType()) 2308f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_IgnoreQualifiers; 2309f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If P is a class and P has the form simple-template-id, then the 2310f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a derived class of the deduced A. Likewise, 2311f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // if P is a pointer to a class of the form simple-template-id, the 2312f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a pointer to a derived class pointed to by 2313f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the deduced A. 2314f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (isSimpleTemplateIdType(ParamType) || 2315f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor (isa<PointerType>(ParamType) && 2316f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor isSimpleTemplateIdType( 2317f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType->getAs<PointerType>()->getPointeeType()))) 2318f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_DerivedClass; 2319f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2320f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return false; 2321f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor} 2322f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2323e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \brief Perform template argument deduction from a function call 2324e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// (C++ [temp.deduct.call]). 2325e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2326e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 2327e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 2328e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 232948026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// \param ExplicitTemplateArguments the explicit template arguments provided 233048026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// for this call. 23316db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// 2332e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Args the function call arguments 2333e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2334e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param NumArgs the number of arguments in Args 2335e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 233648026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// \param Name the name of the function being called. This is only significant 233748026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// when the function template is a conversion function template, in which 233848026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// case this routine will also perform template argument deduction based on 233948026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// the function to which 234048026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// 2341e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Specialization if template argument deduction was successful, 23421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 2343e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 2344e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2345e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Info the argument will be updated to provide additional information 2346e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// about template argument deduction. 2347e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2348e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \returns the result of template argument deduction. 2349e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::TemplateDeductionResult 2350e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 235148026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor const TemplateArgumentListInfo *ExplicitTemplateArgs, 2352e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor Expr **Args, unsigned NumArgs, 2353e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *&Specialization, 2354e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateDeductionInfo &Info) { 2355e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 23566db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor 2357e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++ [temp.deduct.call]p1: 2358e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // Template argument deduction is done by comparing each function template 2359e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // parameter type (call it P) with the type of the corresponding argument 2360e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // of the call (call it A) as described below. 2361e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor unsigned CheckArgs = NumArgs; 23626db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor if (NumArgs < Function->getMinRequiredArguments()) 2363e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooFewArguments; 2364e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor else if (NumArgs > Function->getNumParams()) { 23651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *Proto 2366183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Function->getType()->getAs<FunctionProtoType>(); 2367f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Proto->isTemplateVariadic()) 2368f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor /* Do nothing */; 2369f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (Proto->isVariadic()) 2370f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor CheckArgs = Function->getNumParams(); 2371f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else 2372e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooManyArguments; 2373e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 23741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 23756db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // The types of the parameters from which we will perform template argument 23766db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // deduction. 23772a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 2378e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateParameterList *TemplateParams 2379e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor = FunctionTemplate->getTemplateParameters(); 238002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 23816db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor llvm::SmallVector<QualType, 4> ParamTypes; 238202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 2383d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 238483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionResult Result = 238583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SubstituteExplicitTemplateArguments(FunctionTemplate, 2386d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 238783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced, 238883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes, 238983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 0, 239083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info); 239183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Result) 239283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 239302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 239402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 23956db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } else { 23966db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Just fill in the parameter types from the function declaration. 2397f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 23986db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor ParamTypes.push_back(Function->getParamDecl(I)->getType()); 23996db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } 24001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 24016db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Deduce template arguments from the function parameters. 24021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 2403f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned ArgIdx = 0; 2404f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned ParamIdx = 0, NumParams = ParamTypes.size(); 2405f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamIdx != NumParams; ++ParamIdx) { 2406f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ParamType = ParamTypes[ParamIdx]; 2407f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2408f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor const PackExpansionType *ParamExpansion 2409f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = dyn_cast<PackExpansionType>(ParamType); 2410f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!ParamExpansion) { 2411f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Simple case: matching a function parameter to a function argument. 2412f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgIdx >= CheckArgs) 2413f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 2414f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2415f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx++]; 2416f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 2417f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 2418f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 2419f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 2420f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 2421f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 2422f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2423f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (TemplateDeductionResult Result 2424f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = ::DeduceTemplateArguments(*this, TemplateParams, 2425f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Info, Deduced, 2426f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 2427f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return Result; 24281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2429f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // FIXME: we need to check that the deduced A is the same as A, 2430f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // modulo the various allowed differences. 2431f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 243275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor } 243375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 2434f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p1: 2435f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // For a function parameter pack that occurs at the end of the 2436f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // parameter-declaration-list, the type A of each remaining argument of 2437f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the call is compared with the type P of the declarator-id of the 2438f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // function parameter pack. Each comparison deduces template arguments 2439f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for subsequent positions in the template parameter packs expanded by 2440f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the function parameter pack. 2441f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ParamPattern = ParamExpansion->getPattern(); 2442f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::SmallVector<unsigned, 2> PackIndices; 2443f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor { 2444f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::BitVector SawIndices(TemplateParams->size()); 2445f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 2446f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor collectUnexpandedParameterPacks(ParamPattern, Unexpanded); 2447f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 2448f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned Depth, Index; 2449f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 2450f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 2451f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor SawIndices[Index] = true; 2452f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor PackIndices.push_back(Index); 2453f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2454f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2455f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2456f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 2457f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2458f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Save the deduced template arguments for each parameter pack expanded 2459f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // by this pack expansion, then clear out the deduction. 2460f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 2> 2461f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor SavedPacks(PackIndices.size()); 2462f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 2463f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor SavedPacks[I] = Deduced[PackIndices[I]]; 2464f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Deduced[PackIndices[I]] = DeducedTemplateArgument(); 2465eff92135d32039c9874dc356f3e93143af6069c1John McCall } 2466f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2467f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Keep track of the deduced template arguments for each parameter pack 2468f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // expanded by this pack expansion (the outer index) and for each 2469f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // template argument (the inner SmallVectors). 2470f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2> 2471f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewlyDeducedPacks(PackIndices.size()); 2472f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor bool HasAnyArguments = false; 2473f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (; ArgIdx < NumArgs; ++ArgIdx) { 2474f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor HasAnyArguments = true; 2475f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2476f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType = ParamPattern; 2477f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx]; 2478f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 2479f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 2480f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 2481f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 2482f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) { 2483f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // We can't actually perform any deduction for this argument, so stop 2484f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // deduction at this point. 2485f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ++ArgIdx; 2486f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 2487f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2488f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2489f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (TemplateDeductionResult Result 2490f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = ::DeduceTemplateArguments(*this, TemplateParams, 2491f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Info, Deduced, 2492f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 2493f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return Result; 2494eff92135d32039c9874dc356f3e93143af6069c1John McCall 2495f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 2496f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 2497f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for that pack, then clear out the deduced argument. 2498f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 2499f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 2500f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!DeducedArg.isNull()) { 2501f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 2502f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedArg = DeducedTemplateArgument(); 2503f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2504e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 2505e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 2506f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2507f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 2508f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // pack expansion. 2509f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 2510f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { 2511f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // We were not able to deduce anything for this parameter pack, 2512f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // so just restore the saved argument pack. 2513f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Deduced[PackIndices[I]] = SavedPacks[I]; 2514f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 2515f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2516f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2517f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedTemplateArgument NewPack; 2518f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2519f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (NewlyDeducedPacks[I].empty()) { 2520f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // If we deduced an empty argument pack, create it now. 2521f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewPack = DeducedTemplateArgument(TemplateArgument(0, 0)); 2522f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } else { 2523f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TemplateArgument *ArgumentPack 2524f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = new (Context) TemplateArgument [NewlyDeducedPacks[I].size()]; 2525f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), 2526f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgumentPack); 2527f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewPack 2528f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = DeducedTemplateArgument(TemplateArgument(ArgumentPack, 2529f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewlyDeducedPacks[I].size()), 2530f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); 2531f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2532f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2533f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedTemplateArgument Result 2534f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = checkDeducedTemplateArguments(Context, SavedPacks[I], NewPack); 2535f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Result.isNull()) { 2536f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Info.Param 2537f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); 2538f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Info.FirstArg = SavedPacks[I]; 2539f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Info.SecondArg = NewPack; 2540f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return Sema::TDK_Inconsistent; 2541f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2542f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2543f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Deduced[PackIndices[I]] = Result; 2544f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 25451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2546f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // After we've matching against a parameter pack, we're done. 2547f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 2548e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 254965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 25501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 255102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified, 255283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization, Info); 255383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 2554127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor 255583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Deduce template arguments when taking the address of a function 25564b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to 25574b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// a template. 255883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 255983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template for which we are performing 256083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 256183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 25624b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param ExplicitTemplateArguments the explicitly-specified template 25634b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 256483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 256583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ArgFunctionType the function type that will be used as the 256683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// "argument" type (A) when performing template argument deduction from the 25674b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// function template's function type. This type may be NULL, if there is no 25684b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// argument type to compare against, in C++0x [temp.arg.explicit]p3. 256983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 257083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Specialization if template argument deduction was successful, 25711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 257283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 257383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 257483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info the argument will be updated to provide additional information 257583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// about template argument deduction. 257683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 257783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns the result of template argument deduction. 257883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 257983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 2580d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo *ExplicitTemplateArgs, 258183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType ArgFunctionType, 258283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 258383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 258483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 258583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 258683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 258783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType FunctionType = Function->getType(); 25881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 258983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitute any explicit template arguments. 25902a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 259102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 259202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 259383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVector<QualType, 4> ParamTypes; 2594d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 25951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (TemplateDeductionResult Result 25961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump = SubstituteExplicitTemplateArguments(FunctionTemplate, 2597d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 25981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced, ParamTypes, 259983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor &FunctionType, Info)) 260083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 260102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 260202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 2603127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor } 260483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 260583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Template argument deduction for function templates in a SFINAE context. 260683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Trap any errors that might occur. 26071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 26081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2609eff92135d32039c9874dc356f3e93143af6069c1John McCall Deduced.resize(TemplateParams->size()); 2610eff92135d32039c9874dc356f3e93143af6069c1John McCall 26114b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (!ArgFunctionType.isNull()) { 26124b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // Deduce template arguments from the function type. 26134b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (TemplateDeductionResult Result 2614a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = ::DeduceTemplateArguments(*this, TemplateParams, 26154b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionType, ArgFunctionType, Info, 26164b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor Deduced, 0)) 26174b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return Result; 26184b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 2619fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 2620fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor if (TemplateDeductionResult Result 2621fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 2622fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor NumExplicitlySpecified, 2623fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor Specialization, Info)) 2624fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return Result; 2625fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 2626fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // If the requested function type does not match the actual type of the 2627fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // specialization, template argument deduction fails. 2628fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor if (!ArgFunctionType.isNull() && 2629fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor !Context.hasSameType(ArgFunctionType, Specialization->getType())) 2630fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_NonDeducedMismatch; 2631fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 2632fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_Success; 2633e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor} 2634e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 263565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \brief Deduce template arguments for a templated conversion 263665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// function (C++ [temp.deduct.conv]) and, if successful, produce a 263765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// conversion function template specialization. 263865ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::TemplateDeductionResult 263965ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 264065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType ToType, 264165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor CXXConversionDecl *&Specialization, 264265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionInfo &Info) { 26431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CXXConversionDecl *Conv 264465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()); 264565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType FromType = Conv->getConversionType(); 264665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 264765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Canonicalize the types for deduction. 264865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType P = Context.getCanonicalType(FromType); 264965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType A = Context.getCanonicalType(ToType); 265065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 265165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p3: 265265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If P is a reference type, the type referred to by P is used for 265365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type deduction. 265465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *PRef = P->getAs<ReferenceType>()) 265565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = PRef->getPointeeType(); 265665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 265765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p3: 265865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If A is a reference type, the type referred to by A is used 265965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // for type deduction. 266065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *ARef = A->getAs<ReferenceType>()) 266165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor A = ARef->getPointeeType(); 266265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++ [temp.deduct.conv]p2: 266365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 26641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If A is not a reference type: 266565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else { 266665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor assert(!A->isReferenceType() && "Reference types were handled above"); 266765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 266865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is an array type, the pointer type produced by the 26691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // array-to-pointer standard conversion (4.2) is used in place 267065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // of P for type deduction; otherwise, 267165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (P->isArrayType()) 267265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getArrayDecayedType(P); 267365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a function type, the pointer type produced by the 267465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // function-to-pointer standard conversion (4.3) is used in 267565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // place of P for type deduction; otherwise, 267665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else if (P->isFunctionType()) 267765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getPointerType(P); 267865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a cv-qualified type, the top level cv-qualifiers of 267965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // P’s type are ignored for type deduction. 268065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else 268165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = P.getUnqualifiedType(); 268265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 268365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p3: 268465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If A is a cv-qualified type, the top level cv-qualifiers of A’s 268565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type are ignored for type deduction. 268665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor A = A.getUnqualifiedType(); 268765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor } 268865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 268965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Template argument deduction for function templates in a SFINAE context. 269065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Trap any errors that might occur. 26911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 269265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 269365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++ [temp.deduct.conv]p1: 269465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Template argument deduction is done by comparing the return 269565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type of the template conversion function (call it P) with the 269665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type that is required as the result of the conversion (call it 269765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A) as described in 14.8.2.4. 269865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateParameterList *TemplateParams 269965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = FunctionTemplate->getTemplateParameters(); 270002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 27011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 270265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 270365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p4: 270465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // In general, the deduction process attempts to find template 270565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // argument values that will make the deduced A identical to 270665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A. However, there are two cases that allow a difference: 270765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor unsigned TDF = 0; 270865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If the original A is a reference type, A can be more 270965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // cv-qualified than the deduced A (i.e., the type referred to 271065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // by the reference) 271165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (ToType->isReferenceType()) 271265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_ParamWithReferenceType; 271365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - The deduced A can be another pointer or pointer to member 271465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type that can be converted to A via a qualification 271565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // conversion. 271665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 271765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when 271865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // both P and A are pointers or member pointers. In this case, we 271965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // just ignore cv-qualifiers completely). 272065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if ((P->isPointerType() && A->isPointerType()) || 272165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor (P->isMemberPointerType() && P->isMemberPointerType())) 272265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_IgnoreQualifiers; 272365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (TemplateDeductionResult Result 2724a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = ::DeduceTemplateArguments(*this, TemplateParams, 272565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P, A, Info, Deduced, TDF)) 272665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 272765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 272865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // FIXME: we need to check that the deduced A is the same as A, 272965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // modulo the various allowed differences. 27301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 273165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Finish template argument deduction. 27322a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 273365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionDecl *Spec = 0; 273465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionResult Result 273502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec, 273602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Info); 273765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor Specialization = cast_or_null<CXXConversionDecl>(Spec); 273865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 273965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 274065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 27414b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \brief Deduce template arguments for a function template when there is 27424b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// nothing to deduce against (C++0x [temp.arg.explicit]p3). 27434b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 27444b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 27454b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 27464b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 27474b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param ExplicitTemplateArguments the explicitly-specified template 27484b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 27494b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 27504b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Specialization if template argument deduction was successful, 27514b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// this will be set to the function template specialization produced by 27524b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 27534b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 27544b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Info the argument will be updated to provide additional information 27554b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// about template argument deduction. 27564b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 27574b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \returns the result of template argument deduction. 27584b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::TemplateDeductionResult 27594b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 27604b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor const TemplateArgumentListInfo *ExplicitTemplateArgs, 27614b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionDecl *&Specialization, 27624b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor TemplateDeductionInfo &Info) { 27634b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, 27644b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor QualType(), Specialization, Info); 27654b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor} 27664b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor 27678a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \brief Stores the result of comparing the qualifiers of two types. 27688a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorenum DeductionQualifierComparison { 27698a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor NeitherMoreQualified = 0, 27708a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor ParamMoreQualified, 27718a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor ArgMoreQualified 27728a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor}; 27738a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 27748a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \brief Deduce the template arguments during partial ordering by comparing 27758a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// the parameter type and the argument type (C++0x [temp.deduct.partial]). 27768a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// 2777a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the semantic analysis object within which we are deducing 27788a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// 27798a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param TemplateParams the template parameters that we are deducing 27808a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// 27818a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param ParamIn the parameter type 27828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// 27838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param ArgIn the argument type 27848a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// 27858a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param Info information about the template argument deduction itself 27868a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// 27878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param Deduced the deduced template arguments 27888a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// 27898a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \returns the result of template argument deduction so far. Note that a 27908a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// "success" result means that template argument deduction has not yet failed, 27918a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// but it may still fail, later, for other reasons. 27928a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic Sema::TemplateDeductionResult 2793a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArgumentsDuringPartialOrdering(Sema &S, 279402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor TemplateParameterList *TemplateParams, 27958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor QualType ParamIn, QualType ArgIn, 27962a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 279702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 279802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeductionQualifierComparison> *QualifierComparisons) { 2799a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth CanQualType Param = S.Context.getCanonicalType(ParamIn); 2800a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth CanQualType Arg = S.Context.getCanonicalType(ArgIn); 28018a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 28028a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p5: 28038a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // Before the partial ordering is done, certain transformations are 28048a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // performed on the types used for partial ordering: 28058a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - If P is a reference type, P is replaced by the type referred to. 28068a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor CanQual<ReferenceType> ParamRef = Param->getAs<ReferenceType>(); 2807e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall if (!ParamRef.isNull()) 28088a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Param = ParamRef->getPointeeType(); 28098a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 28108a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - If A is a reference type, A is replaced by the type referred to. 28118a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor CanQual<ReferenceType> ArgRef = Arg->getAs<ReferenceType>(); 2812e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall if (!ArgRef.isNull()) 28138a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Arg = ArgRef->getPointeeType(); 28148a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 2815e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall if (QualifierComparisons && !ParamRef.isNull() && !ArgRef.isNull()) { 28168a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p6: 28178a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If both P and A were reference types (before being replaced with the 28188a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // type referred to above), determine which of the two types (if any) is 28198a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // more cv-qualified than the other; otherwise the types are considered to 28208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // be equally cv-qualified for partial ordering purposes. The result of this 28218a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // determination will be used below. 28228a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // 28238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // We save this information for later, using it only when deduction 28248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // succeeds in both directions. 28258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor DeductionQualifierComparison QualifierResult = NeitherMoreQualified; 28268a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Param.isMoreQualifiedThan(Arg)) 28278a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor QualifierResult = ParamMoreQualified; 28288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor else if (Arg.isMoreQualifiedThan(Param)) 28298a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor QualifierResult = ArgMoreQualified; 28308a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor QualifierComparisons->push_back(QualifierResult); 28318a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 28328a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 28338a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p7: 28348a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // Remove any top-level cv-qualifiers: 28358a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - If P is a cv-qualified type, P is replaced by the cv-unqualified 28368a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // version of P. 28378a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Param = Param.getUnqualifiedType(); 28388a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - If A is a cv-qualified type, A is replaced by the cv-unqualified 28398a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // version of A. 28408a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Arg = Arg.getUnqualifiedType(); 28418a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 28428a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p8: 28438a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // Using the resulting types P and A the deduction is then done as 28448a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // described in 14.9.2.5. If deduction succeeds for a given type, the type 28458a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // from the argument template is considered to be at least as specialized 28468a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // as the type from the parameter template. 2847a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, Param, Arg, Info, 28488a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced, TDF_None); 28498a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor} 28508a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 28518a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic void 2852e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, QualType T, 2853e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 2854ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Level, 2855e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced); 285677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 285777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor/// \brief If this is a non-static member function, 285877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregorstatic void MaybeAddImplicitObjectParameterType(ASTContext &Context, 285977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor CXXMethodDecl *Method, 286077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor llvm::SmallVectorImpl<QualType> &ArgTypes) { 286177bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor if (Method->isStatic()) 286277bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor return; 286377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 286477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // C++ [over.match.funcs]p4: 286577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // 286677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // For non-static member functions, the type of the implicit 286777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // object parameter is 286877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // — "lvalue reference to cv X" for functions declared without a 286977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // ref-qualifier or with the & ref-qualifier 287077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // - "rvalue reference to cv X" for functions declared with the 287177bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // && ref-qualifier 287277bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // 287377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // FIXME: We don't have ref-qualifiers yet, so we don't do that part. 287477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor QualType ArgTy = Context.getTypeDeclType(Method->getParent()); 287577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTy = Context.getQualifiedType(ArgTy, 287677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Qualifiers::fromCVRMask(Method->getTypeQualifiers())); 287777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTy = Context.getLValueReferenceType(ArgTy); 287877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTypes.push_back(ArgTy); 287977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor} 288077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 28818a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \brief Determine whether the function template \p FT1 is at least as 28828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// specialized as \p FT2. 28838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic bool isAtLeastAsSpecializedAs(Sema &S, 28845769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 28858a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT1, 28868a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT2, 28878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplatePartialOrderingContext TPOC, 28888a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor llvm::SmallVectorImpl<DeductionQualifierComparison> *QualifierComparisons) { 28898a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionDecl *FD1 = FT1->getTemplatedDecl(); 28908a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionDecl *FD2 = FT2->getTemplatedDecl(); 28918a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>(); 28928a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>(); 28938a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 28948a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(Proto1 && Proto2 && "Function templates must have prototypes"); 28958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); 289602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 28978a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced.resize(TemplateParams->size()); 28988a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 28998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p3: 29008a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // The types used to determine the ordering depend on the context in which 29018a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // the partial ordering is done: 29022a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(S.Context, Loc); 29038d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method1 = 0; 29048d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method2 = 0; 29058d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic2 = false; 29068d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic1 = false; 29078d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor unsigned Skip2 = 0; 29088a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 29098a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 29108a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a function call, the function parameter types are 29118a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used. 29128d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method1 = dyn_cast<CXXMethodDecl>(FD1); 29138d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method2 = dyn_cast<CXXMethodDecl>(FD2); 29148d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic1 = Method1 && !Method1->isStatic(); 29158d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic2 = Method2 && !Method2->isStatic(); 29168d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor 29178d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // C++0x [temp.func.order]p3: 29188d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // [...] If only one of the function templates is a non-static 29198d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // member, that function template is considered to have a new 29208d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // first parameter inserted in its function parameter list. The 29218d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // new parameter is of type "reference to cv A," where cv are 29228d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the cv-qualifiers of the function template (if any) and A is 29238d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the class of which the function template is a member. 29248d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // 29258d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // C++98/03 doesn't have this provision, so instead we drop the 29268d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // first argument of the free function or static member, which 29278d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // seems to match existing practice. 292877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor llvm::SmallVector<QualType, 4> Args1; 29298d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor unsigned Skip1 = !S.getLangOptions().CPlusPlus0x && 29308d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic2 && !IsNonStatic1; 29318d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor if (S.getLangOptions().CPlusPlus0x && IsNonStatic1 && !IsNonStatic2) 293277bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor MaybeAddImplicitObjectParameterType(S.Context, Method1, Args1); 293377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Args1.insert(Args1.end(), 29348d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end()); 293577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 293677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor llvm::SmallVector<QualType, 4> Args2; 29378d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Skip2 = !S.getLangOptions().CPlusPlus0x && 29388d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic1 && !IsNonStatic2; 29398d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor if (S.getLangOptions().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1) 294077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor MaybeAddImplicitObjectParameterType(S.Context, Method2, Args2); 294177bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Args2.insert(Args2.end(), 29428d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end()); 294377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 294477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor unsigned NumParams = std::min(Args1.size(), Args2.size()); 29458a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (unsigned I = 0; I != NumParams; ++I) 2946a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (DeduceTemplateArgumentsDuringPartialOrdering(S, 29478a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplateParams, 294877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Args2[I], 294977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Args1[I], 29508a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Info, 29518a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced, 29528a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor QualifierComparisons)) 29538a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 29548a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29558a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 29568a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 29578a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29588a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 29598a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a call to a conversion operator, the return types 29608a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // of the conversion function templates are used. 2961a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (DeduceTemplateArgumentsDuringPartialOrdering(S, 29628a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplateParams, 29638a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Proto2->getResultType(), 29648a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Proto1->getResultType(), 29658a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Info, 29668a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced, 29678a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor QualifierComparisons)) 29688a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 29698a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 29708a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29718a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 29728a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In other contexts (14.6.6.2) the function template’s function type 29738a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // is used. 2974a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (DeduceTemplateArgumentsDuringPartialOrdering(S, 29758a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplateParams, 29768a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FD2->getType(), 29778a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FD1->getType(), 29788a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Info, 29798a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced, 29808a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor QualifierComparisons)) 29818a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 29828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 29838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 29848a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29858a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p11: 29868a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // In most cases, all template parameters must have values in order for 29878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // deduction to succeed, but for partial ordering purposes a template 29888a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // parameter may remain without a value provided it is not used in the 29898a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // types being used for partial ordering. [ Note: a template parameter used 29908a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // in a non-deduced context is considered used. -end note] 29918a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor unsigned ArgIdx = 0, NumArgs = Deduced.size(); 29928a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 29938a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull()) 29948a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 29958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29968a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (ArgIdx == NumArgs) { 29978a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // All template arguments were deduced. FT1 is at least as specialized 29988a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // as FT2. 29998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 30008a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 30018a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 3002e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // Figure out which template parameters were used. 30038a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor llvm::SmallVector<bool, 4> UsedParameters; 30048a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor UsedParameters.resize(TemplateParams->size()); 30058a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 30068a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 30078a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor unsigned NumParams = std::min(Proto1->getNumArgs(), Proto2->getNumArgs()); 30088d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor if (S.getLangOptions().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1) 30098d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor ::MarkUsedTemplateParameters(S, Method2->getThisType(S.Context), false, 30108d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor TemplateParams->getDepth(), UsedParameters); 30118d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor for (unsigned I = Skip2; I < NumParams; ++I) 3012ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor ::MarkUsedTemplateParameters(S, Proto2->getArgType(I), false, 3013ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3014e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 30158a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30168a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 30178a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30188a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 3019ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor ::MarkUsedTemplateParameters(S, Proto2->getResultType(), false, 3020ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3021e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 30228a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 3025ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor ::MarkUsedTemplateParameters(S, FD2->getType(), false, 3026ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3027ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor UsedParameters); 30288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30298a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 30308a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30318a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 30328a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If this argument had no value deduced but was used in one of the types 30338a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used for partial ordering, then deduction fails. 30348a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) 30358a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 30368a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30378a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 30388a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor} 30398a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30408a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 3041bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized function template according 304265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// to the rules of function template partial ordering (C++ [temp.func.order]). 304365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 304465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT1 the first function template 304565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 304665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT2 the second function template 304765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 30488a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param TPOC the context in which we are performing partial ordering of 30498a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// function templates. 30501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 3051bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized function template. If neither 305265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// template is more specialized, returns NULL. 305365ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorFunctionTemplateDecl * 305465ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, 305565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionTemplateDecl *FT2, 30565769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 30578a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplatePartialOrderingContext TPOC) { 30588a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor llvm::SmallVector<DeductionQualifierComparison, 4> QualifierComparisons; 30595769d6195087229770d7ac90449443e026c47103John McCall bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, 0); 30605769d6195087229770d7ac90449443e026c47103John McCall bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, 30618a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor &QualifierComparisons); 30628a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30638a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better1 != Better2) // We have a clear winner 30648a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return Better1? FT1 : FT2; 30658a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30668a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (!Better1 && !Better2) // Neither is better than the other 306765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return 0; 30688a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30698a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30708a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p10: 30718a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If for each type being considered a given template is at least as 30728a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized for all types and more specialized for some set of types and 30738a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // the other template is not more specialized for any types or is not at 30748a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // least as specialized for any types, then the given template is more 30758a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other template. Otherwise, neither template is more 30768a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other. 30778a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better1 = false; 30788a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better2 = false; 30798a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (unsigned I = 0, N = QualifierComparisons.size(); I != N; ++I) { 30808a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p9: 30818a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If, for a given type, deduction succeeds in both directions (i.e., the 30828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // types are identical after the transformations above) and if the type 30838a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // from the argument template is more cv-qualified than the type from the 30848a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // parameter template (as described above) that type is considered to be 30858a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // more specialized than the other. If neither type is more cv-qualified 30868a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // than the other then neither type is more specialized than the other. 30878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (QualifierComparisons[I]) { 30888a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case NeitherMoreQualified: 30898a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30908a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30918a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case ParamMoreQualified: 30928a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better1 = true; 30938a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better2) 30948a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return 0; 30958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30968a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30978a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case ArgMoreQualified: 30988a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better2 = true; 30998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better1) 31008a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return 0; 31018a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 31028a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 31038a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 31048a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 31058a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(!(Better1 && Better2) && "Should have broken out in the loop above"); 310665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (Better1) 310765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return FT1; 31088a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor else if (Better2) 31098a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return FT2; 31108a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor else 31118a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return 0; 311265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 311383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 3114d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Determine if the two templates are equivalent. 3115d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregorstatic bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { 3116d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (T1 == T2) 3117d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return true; 3118d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3119d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!T1 || !T2) 3120d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return false; 3121d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3122d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return T1->getCanonicalDecl() == T2->getCanonicalDecl(); 3123d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 3124d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3125d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Retrieve the most specialized of the given function template 3126d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specializations. 3127d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3128c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecBegin the start iterator of the function template 3129c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations that we will be comparing. 3130d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3131c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecEnd the end iterator of the function template 3132c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations, paired with \p SpecBegin. 3133d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3134d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param TPOC the partial ordering context to use to compare the function 3135d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template specializations. 3136d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3137d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param Loc the location where the ambiguity or no-specializations 3138d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// diagnostic should occur. 3139d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3140d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param NoneDiag partial diagnostic used to diagnose cases where there are 3141d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// no matching candidates. 3142d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3143d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one 3144d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// occurs. 3145d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3146d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param CandidateDiag partial diagnostic used for each function template 3147d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specialization that is a candidate in the ambiguous ordering. One parameter 3148d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// in this diagnostic should be unbound, which will correspond to the string 3149d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// describing the template arguments for the function template specialization. 3150d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3151d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param Index if non-NULL and the result of this function is non-nULL, 3152d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// receives the index corresponding to the resulting function template 3153d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specialization. 3154d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3155d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \returns the most specialized function template specialization, if 3156c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// found. Otherwise, returns SpecEnd. 3157d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3158d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \todo FIXME: Consider passing in the "also-ran" candidates that failed 3159d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template argument deduction. 3160c373d48502ca7683ab55385f5bd624d778eb288dJohn McCallUnresolvedSetIterator 3161c373d48502ca7683ab55385f5bd624d778eb288dJohn McCallSema::getMostSpecialized(UnresolvedSetIterator SpecBegin, 3162c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall UnresolvedSetIterator SpecEnd, 3163c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall TemplatePartialOrderingContext TPOC, 3164c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall SourceLocation Loc, 3165c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &NoneDiag, 3166c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &AmbigDiag, 3167c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &CandidateDiag) { 3168c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (SpecBegin == SpecEnd) { 3169d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Diag(Loc, NoneDiag); 3170c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 3171d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3172d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3173c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (SpecBegin + 1 == SpecEnd) 3174c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecBegin; 3175d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3176d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Find the function template that is better than all of the templates it 3177d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // has been compared to. 3178c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall UnresolvedSetIterator Best = SpecBegin; 3179d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor FunctionTemplateDecl *BestTemplate 3180c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*Best)->getPrimaryTemplate(); 3181d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(BestTemplate && "Not a function template specialization?"); 3182c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) { 3183c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 3184c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 3185d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(Challenger && "Not a function template specialization?"); 3186c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 31875769d6195087229770d7ac90449443e026c47103John McCall Loc, TPOC), 3188d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Challenger)) { 3189d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Best = I; 3190d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate = Challenger; 3191d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3192d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3193d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3194d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Make sure that the "best" function template is more specialized than all 3195d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // of the others. 3196d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor bool Ambiguous = false; 3197c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { 3198c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 3199c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 3200d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (I != Best && 3201d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 32025769d6195087229770d7ac90449443e026c47103John McCall Loc, TPOC), 3203d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate)) { 3204d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Ambiguous = true; 3205d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor break; 3206d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3207d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3208d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3209d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!Ambiguous) { 3210d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // We found an answer. Return it. 3211c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return Best; 3212d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3213d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3214d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Diagnose the ambiguity. 3215d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Diag(Loc, AmbigDiag); 3216d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3217d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // FIXME: Can we order the candidates in some sane way? 3218c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) 3219c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall Diag((*I)->getLocation(), CandidateDiag) 3220d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor << getTemplateArgumentBindingsText( 3221c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(), 3222c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs()); 3223d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3224c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 3225d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 3226d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3227bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized class template partial specialization 3228bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// according to the rules of partial ordering of class template partial 3229bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// specializations (C++ [temp.class.order]). 3230bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 3231bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS1 the first class template partial specialization 3232bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 3233bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS2 the second class template partial specialization 3234bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 3235bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized class template partial specialization. If 3236bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// neither partial specialization is more specialized, returns NULL. 3237bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorClassTemplatePartialSpecializationDecl * 3238bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorSema::getMoreSpecializedPartialSpecialization( 3239bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor ClassTemplatePartialSpecializationDecl *PS1, 32405769d6195087229770d7ac90449443e026c47103John McCall ClassTemplatePartialSpecializationDecl *PS2, 32415769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc) { 3242bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // C++ [temp.class.order]p1: 3243bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // For two class template partial specializations, the first is at least as 3244bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // specialized as the second if, given the following rewrite to two 3245bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // function templates, the first function template is at least as 3246bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // specialized as the second according to the ordering rules for function 3247bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // templates (14.6.6.2): 3248bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the first function template has the same template parameters as the 3249bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // first partial specialization and has a single function parameter 3250bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // whose type is a class template specialization with the template 3251bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the first partial specialization, and 3252bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the second function template has the same template parameters as the 3253bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // second partial specialization and has a single function parameter 3254bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // whose type is a class template specialization with the template 3255bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the second partial specialization. 3256bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // 325731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // Rather than synthesize function templates, we merely perform the 325831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // equivalent partial ordering by performing deduction directly on 325931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // the template arguments of the class template partial 326031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specializations. This computation is slightly simpler than the 326131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // general problem of function template partial ordering, because 326231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // class template partial specializations are more constrained. We 326331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // know that every template parameter is deducible from the class 326431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // template partial specialization's template arguments, for 326531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // example. 326602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 32672a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(Context, Loc); 326831f17ecbef57b5679c017c375db330546b7b5145John McCall 326931f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT1 = PS1->getInjectedSpecializationType(); 327031f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT2 = PS2->getInjectedSpecializationType(); 3271bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 3272bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS1 is at least as specialized as PS2 3273bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS2->getTemplateParameters()->size()); 3274a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth bool Better1 = !DeduceTemplateArgumentsDuringPartialOrdering(*this, 3275bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor PS2->getTemplateParameters(), 327631f17ecbef57b5679c017c375db330546b7b5145John McCall PT2, 327731f17ecbef57b5679c017c375db330546b7b5145John McCall PT1, 3278bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Info, 3279bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced, 3280bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 0); 32812c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better1) { 32822c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, 32832c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis Deduced.data(), Deduced.size(), Info); 3284516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, 3285516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor PS1->getTemplateArgs(), 3286516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 32872c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 3288516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor 3289bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS2 is at least as specialized as PS1 3290db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Deduced.clear(); 3291bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS1->getTemplateParameters()->size()); 3292a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth bool Better2 = !DeduceTemplateArgumentsDuringPartialOrdering(*this, 3293bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor PS1->getTemplateParameters(), 329431f17ecbef57b5679c017c375db330546b7b5145John McCall PT1, 329531f17ecbef57b5679c017c375db330546b7b5145John McCall PT2, 3296bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Info, 3297bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced, 3298bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 0); 32992c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better2) { 33002c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, 33012c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis Deduced.data(), Deduced.size(), Info); 3302516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, 3303516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor PS2->getTemplateArgs(), 3304516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 33052c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 3306bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 3307bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor if (Better1 == Better2) 3308bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return 0; 3309bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 3310bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return Better1? PS1 : PS2; 3311bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor} 3312bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 33131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 3314e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3315e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 3316e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3317ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3318e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used); 3319031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3320e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 3321031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// expression. 33221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 3323e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3324e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const Expr *E, 3325e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3326ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3327e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3328be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor // We can deduce from a pack expansion. 3329be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E)) 3330be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor E = Expansion->getPattern(); 3331be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor 333254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Skip through any implicit casts we added while type-checking. 333354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 333454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor E = ICE->getSubExpr(); 333554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 3336e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to 3337e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // find other occurrences of template parameters. 3338f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 3339c781f9cd854f3d5d1c826f4a13382c6abca4cff7Douglas Gregor if (!DRE) 3340031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 3341031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 33421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const NonTypeTemplateParmDecl *NTTP 3343031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 3344031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!NTTP) 3345031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 3346031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3347ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (NTTP->getDepth() == Depth) 3348ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[NTTP->getIndex()] = true; 3349031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 3350031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3351e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 3352e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// nested name specifier. 3353e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 3354e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3355e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor NestedNameSpecifier *NNS, 3356e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3357ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3358e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3359e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!NNS) 3360e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 3361e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3362ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor MarkUsedTemplateParameters(SemaRef, NNS->getPrefix(), OnlyDeduced, Depth, 3363ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 3364e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, QualType(NNS->getAsType(), 0), 3365ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3366e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 3367e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3368e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 3369e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// template name. 3370e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 3371e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3372e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor TemplateName Name, 3373e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3374ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3375e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3376e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 3377e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateTemplateParmDecl *TTP 3378ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(Template)) { 3379ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 3380ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 3381ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 3382e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 3383e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 3384e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3385788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) 3386788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor MarkUsedTemplateParameters(SemaRef, QTN->getQualifier(), OnlyDeduced, 3387788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Depth, Used); 3388e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) 3389ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor MarkUsedTemplateParameters(SemaRef, DTN->getQualifier(), OnlyDeduced, 3390ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3391e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 3392e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3393e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 3394031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// type. 33951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 3396e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, QualType T, 3397e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3398ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3399e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3400e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (T.isNull()) 3401e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 3402e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3403031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Non-dependent types have nothing deducible 3404031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!T->isDependentType()) 3405031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 3406031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3407031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor T = SemaRef.Context.getCanonicalType(T); 3408031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (T->getTypeClass()) { 3409031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Pointer: 3410e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3411e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<PointerType>(T)->getPointeeType(), 3412e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 3413ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 3414e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 3415031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3416031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3417031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::BlockPointer: 3418e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3419e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<BlockPointerType>(T)->getPointeeType(), 3420e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 3421ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 3422e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 3423031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3424031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3425031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::LValueReference: 3426031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::RValueReference: 3427e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3428e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ReferenceType>(T)->getPointeeType(), 3429e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 3430ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 3431e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 3432031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3433031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3434031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::MemberPointer: { 3435031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr()); 3436e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, MemPtr->getPointeeType(), OnlyDeduced, 3437ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3438e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, QualType(MemPtr->getClass(), 0), 3439ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3440031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3441031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 3442031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3443031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::DependentSizedArray: 3444e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3445e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<DependentSizedArrayType>(T)->getSizeExpr(), 3446ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3447031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Fall through to check the element type 3448031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3449031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ConstantArray: 3450031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::IncompleteArray: 3451e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3452e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ArrayType>(T)->getElementType(), 3453ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3454031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3455031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3456031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Vector: 3457031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ExtVector: 3458e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3459e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<VectorType>(T)->getElementType(), 3460ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3461031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3462031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 34639cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor case Type::DependentSizedExtVector: { 34649cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor const DependentSizedExtVectorType *VecType 3465f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<DependentSizedExtVectorType>(T); 3466e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, VecType->getElementType(), OnlyDeduced, 3467ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3468e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, VecType->getSizeExpr(), OnlyDeduced, 3469ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 34709cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor break; 34719cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 34729cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 3473031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionProto: { 3474f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 3475e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, Proto->getResultType(), OnlyDeduced, 3476ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3477031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I) 3478e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, Proto->getArgType(I), OnlyDeduced, 3479ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3480031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3481031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 3482031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3483ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor case Type::TemplateTypeParm: { 3484ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T); 3485ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 3486ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 3487031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3488ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 3489031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 349031f17ecbef57b5679c017c375db330546b7b5145John McCall case Type::InjectedClassName: 349131f17ecbef57b5679c017c375db330546b7b5145John McCall T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType(); 349231f17ecbef57b5679c017c375db330546b7b5145John McCall // fall through 349331f17ecbef57b5679c017c375db330546b7b5145John McCall 3494031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::TemplateSpecialization: { 34951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const TemplateSpecializationType *Spec 3496f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<TemplateSpecializationType>(T); 3497e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, Spec->getTemplateName(), OnlyDeduced, 3498ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 34997b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 35007b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 35017b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // If the template argument list of P contains a pack expansion that is not 35027b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // the last template argument, the entire template argument list is a 35037b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 35047b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (OnlyDeduced && 35057b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 35067b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 35077b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 3508e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 3509ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth, 3510ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 3511e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 3512e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 35131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3514e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor case Type::Complex: 3515e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 3516e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3517e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ComplexType>(T)->getElementType(), 3518ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3519e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 3520031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 35214714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 3522e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 3523e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 35244714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor cast<DependentNameType>(T)->getQualifier(), 3525ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3526031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3527031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 352833500955d731c73717af52088b7fc0e7a85681e7John McCall case Type::DependentTemplateSpecialization: { 352933500955d731c73717af52088b7fc0e7a85681e7John McCall const DependentTemplateSpecializationType *Spec 353033500955d731c73717af52088b7fc0e7a85681e7John McCall = cast<DependentTemplateSpecializationType>(T); 353133500955d731c73717af52088b7fc0e7a85681e7John McCall if (!OnlyDeduced) 353233500955d731c73717af52088b7fc0e7a85681e7John McCall MarkUsedTemplateParameters(SemaRef, Spec->getQualifier(), 353333500955d731c73717af52088b7fc0e7a85681e7John McCall OnlyDeduced, Depth, Used); 35347b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 35357b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 35367b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // If the template argument list of P contains a pack expansion that is not 35377b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // the last template argument, the entire template argument list is a 35387b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 35397b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (OnlyDeduced && 35407b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 35417b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 35427b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 354333500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 354433500955d731c73717af52088b7fc0e7a85681e7John McCall MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth, 354533500955d731c73717af52088b7fc0e7a85681e7John McCall Used); 354633500955d731c73717af52088b7fc0e7a85681e7John McCall break; 354733500955d731c73717af52088b7fc0e7a85681e7John McCall } 354833500955d731c73717af52088b7fc0e7a85681e7John McCall 3549ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOf: 3550ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 3551ad5e73887052193afda72db8efcb812bd083a4a8John McCall MarkUsedTemplateParameters(SemaRef, 3552ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfType>(T)->getUnderlyingType(), 3553ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 3554ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 3555ad5e73887052193afda72db8efcb812bd083a4a8John McCall 3556ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOfExpr: 3557ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 3558ad5e73887052193afda72db8efcb812bd083a4a8John McCall MarkUsedTemplateParameters(SemaRef, 3559ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfExprType>(T)->getUnderlyingExpr(), 3560ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 3561ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 3562ad5e73887052193afda72db8efcb812bd083a4a8John McCall 3563ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::Decltype: 3564ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 3565ad5e73887052193afda72db8efcb812bd083a4a8John McCall MarkUsedTemplateParameters(SemaRef, 3566ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<DecltypeType>(T)->getUnderlyingExpr(), 3567ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 3568ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 3569ad5e73887052193afda72db8efcb812bd083a4a8John McCall 35707536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor case Type::PackExpansion: 35717536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor MarkUsedTemplateParameters(SemaRef, 35727536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor cast<PackExpansionType>(T)->getPattern(), 35737536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor OnlyDeduced, Depth, Used); 35747536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor break; 35757536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 3576e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // None of these types have any template parameters in them. 3577031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Builtin: 3578031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::VariableArray: 3579031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionNoProto: 3580031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Record: 3581031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Enum: 3582031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ObjCInterface: 3583c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 3584d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 3585ed97649e9574b9d854fa4d6109c9333ae0993554John McCall case Type::UnresolvedUsing: 3586031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define TYPE(Class, Base) 3587031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 3588031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define DEPENDENT_TYPE(Class, Base) 3589031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 3590031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#include "clang/AST/TypeNodes.def" 3591031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3592031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 3593031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 3594031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3595e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by this 3596031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument. 35971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 3598e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3599e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 3600e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3601ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3602e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3603031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (TemplateArg.getKind()) { 3604031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Null: 3605031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Integral: 3606788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Declaration: 3607031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 36081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3609031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Type: 3610e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsType(), OnlyDeduced, 3611ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3612031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3613031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3614788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 3615a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 3616a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3617a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor TemplateArg.getAsTemplateOrTemplatePattern(), 3618788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor OnlyDeduced, Depth, Used); 3619031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3620031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3621031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Expression: 3622e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsExpr(), OnlyDeduced, 3623ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3624031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3625e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3626d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 3627e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(), 3628e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor PEnd = TemplateArg.pack_end(); 3629e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor P != PEnd; ++P) 3630ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor MarkUsedTemplateParameters(SemaRef, *P, OnlyDeduced, Depth, Used); 3631d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson break; 3632031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 3633031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 3634031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3635031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \brief Mark the template parameters can be deduced by the given 3636031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument list. 3637031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 3638031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param TemplateArgs the template argument list from which template 3639031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// parameters will be deduced. 3640031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 3641031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param Deduced a bit vector whose elements will be set to \c true 3642031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// to indicate when the corresponding template parameter will be 3643031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// deduced. 36441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 3645e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorSema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, 3646ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor bool OnlyDeduced, unsigned Depth, 3647e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 36487b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 36497b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // If the template argument list of P contains a pack expansion that is not 36507b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // the last template argument, the entire template argument list is a 36517b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 36527b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (OnlyDeduced && 36537b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size())) 36547b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return; 36557b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 3656031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 3657ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor ::MarkUsedTemplateParameters(*this, TemplateArgs[I], OnlyDeduced, 3658ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3659031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 366063f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor 366163f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// \brief Marks all of the template parameters that will be deduced by a 366263f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// call to the given function template. 366302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregorvoid 366402024a9f0d8e6c898de276193af604c42ee41269Douglas GregorSema::MarkDeducedTemplateParameters(FunctionTemplateDecl *FunctionTemplate, 366502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced) { 366663f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor TemplateParameterList *TemplateParams 366763f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor = FunctionTemplate->getTemplateParameters(); 366863f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.clear(); 366963f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.resize(TemplateParams->size()); 367063f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor 367163f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 367263f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 367363f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor ::MarkUsedTemplateParameters(*this, Function->getParamDecl(I)->getType(), 3674ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor true, TemplateParams->getDepth(), Deduced); 367563f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor} 3676