SemaTemplateDeduction.cpp revision 83314aa1cf61ed2458a8a20c83b2d4708192d5dc
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 130b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "Sema.h" 140b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ASTContext.h" 150b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/DeclTemplate.h" 160b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/StmtVisitor.h" 170b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/Expr.h" 180b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ExprCXX.h" 190b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/Parse/DeclSpec.h" 200b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "llvm/Support/Compiler.h" 21508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 22508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregornamespace clang { 23508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Various flags that control template argument deduction. 24508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// 25508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// These flags can be bitwise-OR'd together. 26508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor enum TemplateDeductionFlags { 27508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief No template argument deduction flags, which indicates the 28508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// strictest results for template argument deduction (as used for, e.g., 29508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// matching class template partial specializations). 30508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_None = 0, 31508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, we are 32508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// matching with a parameter type for which the original parameter was 33508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// a reference. 34508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_ParamWithReferenceType = 0x1, 35508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, we 36508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// are matching in a case where we ignore cv-qualifiers. 37508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_IgnoreQualifiers = 0x02, 38508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, 39508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// we are matching in a case where we can perform template argument 404112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor /// deduction from a template-id of a derived class of the argument type. 41508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_DerivedClass = 0x04 42508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor }; 43508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor} 44508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 450b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregorusing namespace clang; 460b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 47f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 48f67875d5addf36b951ad37fb04509ab2b572c88aDouglas GregorDeduceTemplateArguments(ASTContext &Context, 49f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 50f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 51d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor const TemplateArgument &Arg, 52f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Sema::TemplateDeductionInfo &Info, 53d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced); 54d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 55199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \brief If the given expression is of a form that permits the deduction 56199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// of a non-type template parameter, return the declaration of that 57199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// non-type template parameter. 58199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregorstatic NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { 59199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E)) 60199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor E = IC->getSubExpr(); 61199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 62199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 63199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 64199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 65199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return 0; 66199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 67199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 68199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \brief Deduce the value of the given non-type template parameter 69199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given constant. 70f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 71f67875d5addf36b951ad37fb04509ab2b572c88aDouglas GregorDeduceNonTypeTemplateArgument(ASTContext &Context, 72f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor NonTypeTemplateParmDecl *NTTP, 73335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson llvm::APSInt Value, 74f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Sema::TemplateDeductionInfo &Info, 75f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced) { 76199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(NTTP->getDepth() == 0 && 77199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 78199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 79199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Deduced[NTTP->getIndex()].isNull()) { 8025af1ed6ffa46a333886264299be98a838097b34Anders Carlsson QualType T = NTTP->getType(); 8125af1ed6ffa46a333886264299be98a838097b34Anders Carlsson 8225af1ed6ffa46a333886264299be98a838097b34Anders Carlsson // FIXME: Make sure we didn't overflow our data type! 8325af1ed6ffa46a333886264299be98a838097b34Anders Carlsson unsigned AllowedBits = Context.getTypeSize(T); 8425af1ed6ffa46a333886264299be98a838097b34Anders Carlsson if (Value.getBitWidth() != AllowedBits) 8525af1ed6ffa46a333886264299be98a838097b34Anders Carlsson Value.extOrTrunc(AllowedBits); 8625af1ed6ffa46a333886264299be98a838097b34Anders Carlsson Value.setIsSigned(T->isSignedIntegerType()); 8725af1ed6ffa46a333886264299be98a838097b34Anders Carlsson 8825af1ed6ffa46a333886264299be98a838097b34Anders Carlsson Deduced[NTTP->getIndex()] = TemplateArgument(SourceLocation(), Value, T); 89f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 90199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 91199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 92f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor assert(Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Integral); 93199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 94199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // If the template argument was previously deduced to a negative value, 95199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // then our deduction fails. 96199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor const llvm::APSInt *PrevValuePtr = Deduced[NTTP->getIndex()].getAsIntegral(); 97335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson if (PrevValuePtr->isNegative()) { 98f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = NTTP; 99f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 100335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson Info.SecondArg = TemplateArgument(SourceLocation(), Value, NTTP->getType()); 101f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Inconsistent; 102f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 103f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 104335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson llvm::APSInt PrevValue = *PrevValuePtr; 105199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Value.getBitWidth() > PrevValue.getBitWidth()) 106199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor PrevValue.zext(Value.getBitWidth()); 107199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor else if (Value.getBitWidth() < PrevValue.getBitWidth()) 108199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor Value.zext(PrevValue.getBitWidth()); 109f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 110f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Value != PrevValue) { 111f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = NTTP; 112f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 113335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson Info.SecondArg = TemplateArgument(SourceLocation(), Value, NTTP->getType()); 114f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Inconsistent; 115f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 116f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 117f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 118199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 119199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 120199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \brief Deduce the value of the given non-type template parameter 121199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given type- or value-dependent expression. 122199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// 123199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \returns true if deduction succeeded, false otherwise. 124199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 125f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 126f67875d5addf36b951ad37fb04509ab2b572c88aDouglas GregorDeduceNonTypeTemplateArgument(ASTContext &Context, 127f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor NonTypeTemplateParmDecl *NTTP, 128f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Expr *Value, 129f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Sema::TemplateDeductionInfo &Info, 130f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced) { 131199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(NTTP->getDepth() == 0 && 132199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 133199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert((Value->isTypeDependent() || Value->isValueDependent()) && 134199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Expression template argument must be type- or value-dependent."); 135199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 136199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Deduced[NTTP->getIndex()].isNull()) { 137199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // FIXME: Clone the Value? 138199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor Deduced[NTTP->getIndex()] = TemplateArgument(Value); 139f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 140199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 141199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 142199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Integral) { 143199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Okay, we deduced a constant in one case and a dependent expression 144199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // in another case. FIXME: Later, we will check that instantiating the 145199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // dependent expression gives us the constant value. 146f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 147199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 148199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 149199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // FIXME: Compare the expressions for equality! 150f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 151199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 152199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 153f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 154f67875d5addf36b951ad37fb04509ab2b572c88aDouglas GregorDeduceTemplateArguments(ASTContext &Context, 155f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Param, 156f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Arg, 157f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Sema::TemplateDeductionInfo &Info, 158f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced) { 159d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // FIXME: Implement template argument deduction for template 160d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // template parameters. 161d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 162f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // FIXME: this routine does not have enough information to produce 163f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // good diagnostics. 164f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 165d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); 166d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor TemplateDecl *ArgDecl = Arg.getAsTemplateDecl(); 167d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 168f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (!ParamDecl || !ArgDecl) { 169f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // FIXME: fill in Info.Param/Info.FirstArg 170f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Inconsistent; 171f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 172d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 173d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor ParamDecl = cast<TemplateDecl>(Context.getCanonicalDecl(ParamDecl)); 174d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor ArgDecl = cast<TemplateDecl>(Context.getCanonicalDecl(ArgDecl)); 175f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (ParamDecl != ArgDecl) { 176f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // FIXME: fill in Info.Param/Info.FirstArg 177f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Inconsistent; 178f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 179f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 180f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 181d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor} 182d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 183de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \brief Deduce the template arguments by comparing the template parameter 184de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// type (which is a template-id) with the template argument type. 185de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 186de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Context the AST context in which this deduction occurs. 187de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 188de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param TemplateParams the template parameters that we are deducing 189de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 190de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Param the parameter type 191de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 192de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Arg the argument type 193de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 194de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Info information about the template argument deduction itself 195de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 196de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Deduced the deduced template arguments 197de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 198de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 199de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 200de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// but it may still fail, later, for other reasons. 201de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregorstatic Sema::TemplateDeductionResult 202de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas GregorDeduceTemplateArguments(ASTContext &Context, 203de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateParameterList *TemplateParams, 204de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const TemplateSpecializationType *Param, 205de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType Arg, 206de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionInfo &Info, 207de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced) { 208de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor assert(Arg->isCanonical() && "Argument type must be canonical"); 209de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 210de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Check whether the template argument is a dependent template-id. 211de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // FIXME: This is untested code; it can be tested when we implement 212de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // partial ordering of class template partial specializations. 213de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (const TemplateSpecializationType *SpecArg 214de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<TemplateSpecializationType>(Arg)) { 215de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 216de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 217de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = DeduceTemplateArguments(Context, 218de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 219de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor SpecArg->getTemplateName(), 220de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 221de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 222de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 223de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor unsigned NumArgs = Param->getNumArgs(); 224de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 225de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // FIXME: When one of the template-names refers to a 226de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // declaration with default template arguments, do we need to 227de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // fill in those default template arguments here? Most likely, 228de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // the answer is "yes", but I don't see any references. This 229de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // issue may be resolved elsewhere, because we may want to 230de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // instantiate default template arguments when we actually write 231de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // the template-id. 232de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (SpecArg->getNumArgs() != NumArgs) 233de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 234de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 235de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction on each template 236de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // argument. 237de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor for (unsigned I = 0; I != NumArgs; ++I) 238de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 239de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = DeduceTemplateArguments(Context, TemplateParams, 240de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getArg(I), 241de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor SpecArg->getArg(I), 242de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 243de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 244de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 245de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_Success; 246de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 247de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 248de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If the argument type is a class template specialization, we 249de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // perform template argument deduction using its template 250de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // arguments. 251de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *RecordArg = dyn_cast<RecordType>(Arg); 252de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!RecordArg) 253de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 254de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 255de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ClassTemplateSpecializationDecl *SpecArg 256de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl()); 257de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!SpecArg) 258de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 259de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 260de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 261de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 262de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = DeduceTemplateArguments(Context, 263de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 264de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateName(SpecArg->getSpecializedTemplate()), 265de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 266de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 267de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 268de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // FIXME: Can the # of arguments in the parameter and the argument 269de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // differ due to default arguments? 270de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor unsigned NumArgs = Param->getNumArgs(); 271de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const TemplateArgumentList &ArgArgs = SpecArg->getTemplateArgs(); 272de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (NumArgs != ArgArgs.size()) 273de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 274de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 275de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor for (unsigned I = 0; I != NumArgs; ++I) 276de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 277de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = DeduceTemplateArguments(Context, TemplateParams, 278de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getArg(I), 279de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ArgArgs.get(I), 280de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 281de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 282de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 283de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_Success; 284de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor} 285de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 286500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \brief Deduce the template arguments by comparing the parameter type and 287500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// the argument type (C++ [temp.deduct.type]). 288500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 289500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Context the AST context in which this deduction occurs. 290500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 291500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param TemplateParams the template parameters that we are deducing 292500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 293500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ParamIn the parameter type 294500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 295500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ArgIn the argument type 296500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 297500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Info information about the template argument deduction itself 298500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 299500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Deduced the deduced template arguments 300500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 301508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 302508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor/// how template argument deduction is performed. 303500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 304500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \returns the result of template argument deduction so far. Note that a 305500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// "success" result means that template argument deduction has not yet failed, 306500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// but it may still fail, later, for other reasons. 307f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 308f67875d5addf36b951ad37fb04509ab2b572c88aDouglas GregorDeduceTemplateArguments(ASTContext &Context, 309f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 310f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType ParamIn, QualType ArgIn, 311f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Sema::TemplateDeductionInfo &Info, 312500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced, 313508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor unsigned TDF) { 3140b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // We only want to look at the canonical types, since typedefs and 3150b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // sugar are not part of template argument deduction. 316f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType Param = Context.getCanonicalType(ParamIn); 317f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType Arg = Context.getCanonicalType(ArgIn); 3180b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 319500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor // C++0x [temp.deduct.call]p4 bullet 1: 320500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor // - If the original P is a reference type, the deduced A (i.e., the type 321500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor // referred to by the reference) can be more cv-qualified than the 322500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor // transformed A. 323508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (TDF & TDF_ParamWithReferenceType) { 324500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor unsigned ExtraQualsOnParam 325500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor = Param.getCVRQualifiers() & ~Arg.getCVRQualifiers(); 326500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor Param.setCVRQualifiers(Param.getCVRQualifiers() & ~ExtraQualsOnParam); 327500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor } 328500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor 329f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // If the parameter type is not dependent, there is nothing to deduce. 330f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!Param->isDependentType()) 331f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Sema::TDK_Success; 3320b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 333199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // C++ [temp.deduct.type]p9: 334199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // A template type argument T, a template template argument TT or a 335199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // template non-type argument i can be deduced if P and A have one of 336199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // the following forms: 337199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // 338199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T 339199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // cv-list T 3400b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor if (const TemplateTypeParmType *TemplateTypeParm 3410b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor = Param->getAsTemplateTypeParmType()) { 342f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor unsigned Index = TemplateTypeParm->getIndex(); 343f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 3440b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // The argument type can not be less qualified than the parameter 3450b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // type. 346508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.isMoreQualifiedThan(Arg) && !(TDF & TDF_IgnoreQualifiers)) { 347f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 348f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[Index]; 349f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = TemplateArgument(SourceLocation(), Arg); 350f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_InconsistentQuals; 351f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 3520b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 3530b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); 3540b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 3550b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor unsigned Quals = Arg.getCVRQualifiers() & ~Param.getCVRQualifiers(); 3560b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor QualType DeducedType = Arg.getQualifiedType(Quals); 3570b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 3580b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor if (Deduced[Index].isNull()) 3590b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor Deduced[Index] = TemplateArgument(SourceLocation(), DeducedType); 3600b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor else { 3610b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // C++ [temp.deduct.type]p2: 3620b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // [...] If type deduction cannot be done for any P/A pair, or if for 3630b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // any pair the deduction leads to more than one possible set of 3640b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // deduced values, or if different pairs yield different deduced 3650b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // values, or if any template argument remains neither deduced nor 3660b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // explicitly specified, template argument deduction fails. 367f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Deduced[Index].getAsType() != DeducedType) { 368f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param 369f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 370f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[Index]; 371f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = TemplateArgument(SourceLocation(), Arg); 372f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Inconsistent; 373f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 3740b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 375f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 3760b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 3770b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 378f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // Set up the template argument deduction information for a failure. 379f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = TemplateArgument(SourceLocation(), ParamIn); 380f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = TemplateArgument(SourceLocation(), ArgIn); 381f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 382508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // Check the cv-qualifiers on the parameter and argument types. 383508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (!(TDF & TDF_IgnoreQualifiers)) { 384508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (TDF & TDF_ParamWithReferenceType) { 385508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.isMoreQualifiedThan(Arg)) 386508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor return Sema::TDK_NonDeducedMismatch; 387508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } else { 388508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) 389508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor return Sema::TDK_NonDeducedMismatch; 390508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 391508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 3920b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 393d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor switch (Param->getTypeClass()) { 394199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // No deduction possible for these types 395199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::Builtin: 396f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 397199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 398199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T * 399d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::Pointer: { 400d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor const PointerType *PointerArg = Arg->getAsPointerType(); 401d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!PointerArg) 402f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 403d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor 4044112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); 405f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return DeduceTemplateArguments(Context, TemplateParams, 406d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<PointerType>(Param)->getPointeeType(), 407d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor PointerArg->getPointeeType(), 4084112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor Info, Deduced, SubTDF); 409d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 410d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor 411199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T & 412d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::LValueReference: { 413d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor const LValueReferenceType *ReferenceArg = Arg->getAsLValueReferenceType(); 414d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 415f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 416d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor 417f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return DeduceTemplateArguments(Context, TemplateParams, 418d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<LValueReferenceType>(Param)->getPointeeType(), 419d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor ReferenceArg->getPointeeType(), 420508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 421d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 4220b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 423199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T && [C++0x] 424d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::RValueReference: { 425d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor const RValueReferenceType *ReferenceArg = Arg->getAsRValueReferenceType(); 426d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 427f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 428d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor 429f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return DeduceTemplateArguments(Context, TemplateParams, 430d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<RValueReferenceType>(Param)->getPointeeType(), 431d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor ReferenceArg->getPointeeType(), 432508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 433d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 434d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor 435199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [] (implied, but not stated explicitly) 4364d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::IncompleteArray: { 4374d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson const IncompleteArrayType *IncompleteArrayArg = 4384d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson Context.getAsIncompleteArrayType(Arg); 4394d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!IncompleteArrayArg) 440f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 4414d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 442f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return DeduceTemplateArguments(Context, TemplateParams, 4434d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson Context.getAsIncompleteArrayType(Param)->getElementType(), 4444d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson IncompleteArrayArg->getElementType(), 445508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 4464d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 447199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 448199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [integer-constant] 4494d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::ConstantArray: { 4504d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson const ConstantArrayType *ConstantArrayArg = 4514d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson Context.getAsConstantArrayType(Arg); 4524d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!ConstantArrayArg) 453f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 4544d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 4554d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson const ConstantArrayType *ConstantArrayParm = 4564d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson Context.getAsConstantArrayType(Param); 4574d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) 458f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 4594d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 460f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return DeduceTemplateArguments(Context, TemplateParams, 4614d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson ConstantArrayParm->getElementType(), 4624d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson ConstantArrayArg->getElementType(), 463508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 4644d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 4654d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 466199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // type [i] 467199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::DependentSizedArray: { 468199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor const ArrayType *ArrayArg = dyn_cast<ArrayType>(Arg); 469199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!ArrayArg) 470f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 471199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 472199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Check the element type of the arrays 473199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor const DependentSizedArrayType *DependentArrayParm 474199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = cast<DependentSizedArrayType>(Param); 475f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 476f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = DeduceTemplateArguments(Context, TemplateParams, 477f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor DependentArrayParm->getElementType(), 478f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor ArrayArg->getElementType(), 479508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0)) 480f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 481199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 482199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Determine the array bound is something we can deduce. 483199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor NonTypeTemplateParmDecl *NTTP 484199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); 485199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!NTTP) 486f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 487199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 488199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // We can perform template argument deduction for the given non-type 489199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // template parameter. 490199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(NTTP->getDepth() == 0 && 491199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument at depth > 0"); 492199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (const ConstantArrayType *ConstantArrayArg 493335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson = dyn_cast<ConstantArrayType>(ArrayArg)) { 494335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson llvm::APSInt Size(ConstantArrayArg->getSize()); 495335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson return DeduceNonTypeTemplateArgument(Context, NTTP, Size, 496f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 497335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson } 498199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (const DependentSizedArrayType *DependentArrayArg 499199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = dyn_cast<DependentSizedArrayType>(ArrayArg)) 500199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return DeduceNonTypeTemplateArgument(Context, NTTP, 501199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor DependentArrayArg->getSizeExpr(), 502f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 503199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 504199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Incomplete type does not match a dependently-sized array type 505f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 506199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 507199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 5080fce0ae7d60bed52e36c87194922b7aecce78b83Douglas Gregor // type(*)(T) 5090fce0ae7d60bed52e36c87194922b7aecce78b83Douglas Gregor // T(*)() 5100fce0ae7d60bed52e36c87194922b7aecce78b83Douglas Gregor // T(*)(T) 511a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson case Type::FunctionProto: { 512a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson const FunctionProtoType *FunctionProtoArg = 513a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson dyn_cast<FunctionProtoType>(Arg); 514a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson if (!FunctionProtoArg) 515f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 516a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson 517a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson const FunctionProtoType *FunctionProtoParam = 518a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson cast<FunctionProtoType>(Param); 519994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 520994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson if (FunctionProtoParam->getTypeQuals() != 521994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson FunctionProtoArg->getTypeQuals()) 522f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 523994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 524994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson if (FunctionProtoParam->getNumArgs() != FunctionProtoArg->getNumArgs()) 525f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 526a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson 527994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson if (FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) 528f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 529994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 530a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson // Check return types. 531f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 532f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = DeduceTemplateArguments(Context, TemplateParams, 533f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor FunctionProtoParam->getResultType(), 534f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor FunctionProtoArg->getResultType(), 535508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0)) 536f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 537a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson 538a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson for (unsigned I = 0, N = FunctionProtoParam->getNumArgs(); I != N; ++I) { 539a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson // Check argument types. 540f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 541f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = DeduceTemplateArguments(Context, TemplateParams, 542f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor FunctionProtoParam->getArgType(I), 543f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor FunctionProtoArg->getArgType(I), 544508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0)) 545f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 546a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson } 547a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson 548f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 549a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson } 550d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 551f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // template-name<T> (where template-name refers to a class template) 552d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // template-name<i> 553d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // TT<T> (TODO) 554d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // TT<i> (TODO) 555d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // TT<> (TODO) 556d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor case Type::TemplateSpecialization: { 557d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor const TemplateSpecializationType *SpecParam 558d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor = cast<TemplateSpecializationType>(Param); 559de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 560de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Try to deduce template arguments from the template-id. 561de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult Result 562de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = DeduceTemplateArguments(Context, TemplateParams, SpecParam, Arg, 563de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced); 564de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 565de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Result && (TDF & TDF_DerivedClass) && 566de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Result != Sema::TDK_Inconsistent) { 567de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // C++ [temp.deduct.call]p3b3: 568de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If P is a class, and P has the form template-id, then A can be a 569de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // derived class of the deduced A. Likewise, if P is a pointer to a 570de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // class of the form template-id, A can be a pointer to a derived 571de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // class pointed to by the deduced A. 572de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // 573de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // More importantly: 574de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // These alternatives are considered only if type deduction would 575de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // otherwise fail. 576de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (const RecordType *RecordT = dyn_cast<RecordType>(Arg)) { 577de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Use data recursion to crawl through the list of base classes. 578de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Visited contains the set of nodes we have already visited, while 579de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // ToVisit is our stack of records that we still need to visit. 580de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallPtrSet<const RecordType *, 8> Visited; 581de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallVector<const RecordType *, 8> ToVisit; 582de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.push_back(RecordT); 583de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor bool Successful = false; 584de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor while (!ToVisit.empty()) { 585de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Retrieve the next class in the inheritance hierarchy. 586de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *NextT = ToVisit.back(); 587de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.pop_back(); 588d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 589de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If we have already seen this type, skip it. 590de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!Visited.insert(NextT)) 591de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor continue; 592de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 593de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If this is a base class, try to perform template argument 594de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // deduction from it. 595de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (NextT != RecordT) { 596de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult BaseResult 597de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = DeduceTemplateArguments(Context, TemplateParams, SpecParam, 598de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType(NextT, 0), Info, Deduced); 599de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 600de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If template argument deduction for this base was successful, 601de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // note that we had some success. 602de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (BaseResult == Sema::TDK_Success) 603de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Successful = true; 604de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If deduction against this base resulted in an inconsistent 605de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // set of deduced template arguments, template argument 606de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // deduction fails. 607de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor else if (BaseResult == Sema::TDK_Inconsistent) 608de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return BaseResult; 609de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 610de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 611de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Visit base classes 612de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl()); 613de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), 614de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor BaseEnd = Next->bases_end(); 615de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Base != BaseEnd; ++Base) { 616de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor assert(Base->getType()->isRecordType() && 617de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor "Base class that isn't a record?"); 618de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.push_back(Base->getType()->getAsRecordType()); 619de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 620de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 621de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 622de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Successful) 623de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_Success; 624de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 625de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 626de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 627a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson 628de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 629d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor } 630d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 631637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T type::* 632637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T T::* 633637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)() 634637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)() 635637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (type::*)(T) 636637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)(T) 637637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)(T) 638637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)() 639637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)(T) 640637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::MemberPointer: { 641637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param); 642637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg); 643637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor if (!MemPtrArg) 644f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 645f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 646f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 647f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = DeduceTemplateArguments(Context, TemplateParams, 648f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor MemPtrParam->getPointeeType(), 649f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor MemPtrArg->getPointeeType(), 650508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 651508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF & TDF_IgnoreQualifiers)) 652f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 653f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 654f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return DeduceTemplateArguments(Context, TemplateParams, 655f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType(MemPtrParam->getClass(), 0), 656f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType(MemPtrArg->getClass(), 0), 657508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 658637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor } 659637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 6609a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // (clang extension) 6619a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // 662859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson // type(^)(T) 663859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson // T(^)() 664859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson // T(^)(T) 665859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson case Type::BlockPointer: { 666859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param); 667859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg); 668859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson 669859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson if (!BlockPtrArg) 670f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 671859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson 672f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return DeduceTemplateArguments(Context, TemplateParams, 673859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson BlockPtrParam->getPointeeType(), 674f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor BlockPtrArg->getPointeeType(), Info, 675508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Deduced, 0); 676859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson } 677859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson 678637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOfExpr: 679637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOf: 680637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::Typename: 681637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // No template argument deduction for these types 682f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 683637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 684d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor default: 685d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor break; 6860b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 6870b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 6880b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // FIXME: Many more cases to go (to go). 689f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Sema::TDK_Success; 6900b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 6910b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 692f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 693f67875d5addf36b951ad37fb04509ab2b572c88aDouglas GregorDeduceTemplateArguments(ASTContext &Context, 694f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 695f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 6960b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor const TemplateArgument &Arg, 697f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Sema::TemplateDeductionInfo &Info, 6980b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced) { 6990b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor switch (Param.getKind()) { 700199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Null: 701199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(false && "Null template argument in parameter list"); 702199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor break; 703199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 7040b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor case TemplateArgument::Type: 705199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(Arg.getKind() == TemplateArgument::Type && "Type/value mismatch"); 706508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor return DeduceTemplateArguments(Context, TemplateParams, Param.getAsType(), 707508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Arg.getAsType(), Info, Deduced, 0); 7080b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 709199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Declaration: 710199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // FIXME: Implement this check 711199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(false && "Unimplemented template argument deduction case"); 712f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 713f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 714f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 715199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 716199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Integral: 717199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) { 718199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // FIXME: Zero extension + sign checking here? 719f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (*Param.getAsIntegral() == *Arg.getAsIntegral()) 720f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 721f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 722f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 723f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 724f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 725f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 726f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 727f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) { 728f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 729f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 730f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 731199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 732199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 733199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(false && "Type/value mismatch"); 734f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 735f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 736f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 737199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 738199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Expression: { 739199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (NonTypeTemplateParmDecl *NTTP 740199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(Param.getAsExpr())) { 741199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) 742199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // FIXME: Sign problems here 743199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return DeduceNonTypeTemplateArgument(Context, NTTP, 744f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor *Arg.getAsIntegral(), 745f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 746199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) 747199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return DeduceNonTypeTemplateArgument(Context, NTTP, Arg.getAsExpr(), 748f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 749199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 750199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(false && "Type/value mismatch"); 751f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 752f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 753f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 754199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 755199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 756199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Can't deduce anything, but that's okay. 757f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 758199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 759d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 760d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson assert(0 && "FIXME: Implement!"); 761d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson break; 7620b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 763199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 764f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 7650b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 7660b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 767f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 7680b9247f129401b4849682b2e2bcdea8fc977068aDouglas GregorDeduceTemplateArguments(ASTContext &Context, 769f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 7700b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor const TemplateArgumentList &ParamList, 7710b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor const TemplateArgumentList &ArgList, 772f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Sema::TemplateDeductionInfo &Info, 7730b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced) { 7740b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor assert(ParamList.size() == ArgList.size()); 7750b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor for (unsigned I = 0, N = ParamList.size(); I != N; ++I) { 776f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 777f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = DeduceTemplateArguments(Context, TemplateParams, 778f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor ParamList[I], ArgList[I], 779f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced)) 780f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 7810b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 782f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 7830b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 7840b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 785f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor/// \brief Determine whether two template arguments are the same. 786f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregorstatic bool isSameTemplateArg(ASTContext &Context, 787f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &X, 788f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &Y) { 789f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.getKind() != Y.getKind()) 790f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 791f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 792f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor switch (X.getKind()) { 793f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Null: 794f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor assert(false && "Comparing NULL template argument"); 795f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor break; 796f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 797f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Type: 798f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Context.getCanonicalType(X.getAsType()) == 799f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Context.getCanonicalType(Y.getAsType()); 800f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 801f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Declaration: 802f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Context.getCanonicalDecl(X.getAsDecl()) == 803f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Context.getCanonicalDecl(Y.getAsDecl()); 804f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 805f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Integral: 806f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return *X.getAsIntegral() == *Y.getAsIntegral(); 807f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 808f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Expression: 809f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // FIXME: We assume that all expressions are distinct, but we should 810f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // really check their canonical forms. 811f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 812f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 813f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Pack: 814f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.pack_size() != Y.pack_size()) 815f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 816f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 817f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor for (TemplateArgument::pack_iterator XP = X.pack_begin(), 818f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor XPEnd = X.pack_end(), 819f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor YP = Y.pack_begin(); 820f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor XP != XPEnd; ++XP, ++YP) 821f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!isSameTemplateArg(Context, *XP, *YP)) 822f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 823f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 824f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return true; 825f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 826f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 827f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 828f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor} 829f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 830f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor/// \brief Helper function to build a TemplateParameter when we don't 831f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor/// know its type statically. 832f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregorstatic TemplateParameter makeTemplateParameter(Decl *D) { 833f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D)) 834f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return TemplateParameter(TTP); 835f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) 836f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return TemplateParameter(NTTP); 837f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 838f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return TemplateParameter(cast<TemplateTemplateParmDecl>(D)); 839f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor} 840f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 841c1efb3faefa7d42f974fe384dfd45e5127f8afa6Douglas Gregor/// \brief Perform template argument deduction to determine whether 842c1efb3faefa7d42f974fe384dfd45e5127f8afa6Douglas Gregor/// the given template arguments match the given class template 843c1efb3faefa7d42f974fe384dfd45e5127f8afa6Douglas Gregor/// partial specialization per C++ [temp.class.spec.match]. 844f67875d5addf36b951ad37fb04509ab2b572c88aDouglas GregorSema::TemplateDeductionResult 8450b9247f129401b4849682b2e2bcdea8fc977068aDouglas GregorSema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, 846f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgumentList &TemplateArgs, 847f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateDeductionInfo &Info) { 848c1efb3faefa7d42f974fe384dfd45e5127f8afa6Douglas Gregor // C++ [temp.class.spec.match]p2: 849c1efb3faefa7d42f974fe384dfd45e5127f8afa6Douglas Gregor // A partial specialization matches a given actual template 850c1efb3faefa7d42f974fe384dfd45e5127f8afa6Douglas Gregor // argument list if the template arguments of the partial 851c1efb3faefa7d42f974fe384dfd45e5127f8afa6Douglas Gregor // specialization can be deduced from the actual template argument 852c1efb3faefa7d42f974fe384dfd45e5127f8afa6Douglas Gregor // list (14.8.2). 853bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor SFINAETrap Trap(*this); 8540b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor llvm::SmallVector<TemplateArgument, 4> Deduced; 8550b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor Deduced.resize(Partial->getTemplateParameters()->size()); 856f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (TemplateDeductionResult Result 857f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = ::DeduceTemplateArguments(Context, 858f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Partial->getTemplateParameters(), 859f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Partial->getTemplateArgs(), 860f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateArgs, Info, Deduced)) 861f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 862637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 863637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, 864637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor Deduced.data(), Deduced.size()); 865637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor if (Inst) 866f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return TDK_InstantiationDepth; 867199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 86802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // C++ [temp.deduct.type]p2: 86902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // [...] or if any template argument remains neither deduced nor 87002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // explicitly specified, template argument deduction fails. 871fb25052736439d72a557cddd41dfb927bcb3d3e5Anders Carlsson TemplateArgumentListBuilder Builder(Partial->getTemplateParameters(), 872fb25052736439d72a557cddd41dfb927bcb3d3e5Anders Carlsson Deduced.size()); 87302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor for (unsigned I = 0, N = Deduced.size(); I != N; ++I) { 874f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Deduced[I].isNull()) { 875f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Decl *Param 876f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = const_cast<Decl *>(Partial->getTemplateParameters()->getParam(I)); 877f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 878f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = TTP; 879f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor else if (NonTypeTemplateParmDecl *NTTP 880f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) 881f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = NTTP; 882f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor else 883f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = cast<TemplateTemplateParmDecl>(Param); 884f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return TDK_Incomplete; 885f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 88602cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 887fb25052736439d72a557cddd41dfb927bcb3d3e5Anders Carlsson Builder.Append(Deduced[I]); 88802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 88902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 89002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Form the template argument list from the deduced template arguments. 89102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor TemplateArgumentList *DeducedArgumentList 892fb25052736439d72a557cddd41dfb927bcb3d3e5Anders Carlsson = new (Context) TemplateArgumentList(Context, Builder, /*TakeArgs=*/true); 893f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.reset(DeducedArgumentList); 89402cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 89502cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Substitute the deduced template arguments into the template 89602cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // arguments of the class template partial specialization, and 89702cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // verify that the instantiated template arguments are both valid 89802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // and are equivalent to the template arguments originally provided 899c9e5d25ea33616c896a2ce5fbd6d68186eaddc5cDouglas Gregor // to the class template. 90002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); 90102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor const TemplateArgumentList &PartialTemplateArgs = Partial->getTemplateArgs(); 90202cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor for (unsigned I = 0, N = PartialTemplateArgs.flat_size(); I != N; ++I) { 903c9e5d25ea33616c896a2ce5fbd6d68186eaddc5cDouglas Gregor Decl *Param = const_cast<Decl *>( 904c9e5d25ea33616c896a2ce5fbd6d68186eaddc5cDouglas Gregor ClassTemplate->getTemplateParameters()->getParam(I)); 905f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor TemplateArgument InstArg = Instantiate(PartialTemplateArgs[I], 906f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor *DeducedArgumentList); 907f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (InstArg.isNull()) { 908f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.Param = makeTemplateParameter(Param); 909f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = PartialTemplateArgs[I]; 910f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return TDK_SubstitutionFailure; 911f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 912f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 913f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (InstArg.getKind() == TemplateArgument::Expression) { 914f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // When the argument is an expression, check the expression result 915f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // against the actual template parameter to get down to the canonical 916f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // template argument. 917f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Expr *InstExpr = InstArg.getAsExpr(); 918f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (NonTypeTemplateParmDecl *NTTP 919f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 920f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (CheckTemplateArgument(NTTP, NTTP->getType(), InstExpr, InstArg)) { 921f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.Param = makeTemplateParameter(Param); 922f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = PartialTemplateArgs[I]; 923f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return TDK_SubstitutionFailure; 924f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 925f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } else if (TemplateTemplateParmDecl *TTP 926f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor = dyn_cast<TemplateTemplateParmDecl>(Param)) { 927f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // FIXME: template template arguments should really resolve to decls 928f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InstExpr); 929f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!DRE || CheckTemplateArgument(TTP, DRE)) { 930f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.Param = makeTemplateParameter(Param); 931f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = PartialTemplateArgs[I]; 932f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return TDK_SubstitutionFailure; 933f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 934f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 93502cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 936f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 937f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!isSameTemplateArg(Context, TemplateArgs[I], InstArg)) { 938f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.Param = makeTemplateParameter(Param); 939f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = TemplateArgs[I]; 940f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.SecondArg = InstArg; 941f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return TDK_NonDeducedMismatch; 942f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 94302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 94402cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 945bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor if (Trap.hasErrorOccurred()) 946bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor return TDK_SubstitutionFailure; 947bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor 948f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return TDK_Success; 9490b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 950031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 9514112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor/// \brief Determine whether the given type T is a simple-template-id type. 9524112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregorstatic bool isSimpleTemplateIdType(QualType T) { 9534112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor if (const TemplateSpecializationType *Spec 9544112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor = T->getAsTemplateSpecializationType()) 9554112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return Spec->getTemplateName().getAsTemplateDecl() != 0; 9564112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor 9574112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return false; 9584112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor} 95983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 96083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Substitute the explicitly-provided template arguments into the 96183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// given function template according to C++ [temp.arg.explicit]. 96283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 96383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template into which the explicit 96483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template arguments will be substituted. 96583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 96683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ExplicitTemplateArguments the explicitly-specified template 96783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// arguments. 96883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 96983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param NumExplicitTemplateArguments the number of explicitly-specified 97083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template arguments in @p ExplicitTemplateArguments. This value may be zero. 97183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 97283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Deduced the deduced template arguments, which will be populated 97383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// with the converted and checked explicit template arguments. 97483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 97583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ParamTypes will be populated with the instantiated function 97683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// parameters. 97783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 97883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionType if non-NULL, the result type of the function template 97983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// will also be instantiated and the pointed-to value will be updated with 98083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the instantiated function type. 98183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 98283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info if substitution fails for any reason, this object will be 98383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// populated with more information about the failure. 98483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 98583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns TDK_Success if substitution was successful, or some failure 98683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// condition. 98783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 98883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::SubstituteExplicitTemplateArguments( 98983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplateDecl *FunctionTemplate, 99083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor const TemplateArgument *ExplicitTemplateArgs, 99183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor unsigned NumExplicitTemplateArgs, 99283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced, 99383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVectorImpl<QualType> &ParamTypes, 99483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType *FunctionType, 99583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 99683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 99783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 99883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 99983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 100083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (NumExplicitTemplateArgs == 0) { 100183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // No arguments to substitute; just copy over the parameter types and 100283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // fill in the function type. 100383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (FunctionDecl::param_iterator P = Function->param_begin(), 100483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor PEnd = Function->param_end(); 100583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor P != PEnd; 100683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ++P) 100783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.push_back((*P)->getType()); 100883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 100983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) 101083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *FunctionType = Function->getType(); 101183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 101283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 101383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 101483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitution of the explicit template arguments into a function template 101583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor /// is a SFINAE context. Trap any errors that might occur. 101683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SFINAETrap Trap(*this); 101783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 101883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p3: 101983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Template arguments that are present shall be specified in the 102083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration order of their corresponding template-parameters. The 102183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template argument list shall not specify more template-arguments than 102283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // there are corresponding template-parameters. 102383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateArgumentListBuilder Builder(TemplateParams, 102483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor NumExplicitTemplateArgs); 102583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 102683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Enter a new template instantiation context where we check the 102783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments against this function template, 102883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // and then substitute them into the function parameter types. 102983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 103083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplate, Deduced.data(), Deduced.size(), 103183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution); 103283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Inst) 103383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InstantiationDepth; 103483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 103583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (CheckTemplateArgumentList(FunctionTemplate, 103683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SourceLocation(), SourceLocation(), 103783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ExplicitTemplateArgs, 103883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor NumExplicitTemplateArgs, 103983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SourceLocation(), 104083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor true, 104183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Builder) || Trap.hasErrorOccurred()) 104283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InvalidExplicitArguments; 104383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 104483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the explicitly-specified 104583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments. 104683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateArgumentList *ExplicitArgumentList 104783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = new (Context) TemplateArgumentList(Context, Builder, /*TakeArgs=*/true); 104883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(ExplicitArgumentList); 104983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 105083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Instantiate the types of each of the function parameters given the 105183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments. 105283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (FunctionDecl::param_iterator P = Function->param_begin(), 105383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor PEnd = Function->param_end(); 105483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor P != PEnd; 105583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ++P) { 105683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType ParamType = InstantiateType((*P)->getType(), 105783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *ExplicitArgumentList, 105883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor (*P)->getLocation(), 105983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor (*P)->getDeclName()); 106083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (ParamType.isNull() || Trap.hasErrorOccurred()) 106183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 106283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 106383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.push_back(ParamType); 106483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 106583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 106683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // If the caller wants a full function type back, instantiate the return 106783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // type and form that function type. 106883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) { 106983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // FIXME: exception-specifications? 107083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor const FunctionProtoType *Proto 107183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = Function->getType()->getAsFunctionProtoType(); 107283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor assert(Proto && "Function template does not have a prototype?"); 107383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 107483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType ResultType = InstantiateType(Proto->getResultType(), 107583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *ExplicitArgumentList, 107683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getTypeSpecStartLoc(), 107783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getDeclName()); 107883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (ResultType.isNull() || Trap.hasErrorOccurred()) 107983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 108083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 108183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *FunctionType = BuildFunctionType(ResultType, 108283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.data(), ParamTypes.size(), 108383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->isVariadic(), 108483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->getTypeQuals(), 108583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getLocation(), 108683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getDeclName()); 108783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType->isNull() || Trap.hasErrorOccurred()) 108883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 108983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 109083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 109183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p2: 109283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Trailing template arguments that can be deduced (14.8.2) may be 109383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // omitted from the list of explicit template-arguments. If all of the 109483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments can be deduced, they may all be omitted; in this 109583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // case, the empty template argument list <> itself may also be omitted. 109683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // 109783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Take all of the explicitly-specified arguments and put them into the 109883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // set of deduced template arguments. 109983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced.reserve(TemplateParams->size()); 110083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) 110183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced.push_back(ExplicitArgumentList->get(I)); 110283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 110383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 110483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 110583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 110683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Finish template argument deduction for a function template, 110783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// checking the deduced template arguments for completeness and forming 110883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the function template specialization. 110983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 111083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, 111183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Deduced, 111283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 111383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 111483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 111583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 111683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 111783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.deduct.type]p2: 111883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // [...] or if any template argument remains neither deduced nor 111983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly specified, template argument deduction fails. 112083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateArgumentListBuilder Builder(TemplateParams, Deduced.size()); 112183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (unsigned I = 0, N = Deduced.size(); I != N; ++I) { 112283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Deduced[I].isNull()) { 112383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.Param = makeTemplateParameter( 112483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor const_cast<Decl *>(TemplateParams->getParam(I))); 112583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Incomplete; 112683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 112783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 112883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Builder.Append(Deduced[I]); 112983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 113083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 113183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the deduced template arguments. 113283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateArgumentList *DeducedArgumentList 113383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = new (Context) TemplateArgumentList(Context, Builder, /*TakeArgs=*/true); 113483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(DeducedArgumentList); 113583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 113683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Template argument deduction for function templates in a SFINAE context. 113783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Trap any errors that might occur. 113883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SFINAETrap Trap(*this); 113983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 114083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Enter a new template instantiation context while we instantiate the 114183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // actual function declaration. 114283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 114383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplate, Deduced.data(), Deduced.size(), 114483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution); 114583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Inst) 114683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InstantiationDepth; 114783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 114883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitute the deduced template arguments into the function template 114983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration to produce the function template specialization. 115083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization = cast_or_null<FunctionDecl>( 115183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor InstantiateDecl(FunctionTemplate->getTemplatedDecl(), 115283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplate->getDeclContext(), 115383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *DeducedArgumentList)); 115483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (!Specialization) 115583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 115683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 115783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // If the template argument list is owned by the function template 115883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // specialization, release it. 115983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList) 116083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.take(); 116183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 116283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // There may have been an error that did not prevent us from constructing a 116383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration. Mark the declaration invalid and return with a substitution 116483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // failure. 116583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Trap.hasErrorOccurred()) { 116683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization->setInvalidDecl(true); 116783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 116883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 116983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 117083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 117183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 117283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 1173e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \brief Perform template argument deduction from a function call 1174e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// (C++ [temp.deduct.call]). 1175e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 1176e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 1177e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 1178e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 11796db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// \param HasExplicitTemplateArgs whether any template arguments were 11806db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// explicitly specified. 11816db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// 11826db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// \param ExplicitTemplateArguments when @p HasExplicitTemplateArgs is true, 11836db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// the explicitly-specified template arguments. 11846db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// 11856db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// \param NumExplicitTemplateArguments when @p HasExplicitTemplateArgs is true, 11866db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// the number of explicitly-specified template arguments in 11876db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// @p ExplicitTemplateArguments. This value may be zero. 11886db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// 1189e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Args the function call arguments 1190e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 1191e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param NumArgs the number of arguments in Args 1192e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 1193e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Specialization if template argument deduction was successful, 1194e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// this will be set to the function template specialization produced by 1195e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 1196e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 1197e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Info the argument will be updated to provide additional information 1198e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// about template argument deduction. 1199e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 1200e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \returns the result of template argument deduction. 1201e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::TemplateDeductionResult 1202e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 12036db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor bool HasExplicitTemplateArgs, 12046db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor const TemplateArgument *ExplicitTemplateArgs, 12056db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor unsigned NumExplicitTemplateArgs, 1206e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor Expr **Args, unsigned NumArgs, 1207e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *&Specialization, 1208e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateDeductionInfo &Info) { 1209e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 12106db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor 1211e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++ [temp.deduct.call]p1: 1212e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // Template argument deduction is done by comparing each function template 1213e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // parameter type (call it P) with the type of the corresponding argument 1214e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // of the call (call it A) as described below. 1215e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor unsigned CheckArgs = NumArgs; 12166db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor if (NumArgs < Function->getMinRequiredArguments()) 1217e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooFewArguments; 1218e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor else if (NumArgs > Function->getNumParams()) { 1219e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor const FunctionProtoType *Proto 1220e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor = Function->getType()->getAsFunctionProtoType(); 1221e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor if (!Proto->isVariadic()) 1222e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooManyArguments; 1223e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 1224e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor CheckArgs = Function->getNumParams(); 1225e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 12266db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor 12276db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // The types of the parameters from which we will perform template argument 12286db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // deduction. 1229e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateParameterList *TemplateParams 1230e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor = FunctionTemplate->getTemplateParameters(); 12316db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor llvm::SmallVector<TemplateArgument, 4> Deduced; 12326db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor llvm::SmallVector<QualType, 4> ParamTypes; 12336db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor if (NumExplicitTemplateArgs) { 123483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionResult Result = 123583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SubstituteExplicitTemplateArguments(FunctionTemplate, 123683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ExplicitTemplateArgs, 123783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor NumExplicitTemplateArgs, 123883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced, 123983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes, 124083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 0, 124183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info); 124283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Result) 124383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 12446db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } else { 12456db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Just fill in the parameter types from the function declaration. 12466db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor for (unsigned I = 0; I != CheckArgs; ++I) 12476db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor ParamTypes.push_back(Function->getParamDecl(I)->getType()); 12486db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } 124983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 12506db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Deduce template arguments from the function parameters. 12516db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor Deduced.resize(TemplateParams->size()); 1252e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor for (unsigned I = 0; I != CheckArgs; ++I) { 12536db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor QualType ParamType = ParamTypes[I]; 1254e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor QualType ArgType = Args[I]->getType(); 1255500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor 1256e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++ [temp.deduct.call]p2: 1257e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // If P is not a reference type: 1258e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor QualType CanonParamType = Context.getCanonicalType(ParamType); 1259500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor bool ParamWasReference = isa<ReferenceType>(CanonParamType); 1260500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor if (!ParamWasReference) { 1261e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // - If A is an array type, the pointer type produced by the 1262e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // array-to-pointer standard conversion (4.2) is used in place of 1263e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // A for type deduction; otherwise, 1264e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor if (ArgType->isArrayType()) 1265e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor ArgType = Context.getArrayDecayedType(ArgType); 1266e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // - If A is a function type, the pointer type produced by the 1267e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // function-to-pointer standard conversion (4.3) is used in place 1268e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // of A for type deduction; otherwise, 1269e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor else if (ArgType->isFunctionType()) 1270e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor ArgType = Context.getPointerType(ArgType); 1271e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor else { 1272e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // - If A is a cv-qualified type, the top level cv-qualifiers of A’s 1273e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // type are ignored for type deduction. 1274e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor QualType CanonArgType = Context.getCanonicalType(ArgType); 1275e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor if (CanonArgType.getCVRQualifiers()) 1276e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor ArgType = CanonArgType.getUnqualifiedType(); 1277e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 1278e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 1279e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 1280e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++0x [temp.deduct.call]p3: 1281e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // If P is a cv-qualified type, the top level cv-qualifiers of P’s type 1282e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // are ignored for type deduction. 1283e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor if (CanonParamType.getCVRQualifiers()) 1284e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor ParamType = CanonParamType.getUnqualifiedType(); 1285e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor if (const ReferenceType *ParamRefType = ParamType->getAsReferenceType()) { 1286e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // [...] If P is a reference type, the type referred to by P is used 1287e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // for type deduction. 1288e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor ParamType = ParamRefType->getPointeeType(); 1289e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 1290e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // [...] If P is of the form T&&, where T is a template parameter, and 1291e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // the argument is an lvalue, the type A& is used in place of A for 1292e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // type deduction. 1293e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor if (isa<RValueReferenceType>(ParamRefType) && 1294e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor ParamRefType->getAsTemplateTypeParmType() && 1295e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor Args[I]->isLvalue(Context) == Expr::LV_Valid) 1296e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor ArgType = Context.getLValueReferenceType(ArgType); 1297e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 1298e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 1299e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++0x [temp.deduct.call]p4: 1300e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // In general, the deduction process attempts to find template argument 1301e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // values that will make the deduced A identical to A (after the type A 1302e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // is transformed as described above). [...] 1303508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor unsigned TDF = 0; 1304508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 1305508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 1306508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // type referred to by the reference) can be more cv-qualified than 1307508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // the transformed A. 1308508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (ParamWasReference) 1309508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF |= TDF_ParamWithReferenceType; 1310508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // - The transformed A can be another pointer or pointer to member 1311508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // type that can be converted to the deduced A via a qualification 1312508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // conversion (4.4). 1313508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (ArgType->isPointerType() || ArgType->isMemberPointerType()) 1314508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF |= TDF_IgnoreQualifiers; 13154112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor // - If P is a class and P has the form simple-template-id, then the 13164112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor // transformed A can be a derived class of the deduced A. Likewise, 13174112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor // if P is a pointer to a class of the form simple-template-id, the 13184112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor // transformed A can be a pointer to a derived class pointed to by 13194112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor // the deduced A. 13204112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor if (isSimpleTemplateIdType(ParamType) || 13214112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor (isa<PointerType>(ParamType) && 13224112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor isSimpleTemplateIdType( 13234112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor ParamType->getAsPointerType()->getPointeeType()))) 13244112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor TDF |= TDF_DerivedClass; 13254112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor 1326e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor if (TemplateDeductionResult Result 1327e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor = ::DeduceTemplateArguments(Context, TemplateParams, 1328500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor ParamType, ArgType, Info, Deduced, 1329508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF)) 1330e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return Result; 1331e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 13328fdc3c49e3c8178222a35b16426dc5a08a0efb6dDouglas Gregor // FIXME: C++0x [temp.deduct.call] paragraphs 6-9 deal with function 1333e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // pointer parameters. 1334e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 1335e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 133683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 133783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization, Info); 133883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 1339127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor 134083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Deduce template arguments when taking the address of a function 134183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template (C++ [temp.deduct.funcaddr]). 134283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 134383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template for which we are performing 134483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 134583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 134683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param HasExplicitTemplateArgs whether any template arguments were 134783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// explicitly specified. 134883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 134983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ExplicitTemplateArguments when @p HasExplicitTemplateArgs is true, 135083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the explicitly-specified template arguments. 135183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 135283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param NumExplicitTemplateArguments when @p HasExplicitTemplateArgs is true, 135383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the number of explicitly-specified template arguments in 135483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// @p ExplicitTemplateArguments. This value may be zero. 135583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 135683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ArgFunctionType the function type that will be used as the 135783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// "argument" type (A) when performing template argument deduction from the 135883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// function template's function type. 135983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 136083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Specialization if template argument deduction was successful, 136183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// this will be set to the function template specialization produced by 136283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 136383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 136483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info the argument will be updated to provide additional information 136583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// about template argument deduction. 136683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 136783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns the result of template argument deduction. 136883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 136983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 137083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor bool HasExplicitTemplateArgs, 137183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor const TemplateArgument *ExplicitTemplateArgs, 137283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor unsigned NumExplicitTemplateArgs, 137383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType ArgFunctionType, 137483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 137583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 137683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 137783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 137883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 137983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType FunctionType = Function->getType(); 138083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 138183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitute any explicit template arguments. 138283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVector<TemplateArgument, 4> Deduced; 138383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVector<QualType, 4> ParamTypes; 138483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (HasExplicitTemplateArgs) { 138583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (TemplateDeductionResult Result 138683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = SubstituteExplicitTemplateArguments(FunctionTemplate, 138783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ExplicitTemplateArgs, 138883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor NumExplicitTemplateArgs, 138983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced, ParamTypes, 139083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor &FunctionType, Info)) 139183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 1392127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor } 139383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 139483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Template argument deduction for function templates in a SFINAE context. 139583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Trap any errors that might occur. 139683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SFINAETrap Trap(*this); 1397127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor 139883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Deduce template arguments from the function type. 139983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced.resize(TemplateParams->size()); 140083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (TemplateDeductionResult Result 140183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = ::DeduceTemplateArguments(Context, TemplateParams, 140283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionType, ArgFunctionType, Info, 140383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced, 0)) 140483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 140583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 140683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 140783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization, Info); 1408e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor} 1409e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 141083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 1411031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregorstatic void 1412031a5880e19d06624551aed9d74594356f4f9db1Douglas GregorMarkDeducedTemplateParameters(Sema &SemaRef, 1413031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const TemplateArgument &TemplateArg, 1414031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced); 1415031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1416031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \brief Mark the template arguments that are deduced by the given 1417031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// expression. 1418031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregorstatic void 1419f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas GregorMarkDeducedTemplateParameters(const Expr *E, 1420f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced) { 1421f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 1422031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!E) 1423031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 1424031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1425f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const NonTypeTemplateParmDecl *NTTP 1426031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 1427031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!NTTP) 1428031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 1429031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1430031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced[NTTP->getIndex()] = true; 1431031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 1432031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1433031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \brief Mark the template parameters that are deduced by the given 1434031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// type. 1435031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregorstatic void 1436031a5880e19d06624551aed9d74594356f4f9db1Douglas GregorMarkDeducedTemplateParameters(Sema &SemaRef, QualType T, 1437031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced) { 1438031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Non-dependent types have nothing deducible 1439031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!T->isDependentType()) 1440031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 1441031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1442031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor T = SemaRef.Context.getCanonicalType(T); 1443031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (T->getTypeClass()) { 1444031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ExtQual: 1445031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, 1446f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor QualType(cast<ExtQualType>(T)->getBaseType(), 0), 1447031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced); 1448031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1449031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1450031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Pointer: 1451031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, 1452f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor cast<PointerType>(T)->getPointeeType(), 1453031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced); 1454031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1455031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1456031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::BlockPointer: 1457031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, 1458f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor cast<BlockPointerType>(T)->getPointeeType(), 1459031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced); 1460031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1461031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1462031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::LValueReference: 1463031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::RValueReference: 1464031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, 1465f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor cast<ReferenceType>(T)->getPointeeType(), 1466031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced); 1467031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1468031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1469031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::MemberPointer: { 1470031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr()); 1471031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, MemPtr->getPointeeType(), Deduced); 1472031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, QualType(MemPtr->getClass(), 0), 1473031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced); 1474031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1475031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 1476031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1477031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::DependentSizedArray: 1478f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor MarkDeducedTemplateParameters(cast<DependentSizedArrayType>(T)->getSizeExpr(), 1479031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced); 1480031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Fall through to check the element type 1481031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1482031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ConstantArray: 1483031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::IncompleteArray: 1484031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, 1485f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor cast<ArrayType>(T)->getElementType(), 1486031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced); 1487031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1488031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1489031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Vector: 1490031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ExtVector: 1491031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, 1492f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor cast<VectorType>(T)->getElementType(), 1493031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced); 1494031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1495031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 14969cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor case Type::DependentSizedExtVector: { 14979cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor const DependentSizedExtVectorType *VecType 1498f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<DependentSizedExtVectorType>(T); 14999cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor MarkDeducedTemplateParameters(SemaRef, VecType->getElementType(), Deduced); 15009cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor MarkDeducedTemplateParameters(VecType->getSizeExpr(), Deduced); 15019cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor break; 15029cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 15039cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 1504031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionProto: { 1505f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 1506031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, Proto->getResultType(), Deduced); 1507031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I) 1508031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, Proto->getArgType(I), Deduced); 1509031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1510031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 1511031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1512031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::TemplateTypeParm: 1513f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor Deduced[cast<TemplateTypeParmType>(T)->getIndex()] = true; 1514031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1515031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1516031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::TemplateSpecialization: { 1517031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const TemplateSpecializationType *Spec 1518f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<TemplateSpecializationType>(T); 1519031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (TemplateDecl *Template = Spec->getTemplateName().getAsTemplateDecl()) 1520031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (TemplateTemplateParmDecl *TTP 1521031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(Template)) 1522031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced[TTP->getIndex()] = true; 1523031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1524031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 1525031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, Spec->getArg(I), Deduced); 1526031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1527031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1528031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 1529031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1530031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // None of these types have any deducible parts. 1531031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Builtin: 1532031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FixedWidthInt: 1533031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Complex: 1534031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::VariableArray: 1535031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionNoProto: 1536031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Record: 1537031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Enum: 1538031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Typename: 1539031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ObjCInterface: 1540031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ObjCQualifiedInterface: 1541d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 1542031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define TYPE(Class, Base) 1543031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 1544031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define DEPENDENT_TYPE(Class, Base) 1545031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 1546031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#include "clang/AST/TypeNodes.def" 1547031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1548031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 1549031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 1550031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1551031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \brief Mark the template parameters that are deduced by this 1552031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument. 1553031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregorstatic void 1554031a5880e19d06624551aed9d74594356f4f9db1Douglas GregorMarkDeducedTemplateParameters(Sema &SemaRef, 1555031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const TemplateArgument &TemplateArg, 1556031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced) { 1557031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (TemplateArg.getKind()) { 1558031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Null: 1559031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Integral: 1560031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1561031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1562031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Type: 1563031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(SemaRef, TemplateArg.getAsType(), Deduced); 1564031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1565031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1566031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Declaration: 1567031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (TemplateTemplateParmDecl *TTP 1568031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(TemplateArg.getAsDecl())) 1569031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor Deduced[TTP->getIndex()] = true; 1570031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1571031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1572031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Expression: 1573031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor MarkDeducedTemplateParameters(TemplateArg.getAsExpr(), Deduced); 1574031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 1575d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 1576d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson assert(0 && "FIXME: Implement!"); 1577d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson break; 1578031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 1579031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 1580031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 1581031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \brief Mark the template parameters can be deduced by the given 1582031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument list. 1583031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 1584031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param TemplateArgs the template argument list from which template 1585031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// parameters will be deduced. 1586031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 1587031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param Deduced a bit vector whose elements will be set to \c true 1588031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// to indicate when the corresponding template parameter will be 1589031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// deduced. 1590031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregorvoid 1591031a5880e19d06624551aed9d74594356f4f9db1Douglas GregorSema::MarkDeducedTemplateParameters(const TemplateArgumentList &TemplateArgs, 1592031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced) { 1593031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 1594031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor ::MarkDeducedTemplateParameters(*this, TemplateArgs[I], Deduced); 1595031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 1596