head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.13 netbsd-11-0-RC3:1.1.1.13 netbsd-11-0-RC2:1.1.1.13 netbsd-11-0-RC1:1.1.1.13 perseant-exfatfs-base-20250801:1.1.1.13 netbsd-11:1.1.1.13.0.10 netbsd-11-base:1.1.1.13 netbsd-10-1-RELEASE:1.1.1.13 perseant-exfatfs-base-20240630:1.1.1.13 perseant-exfatfs:1.1.1.13.0.8 perseant-exfatfs-base:1.1.1.13 netbsd-8-3-RELEASE:1.1.1.10 netbsd-9-4-RELEASE:1.1.1.12 netbsd-10-0-RELEASE:1.1.1.13 netbsd-10-0-RC6:1.1.1.13 netbsd-10-0-RC5:1.1.1.13 netbsd-10-0-RC4:1.1.1.13 netbsd-10-0-RC3:1.1.1.13 netbsd-10-0-RC2:1.1.1.13 netbsd-10-0-RC1:1.1.1.13 netbsd-10:1.1.1.13.0.6 netbsd-10-base:1.1.1.13 netbsd-9-3-RELEASE:1.1.1.12 cjep_sun2x:1.1.1.13.0.4 cjep_sun2x-base:1.1.1.13 cjep_staticlib_x-base1:1.1.1.13 netbsd-9-2-RELEASE:1.1.1.12 cjep_staticlib_x:1.1.1.13.0.2 cjep_staticlib_x-base:1.1.1.13 netbsd-9-1-RELEASE:1.1.1.12 phil-wifi-20200421:1.1.1.13 phil-wifi-20200411:1.1.1.13 phil-wifi-20200406:1.1.1.13 netbsd-8-2-RELEASE:1.1.1.10 netbsd-9-0-RELEASE:1.1.1.12 netbsd-9-0-RC2:1.1.1.12 netbsd-9-0-RC1:1.1.1.12 netbsd-9:1.1.1.12.0.2 netbsd-9-base:1.1.1.12 phil-wifi-20190609:1.1.1.12 netbsd-8-1-RELEASE:1.1.1.10 netbsd-8-1-RC1:1.1.1.10 pgoyette-compat-merge-20190127:1.1.1.11.2.1 pgoyette-compat-20190127:1.1.1.12 pgoyette-compat-20190118:1.1.1.12 pgoyette-compat-1226:1.1.1.12 pgoyette-compat-1126:1.1.1.12 pgoyette-compat-1020:1.1.1.12 pgoyette-compat-0930:1.1.1.12 pgoyette-compat-0906:1.1.1.12 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.12 clang-337282:1.1.1.12 netbsd-8-0-RELEASE:1.1.1.10 phil-wifi:1.1.1.11.0.4 phil-wifi-base:1.1.1.11 pgoyette-compat-0625:1.1.1.11 netbsd-8-0-RC2:1.1.1.10 pgoyette-compat-0521:1.1.1.11 pgoyette-compat-0502:1.1.1.11 pgoyette-compat-0422:1.1.1.11 netbsd-8-0-RC1:1.1.1.10 pgoyette-compat-0415:1.1.1.11 pgoyette-compat-0407:1.1.1.11 pgoyette-compat-0330:1.1.1.11 pgoyette-compat-0322:1.1.1.11 pgoyette-compat-0315:1.1.1.11 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.11.0.2 pgoyette-compat-base:1.1.1.11 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.11 matt-nb8-mediatek:1.1.1.10.0.10 matt-nb8-mediatek-base:1.1.1.10 clang-309604:1.1.1.11 perseant-stdc-iso10646:1.1.1.10.0.8 perseant-stdc-iso10646-base:1.1.1.10 netbsd-8:1.1.1.10.0.6 netbsd-8-base:1.1.1.10 prg-localcount2-base3:1.1.1.10 prg-localcount2-base2:1.1.1.10 prg-localcount2-base1:1.1.1.10 prg-localcount2:1.1.1.10.0.4 prg-localcount2-base:1.1.1.10 pgoyette-localcount-20170426:1.1.1.10 bouyer-socketcan-base1:1.1.1.10 pgoyette-localcount-20170320:1.1.1.10 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.10 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.5 clang-199312:1.1.1.4 clang-198450:1.1.1.3 clang-196603:1.1.1.2 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.51; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.51; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2013.12.06.23.17.00; author joerg; state Exp; branches; next 1.1.1.3; commitid oIJdta8D25nvY7gx; 1.1.1.3 date 2014.01.05.15.38.48; author joerg; state Exp; branches; next 1.1.1.4; commitid wh3aCSIWykURqWjx; 1.1.1.4 date 2014.01.15.21.26.22; author joerg; state Exp; branches; next 1.1.1.5; commitid NQXlzzA0SPkc5glx; 1.1.1.5 date 2014.02.14.20.07.15; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid annVkZ1sc17rF6px; 1.1.1.6 date 2014.05.30.18.14.44; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.29; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.29; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.11.56; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.34.02; author joerg; state Exp; branches; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.08.01.19.35.09; author joerg; state Exp; branches 1.1.1.11.2.1 1.1.1.11.4.1; next 1.1.1.12; commitid pMuDy65V0VicSx1A; 1.1.1.12 date 2018.07.17.18.31.21; author joerg; state Exp; branches; next 1.1.1.13; commitid wDzL46ALjrCZgwKA; 1.1.1.13 date 2019.11.13.22.19.27; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.09; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.02.14.20.07.15; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.30; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.30; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.29; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.30; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.41; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.11.2.1 date 2018.07.28.04.33.22; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.11.4.1 date 2019.06.10.21.45.27; author christos; state Exp; branches; next 1.1.1.11.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.11.4.2 date 2020.04.13.07.46.38; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/ // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. //===----------------------------------------------------------------------===/ // // This file implements C++ template argument deduction. // //===----------------------------------------------------------------------===/ #include "clang/Sema/TemplateDeduction.h" #include "TreeTransform.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTLambda.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/StmtVisitor.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/Sema.h" #include "clang/Sema/Template.h" #include "llvm/ADT/SmallBitVector.h" #include namespace clang { using namespace sema; /// \brief Various flags that control template argument deduction. /// /// These flags can be bitwise-OR'd together. enum TemplateDeductionFlags { /// \brief No template argument deduction flags, which indicates the /// strictest results for template argument deduction (as used for, e.g., /// matching class template partial specializations). TDF_None = 0, /// \brief Within template argument deduction from a function call, we are /// matching with a parameter type for which the original parameter was /// a reference. TDF_ParamWithReferenceType = 0x1, /// \brief Within template argument deduction from a function call, we /// are matching in a case where we ignore cv-qualifiers. TDF_IgnoreQualifiers = 0x02, /// \brief Within template argument deduction from a function call, /// we are matching in a case where we can perform template argument /// deduction from a template-id of a derived class of the argument type. TDF_DerivedClass = 0x04, /// \brief Allow non-dependent types to differ, e.g., when performing /// template argument deduction from a function call where conversions /// may apply. TDF_SkipNonDependent = 0x08, /// \brief Whether we are performing template argument deduction for /// parameters and arguments in a top-level template argument TDF_TopLevelParameterTypeList = 0x10, /// \brief Within template argument deduction from overload resolution per /// C++ [over.over] allow matching function types that are compatible in /// terms of noreturn and default calling convention adjustments. TDF_InOverloadResolution = 0x20 }; } using namespace clang; /// \brief Compare two APSInts, extending and switching the sign as /// necessary to compare their values regardless of underlying type. static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { if (Y.getBitWidth() > X.getBitWidth()) X = X.extend(Y.getBitWidth()); else if (Y.getBitWidth() < X.getBitWidth()) Y = Y.extend(X.getBitWidth()); // If there is a signedness mismatch, correct it. if (X.isSigned() != Y.isSigned()) { // If the signed value is negative, then the values cannot be the same. if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) return false; Y.setIsSigned(true); X.setIsSigned(true); } return X == Y; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced); /// \brief Whether template argument deduction for two reference parameters /// resulted in the argument type, parameter type, or neither type being more /// qualified than the other. enum DeductionQualifierComparison { NeitherMoreQualified = 0, ParamMoreQualified, ArgMoreQualified }; /// \brief Stores the result of comparing two reference parameters while /// performing template argument deduction for partial ordering of function /// templates. struct RefParamPartialOrderingComparison { /// \brief Whether the parameter type is an rvalue reference type. bool ParamIsRvalueRef; /// \brief Whether the argument type is an rvalue reference type. bool ArgIsRvalueRef; /// \brief Whether the parameter or argument (or neither) is more qualified. DeductionQualifierComparison Qualifiers; }; static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl & Deduced, unsigned TDF, bool PartialOrdering = false, SmallVectorImpl * RefParamComparisons = 0); static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument *Params, unsigned NumParams, const TemplateArgument *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced); /// \brief If the given expression is of a form that permits the deduction /// of a non-type template parameter, return the declaration of that /// non-type template parameter. static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { // If we are within an alias template, the expression may have undergone // any number of parameter substitutions already. while (1) { if (ImplicitCastExpr *IC = dyn_cast(E)) E = IC->getSubExpr(); else if (SubstNonTypeTemplateParmExpr *Subst = dyn_cast(E)) E = Subst->getReplacement(); else break; } if (DeclRefExpr *DRE = dyn_cast(E)) return dyn_cast(DRE->getDecl()); return 0; } /// \brief Determine whether two declaration pointers refer to the same /// declaration. static bool isSameDeclaration(Decl *X, Decl *Y) { if (NamedDecl *NX = dyn_cast(X)) X = NX->getUnderlyingDecl(); if (NamedDecl *NY = dyn_cast(Y)) Y = NY->getUnderlyingDecl(); return X->getCanonicalDecl() == Y->getCanonicalDecl(); } /// \brief Verify that the given, deduced template arguments are compatible. /// /// \returns The deduced template argument, or a NULL template argument if /// the deduced template arguments were incompatible. static DeducedTemplateArgument checkDeducedTemplateArguments(ASTContext &Context, const DeducedTemplateArgument &X, const DeducedTemplateArgument &Y) { // We have no deduction for one or both of the arguments; they're compatible. if (X.isNull()) return Y; if (Y.isNull()) return X; switch (X.getKind()) { case TemplateArgument::Null: llvm_unreachable("Non-deduced template arguments handled above"); case TemplateArgument::Type: // If two template type arguments have the same type, they're compatible. if (Y.getKind() == TemplateArgument::Type && Context.hasSameType(X.getAsType(), Y.getAsType())) return X; return DeducedTemplateArgument(); case TemplateArgument::Integral: // If we deduced a constant in one case and either a dependent expression or // declaration in another case, keep the integral constant. // If both are integral constants with the same value, keep that value. if (Y.getKind() == TemplateArgument::Expression || Y.getKind() == TemplateArgument::Declaration || (Y.getKind() == TemplateArgument::Integral && hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()))) return DeducedTemplateArgument(X, X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Template: if (Y.getKind() == TemplateArgument::Template && Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::TemplateExpansion: if (Y.getKind() == TemplateArgument::TemplateExpansion && Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), Y.getAsTemplateOrTemplatePattern())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Expression: // If we deduced a dependent expression in one case and either an integral // constant or a declaration in another case, keep the integral constant // or declaration. if (Y.getKind() == TemplateArgument::Integral || Y.getKind() == TemplateArgument::Declaration) return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); if (Y.getKind() == TemplateArgument::Expression) { // Compare the expressions for equality llvm::FoldingSetNodeID ID1, ID2; X.getAsExpr()->Profile(ID1, Context, true); Y.getAsExpr()->Profile(ID2, Context, true); if (ID1 == ID2) return X; } // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Declaration: // If we deduced a declaration and a dependent expression, keep the // declaration. if (Y.getKind() == TemplateArgument::Expression) return X; // If we deduced a declaration and an integral constant, keep the // integral constant. if (Y.getKind() == TemplateArgument::Integral) return Y; // If we deduced two declarations, make sure they they refer to the // same declaration. if (Y.getKind() == TemplateArgument::Declaration && isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && X.isDeclForReferenceParam() == Y.isDeclForReferenceParam()) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::NullPtr: // If we deduced a null pointer and a dependent expression, keep the // null pointer. if (Y.getKind() == TemplateArgument::Expression) return X; // If we deduced a null pointer and an integral constant, keep the // integral constant. if (Y.getKind() == TemplateArgument::Integral) return Y; // If we deduced two null pointers, make sure they have the same type. if (Y.getKind() == TemplateArgument::NullPtr && Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Pack: if (Y.getKind() != TemplateArgument::Pack || X.pack_size() != Y.pack_size()) return DeducedTemplateArgument(); for (TemplateArgument::pack_iterator XA = X.pack_begin(), XAEnd = X.pack_end(), YA = Y.pack_begin(); XA != XAEnd; ++XA, ++YA) { if (checkDeducedTemplateArguments(Context, DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) .isNull()) return DeducedTemplateArgument(); } return X; } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Deduce the value of the given non-type template parameter /// from the given constant. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, llvm::APSInt Value, QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType, DeducedFromArrayBound); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } /// \brief Deduce the value of the given non-type template parameter /// from the given type- or value-dependent expression. /// /// \returns true if deduction succeeded, false otherwise. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, Expr *Value, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); assert((Value->isTypeDependent() || Value->isValueDependent()) && "Expression template argument must be type- or value-dependent."); DeducedTemplateArgument NewDeduced(Value); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } /// \brief Deduce the value of the given non-type template parameter /// from the given declaration. /// /// \returns true if deduction succeeded, false otherwise. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, ValueDecl *D, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); D = D ? cast(D->getCanonicalDecl()) : 0; TemplateArgument New(D, NTTP->getType()->isReferenceType()); DeducedTemplateArgument NewDeduced(New); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, TemplateName Param, TemplateName Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); if (!ParamDecl) { // The parameter type is dependent and is not a template template parameter, // so there is nothing that we can deduce. return Sema::TDK_Success; } if (TemplateTemplateParmDecl *TempParam = dyn_cast(ParamDecl)) { DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[TempParam->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = TempParam; Info.FirstArg = Deduced[TempParam->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[TempParam->getIndex()] = Result; return Sema::TDK_Success; } // Verify that the two template names are equivalent. if (S.Context.hasSameTemplateName(Param, Arg)) return Sema::TDK_Success; // Mismatch of non-dependent template parameter to argument. Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } /// \brief Deduce the template arguments by comparing the template parameter /// type (which is a template-id) with the template argument type. /// /// \param S the Sema /// /// \param TemplateParams the template parameters that we are deducing /// /// \param Param the parameter type /// /// \param Arg the argument type /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateSpecializationType *Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(Arg.isCanonical() && "Argument type must be canonical"); // Check whether the template argument is a dependent template-id. if (const TemplateSpecializationType *SpecArg = dyn_cast(Arg)) { // Perform template argument deduction for the template name. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Param->getTemplateName(), SpecArg->getTemplateName(), Info, Deduced)) return Result; // Perform template argument deduction on each template // argument. Ignore any missing/extra arguments, since they could be // filled in by default arguments. return DeduceTemplateArguments(S, TemplateParams, Param->getArgs(), Param->getNumArgs(), SpecArg->getArgs(), SpecArg->getNumArgs(), Info, Deduced); } // If the argument type is a class template specialization, we // perform template argument deduction using its template // arguments. const RecordType *RecordArg = dyn_cast(Arg); if (!RecordArg) { Info.FirstArg = TemplateArgument(QualType(Param, 0)); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } ClassTemplateSpecializationDecl *SpecArg = dyn_cast(RecordArg->getDecl()); if (!SpecArg) { Info.FirstArg = TemplateArgument(QualType(Param, 0)); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } // Perform template argument deduction for the template name. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Param->getTemplateName(), TemplateName(SpecArg->getSpecializedTemplate()), Info, Deduced)) return Result; // Perform template argument deduction for the template arguments. return DeduceTemplateArguments(S, TemplateParams, Param->getArgs(), Param->getNumArgs(), SpecArg->getTemplateArgs().data(), SpecArg->getTemplateArgs().size(), Info, Deduced); } /// \brief Determines whether the given type is an opaque type that /// might be more qualified when instantiated. static bool IsPossiblyOpaquelyQualifiedType(QualType T) { switch (T->getTypeClass()) { case Type::TypeOfExpr: case Type::TypeOf: case Type::DependentName: case Type::Decltype: case Type::UnresolvedUsing: case Type::TemplateTypeParm: return true; case Type::ConstantArray: case Type::IncompleteArray: case Type::VariableArray: case Type::DependentSizedArray: return IsPossiblyOpaquelyQualifiedType( cast(T)->getElementType()); default: return false; } } /// \brief Retrieve the depth and index of a template parameter. static std::pair getDepthAndIndex(NamedDecl *ND) { if (TemplateTypeParmDecl *TTP = dyn_cast(ND)) return std::make_pair(TTP->getDepth(), TTP->getIndex()); if (NonTypeTemplateParmDecl *NTTP = dyn_cast(ND)) return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); TemplateTemplateParmDecl *TTP = cast(ND); return std::make_pair(TTP->getDepth(), TTP->getIndex()); } /// \brief Retrieve the depth and index of an unexpanded parameter pack. static std::pair getDepthAndIndex(UnexpandedParameterPack UPP) { if (const TemplateTypeParmType *TTP = UPP.first.dyn_cast()) return std::make_pair(TTP->getDepth(), TTP->getIndex()); return getDepthAndIndex(UPP.first.get()); } /// \brief Helper function to build a TemplateParameter when we don't /// know its type statically. static TemplateParameter makeTemplateParameter(Decl *D) { if (TemplateTypeParmDecl *TTP = dyn_cast(D)) return TemplateParameter(TTP); if (NonTypeTemplateParmDecl *NTTP = dyn_cast(D)) return TemplateParameter(NTTP); return TemplateParameter(cast(D)); } typedef SmallVector, 2> NewlyDeducedPacksType; /// \brief Prepare to perform template argument deduction for all of the /// arguments in a set of argument packs. static void PrepareArgumentPackDeduction(Sema &S, SmallVectorImpl &Deduced, ArrayRef PackIndices, SmallVectorImpl &SavedPacks, NewlyDeducedPacksType &NewlyDeducedPacks) { // Save the deduced template arguments for each parameter pack expanded // by this pack expansion, then clear out the deduction. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { // Save the previously-deduced argument pack, then clear it out so that we // can deduce a new argument pack. SavedPacks[I] = Deduced[PackIndices[I]]; Deduced[PackIndices[I]] = TemplateArgument(); if (!S.CurrentInstantiationScope) continue; // If the template argument pack was explicitly specified, add that to // the set of deduced arguments. const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; if (NamedDecl *PartiallySubstitutedPack = S.CurrentInstantiationScope->getPartiallySubstitutedPack( &ExplicitArgs, &NumExplicitArgs)) { if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I]) NewlyDeducedPacks[I].append(ExplicitArgs, ExplicitArgs + NumExplicitArgs); } } } /// \brief Finish template argument deduction for a set of argument packs, /// producing the argument packs and checking for consistency with prior /// deductions. static Sema::TemplateDeductionResult FinishArgumentPackDeduction(Sema &S, TemplateParameterList *TemplateParams, bool HasAnyArguments, SmallVectorImpl &Deduced, ArrayRef PackIndices, SmallVectorImpl &SavedPacks, NewlyDeducedPacksType &NewlyDeducedPacks, TemplateDeductionInfo &Info) { // Build argument packs for each of the parameter packs expanded by this // pack expansion. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { // We were not able to deduce anything for this parameter pack, // so just restore the saved argument pack. Deduced[PackIndices[I]] = SavedPacks[I]; continue; } DeducedTemplateArgument NewPack; if (NewlyDeducedPacks[I].empty()) { // If we deduced an empty argument pack, create it now. NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); } else { TemplateArgument *ArgumentPack = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), ArgumentPack); NewPack = DeducedTemplateArgument(TemplateArgument(ArgumentPack, NewlyDeducedPacks[I].size()), NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); } DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); if (Result.isNull()) { Info.Param = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); Info.FirstArg = SavedPacks[I]; Info.SecondArg = NewPack; return Sema::TDK_Inconsistent; } Deduced[PackIndices[I]] = Result; } return Sema::TDK_Success; } /// \brief Deduce the template arguments by comparing the list of parameter /// types to the list of argument types, as in the parameter-type-lists of /// function types (C++ [temp.deduct.type]p10). /// /// \param S The semantic analysis object within which we are deducing /// /// \param TemplateParams The template parameters that we are deducing /// /// \param Params The list of parameter types /// /// \param NumParams The number of types in \c Params /// /// \param Args The list of argument types /// /// \param NumArgs The number of types in \c Args /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe /// how template argument deduction is performed. /// /// \param PartialOrdering If true, we are performing template argument /// deduction for during partial ordering for a call /// (C++0x [temp.deduct.partial]). /// /// \param RefParamComparisons If we're performing template argument deduction /// in the context of partial ordering, the set of qualifier comparisons. /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const QualType *Params, unsigned NumParams, const QualType *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF, bool PartialOrdering = false, SmallVectorImpl * RefParamComparisons = 0) { // Fast-path check to see if we have too many/too few arguments. if (NumParams != NumArgs && !(NumParams && isa(Params[NumParams - 1])) && !(NumArgs && isa(Args[NumArgs - 1]))) return Sema::TDK_MiscellaneousDeductionFailure; // C++0x [temp.deduct.type]p10: // Similarly, if P has a form that contains (T), then each parameter type // Pi of the respective parameter-type- list of P is compared with the // corresponding parameter type Ai of the corresponding parameter-type-list // of A. [...] unsigned ArgIdx = 0, ParamIdx = 0; for (; ParamIdx != NumParams; ++ParamIdx) { // Check argument types. const PackExpansionType *Expansion = dyn_cast(Params[ParamIdx]); if (!Expansion) { // Simple case: compare the parameter and argument types at this point. // Make sure we have an argument. if (ArgIdx >= NumArgs) return Sema::TDK_MiscellaneousDeductionFailure; if (isa(Args[ArgIdx])) { // C++0x [temp.deduct.type]p22: // If the original function parameter associated with A is a function // parameter pack and the function parameter associated with P is not // a function parameter pack, then template argument deduction fails. return Sema::TDK_MiscellaneousDeductionFailure; } if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Params[ParamIdx], Args[ArgIdx], Info, Deduced, TDF, PartialOrdering, RefParamComparisons)) return Result; ++ArgIdx; continue; } // C++0x [temp.deduct.type]p5: // The non-deduced contexts are: // - A function parameter pack that does not occur at the end of the // parameter-declaration-clause. if (ParamIdx + 1 < NumParams) return Sema::TDK_Success; // C++0x [temp.deduct.type]p10: // If the parameter-declaration corresponding to Pi is a function // parameter pack, then the type of its declarator- id is compared with // each remaining parameter type in the parameter-type-list of A. Each // comparison deduces template arguments for subsequent positions in the // template parameter packs expanded by the function parameter pack. // Compute the set of template parameter indices that correspond to // parameter packs expanded by the pack expansion. SmallVector PackIndices; QualType Pattern = Expansion->getPattern(); { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; S.collectUnexpandedParameterPacks(Pattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; PackIndices.push_back(Index); } } } assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); // Keep track of the deduced template arguments for each parameter pack // expanded by this pack expansion (the outer index) and for each // template argument (the inner SmallVectors). NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); SmallVector SavedPacks(PackIndices.size()); PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks); bool HasAnyArguments = false; for (; ArgIdx < NumArgs; ++ArgIdx) { HasAnyArguments = true; // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced, TDF, PartialOrdering, RefParamComparisons)) return Result; // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; if (!DeducedArg.isNull()) { NewlyDeducedPacks[I].push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } } } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (Sema::TemplateDeductionResult Result = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks, Info)) return Result; } // Make sure we don't have any extra arguments. if (ArgIdx < NumArgs) return Sema::TDK_MiscellaneousDeductionFailure; return Sema::TDK_Success; } /// \brief Determine whether the parameter has qualifiers that are either /// inconsistent with or a superset of the argument's qualifiers. static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, QualType ArgType) { Qualifiers ParamQs = ParamType.getQualifiers(); Qualifiers ArgQs = ArgType.getQualifiers(); if (ParamQs == ArgQs) return false; // Mismatched (but not missing) Objective-C GC attributes. if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && ParamQs.hasObjCGCAttr()) return true; // Mismatched (but not missing) address spaces. if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() && ParamQs.hasAddressSpace()) return true; // Mismatched (but not missing) Objective-C lifetime qualifiers. if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() && ParamQs.hasObjCLifetime()) return true; // CVR qualifier superset. return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) && ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers()) == ParamQs.getCVRQualifiers()); } /// \brief Compare types for equality with respect to possibly compatible /// function types (noreturn adjustment, implicit calling conventions). If any /// of parameter and argument is not a function, just perform type comparison. /// /// \param Param the template parameter type. /// /// \param Arg the argument type. bool Sema::isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg) { const FunctionType *ParamFunction = Param->getAs(), *ArgFunction = Arg->getAs(); // Just compare if not functions. if (!ParamFunction || !ArgFunction) return Param == Arg; // Noreturn adjustment. QualType AdjustedParam; if (IsNoReturnConversion(Param, Arg, AdjustedParam)) return Arg == Context.getCanonicalType(AdjustedParam); // FIXME: Compatible calling conventions. return Param == Arg; } /// \brief Deduce the template arguments by comparing the parameter type and /// the argument type (C++ [temp.deduct.type]). /// /// \param S the semantic analysis object within which we are deducing /// /// \param TemplateParams the template parameters that we are deducing /// /// \param ParamIn the parameter type /// /// \param ArgIn the argument type /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe /// how template argument deduction is performed. /// /// \param PartialOrdering Whether we're performing template argument deduction /// in the context of partial ordering (C++0x [temp.deduct.partial]). /// /// \param RefParamComparisons If we're performing template argument deduction /// in the context of partial ordering, the set of qualifier comparisons. /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType ParamIn, QualType ArgIn, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF, bool PartialOrdering, SmallVectorImpl * RefParamComparisons) { // We only want to look at the canonical types, since typedefs and // sugar are not part of template argument deduction. QualType Param = S.Context.getCanonicalType(ParamIn); QualType Arg = S.Context.getCanonicalType(ArgIn); // If the argument type is a pack expansion, look at its pattern. // This isn't explicitly called out if (const PackExpansionType *ArgExpansion = dyn_cast(Arg)) Arg = ArgExpansion->getPattern(); if (PartialOrdering) { // C++0x [temp.deduct.partial]p5: // Before the partial ordering is done, certain transformations are // performed on the types used for partial ordering: // - If P is a reference type, P is replaced by the type referred to. const ReferenceType *ParamRef = Param->getAs(); if (ParamRef) Param = ParamRef->getPointeeType(); // - If A is a reference type, A is replaced by the type referred to. const ReferenceType *ArgRef = Arg->getAs(); if (ArgRef) Arg = ArgRef->getPointeeType(); if (RefParamComparisons && ParamRef && ArgRef) { // C++0x [temp.deduct.partial]p6: // If both P and A were reference types (before being replaced with the // type referred to above), determine which of the two types (if any) is // more cv-qualified than the other; otherwise the types are considered // to be equally cv-qualified for partial ordering purposes. The result // of this determination will be used below. // // We save this information for later, using it only when deduction // succeeds in both directions. RefParamPartialOrderingComparison Comparison; Comparison.ParamIsRvalueRef = ParamRef->getAs(); Comparison.ArgIsRvalueRef = ArgRef->getAs(); Comparison.Qualifiers = NeitherMoreQualified; Qualifiers ParamQuals = Param.getQualifiers(); Qualifiers ArgQuals = Arg.getQualifiers(); if (ParamQuals.isStrictSupersetOf(ArgQuals)) Comparison.Qualifiers = ParamMoreQualified; else if (ArgQuals.isStrictSupersetOf(ParamQuals)) Comparison.Qualifiers = ArgMoreQualified; RefParamComparisons->push_back(Comparison); } // C++0x [temp.deduct.partial]p7: // Remove any top-level cv-qualifiers: // - If P is a cv-qualified type, P is replaced by the cv-unqualified // version of P. Param = Param.getUnqualifiedType(); // - If A is a cv-qualified type, A is replaced by the cv-unqualified // version of A. Arg = Arg.getUnqualifiedType(); } else { // C++0x [temp.deduct.call]p4 bullet 1: // - If the original P is a reference type, the deduced A (i.e., the type // referred to by the reference) can be more cv-qualified than the // transformed A. if (TDF & TDF_ParamWithReferenceType) { Qualifiers Quals; QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); Quals.setCVRQualifiers(Quals.getCVRQualifiers() & Arg.getCVRQualifiers()); Param = S.Context.getQualifiedType(UnqualParam, Quals); } if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) { // C++0x [temp.deduct.type]p10: // If P and A are function types that originated from deduction when // taking the address of a function template (14.8.2.2) or when deducing // template arguments from a function declaration (14.8.2.6) and Pi and // Ai are parameters of the top-level parameter-type-list of P and A, // respectively, Pi is adjusted if it is an rvalue reference to a // cv-unqualified template parameter and Ai is an lvalue reference, in // which case the type of Pi is changed to be the template parameter // type (i.e., T&& is changed to simply T). [ Note: As a result, when // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be // deduced as X&. - end note ] TDF &= ~TDF_TopLevelParameterTypeList; if (const RValueReferenceType *ParamRef = Param->getAs()) { if (isa(ParamRef->getPointeeType()) && !ParamRef->getPointeeType().getQualifiers()) if (Arg->isLValueReferenceType()) Param = ParamRef->getPointeeType(); } } } // C++ [temp.deduct.type]p9: // A template type argument T, a template template argument TT or a // template non-type argument i can be deduced if P and A have one of // the following forms: // // T // cv-list T if (const TemplateTypeParmType *TemplateTypeParm = Param->getAs()) { // Just skip any attempts to deduce from a placeholder type. if (Arg->isPlaceholderType()) return Sema::TDK_Success; unsigned Index = TemplateTypeParm->getIndex(); bool RecanonicalizeArg = false; // If the argument type is an array type, move the qualifiers up to the // top level, so they can be matched with the qualifiers on the parameter. if (isa(Arg)) { Qualifiers Quals; Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); if (Quals) { Arg = S.Context.getQualifiedType(Arg, Quals); RecanonicalizeArg = true; } } // The argument type can not be less qualified than the parameter // type. if (!(TDF & TDF_IgnoreQualifiers) && hasInconsistentOrSupersetQualifiersOf(Param, Arg)) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_Underqualified; } assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function"); QualType DeducedType = Arg; // Remove any qualifiers on the parameter from the deduced type. // We checked the qualifiers for consistency above. Qualifiers DeducedQs = DeducedType.getQualifiers(); Qualifiers ParamQs = Param.getQualifiers(); DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers()); if (ParamQs.hasObjCGCAttr()) DeducedQs.removeObjCGCAttr(); if (ParamQs.hasAddressSpace()) DeducedQs.removeAddressSpace(); if (ParamQs.hasObjCLifetime()) DeducedQs.removeObjCLifetime(); // Objective-C ARC: // If template deduction would produce a lifetime qualifier on a type // that is not a lifetime type, template argument deduction fails. if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() && !DeducedType->isDependentType()) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_Underqualified; } // Objective-C ARC: // If template deduction would produce an argument type with lifetime type // but no lifetime qualifier, the __strong lifetime qualifier is inferred. if (S.getLangOpts().ObjCAutoRefCount && DeducedType->isObjCLifetimeType() && !DeducedQs.hasObjCLifetime()) DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong); DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(), DeducedQs); if (RecanonicalizeArg) DeducedType = S.Context.getCanonicalType(DeducedType); DeducedTemplateArgument NewDeduced(DeducedType); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[Index], NewDeduced); if (Result.isNull()) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = Deduced[Index]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[Index] = Result; return Sema::TDK_Success; } // Set up the template argument deduction information for a failure. Info.FirstArg = TemplateArgument(ParamIn); Info.SecondArg = TemplateArgument(ArgIn); // If the parameter is an already-substituted template parameter // pack, do nothing: we don't know which of its arguments to look // at, so we have to wait until all of the parameter packs in this // expansion have arguments. if (isa(Param)) return Sema::TDK_Success; // Check the cv-qualifiers on the parameter and argument types. CanQualType CanParam = S.Context.getCanonicalType(Param); CanQualType CanArg = S.Context.getCanonicalType(Arg); if (!(TDF & TDF_IgnoreQualifiers)) { if (TDF & TDF_ParamWithReferenceType) { if (hasInconsistentOrSupersetQualifiersOf(Param, Arg)) return Sema::TDK_NonDeducedMismatch; } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) return Sema::TDK_NonDeducedMismatch; } // If the parameter type is not dependent, there is nothing to deduce. if (!Param->isDependentType()) { if (!(TDF & TDF_SkipNonDependent)) { bool NonDeduced = (TDF & TDF_InOverloadResolution)? !S.isSameOrCompatibleFunctionType(CanParam, CanArg) : Param != Arg; if (NonDeduced) { return Sema::TDK_NonDeducedMismatch; } } return Sema::TDK_Success; } } else if (!Param->isDependentType()) { CanQualType ParamUnqualType = CanParam.getUnqualifiedType(), ArgUnqualType = CanArg.getUnqualifiedType(); bool Success = (TDF & TDF_InOverloadResolution)? S.isSameOrCompatibleFunctionType(ParamUnqualType, ArgUnqualType) : ParamUnqualType == ArgUnqualType; if (Success) return Sema::TDK_Success; } switch (Param->getTypeClass()) { // Non-canonical types cannot appear here. #define NON_CANONICAL_TYPE(Class, Base) \ case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class); #define TYPE(Class, Base) #include "clang/AST/TypeNodes.def" case Type::TemplateTypeParm: case Type::SubstTemplateTypeParmPack: llvm_unreachable("Type nodes handled above"); // These types cannot be dependent, so simply check whether the types are // the same. case Type::Builtin: case Type::VariableArray: case Type::Vector: case Type::FunctionNoProto: case Type::Record: case Type::Enum: case Type::ObjCObject: case Type::ObjCInterface: case Type::ObjCObjectPointer: { if (TDF & TDF_SkipNonDependent) return Sema::TDK_Success; if (TDF & TDF_IgnoreQualifiers) { Param = Param.getUnqualifiedType(); Arg = Arg.getUnqualifiedType(); } return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch; } // _Complex T [placeholder extension] case Type::Complex: if (const ComplexType *ComplexArg = Arg->getAs()) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getElementType(), ComplexArg->getElementType(), Info, Deduced, TDF); return Sema::TDK_NonDeducedMismatch; // _Atomic T [extension] case Type::Atomic: if (const AtomicType *AtomicArg = Arg->getAs()) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getValueType(), AtomicArg->getValueType(), Info, Deduced, TDF); return Sema::TDK_NonDeducedMismatch; // T * case Type::Pointer: { QualType PointeeType; if (const PointerType *PointerArg = Arg->getAs()) { PointeeType = PointerArg->getPointeeType(); } else if (const ObjCObjectPointerType *PointerArg = Arg->getAs()) { PointeeType = PointerArg->getPointeeType(); } else { return Sema::TDK_NonDeducedMismatch; } unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), PointeeType, Info, Deduced, SubTDF); } // T & case Type::LValueReference: { const LValueReferenceType *ReferenceArg = Arg->getAs(); if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), ReferenceArg->getPointeeType(), Info, Deduced, 0); } // T && [C++0x] case Type::RValueReference: { const RValueReferenceType *ReferenceArg = Arg->getAs(); if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), ReferenceArg->getPointeeType(), Info, Deduced, 0); } // T [] (implied, but not stated explicitly) case Type::IncompleteArray: { const IncompleteArrayType *IncompleteArrayArg = S.Context.getAsIncompleteArrayType(Arg); if (!IncompleteArrayArg) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, S.Context.getAsIncompleteArrayType(Param)->getElementType(), IncompleteArrayArg->getElementType(), Info, Deduced, SubTDF); } // T [integer-constant] case Type::ConstantArray: { const ConstantArrayType *ConstantArrayArg = S.Context.getAsConstantArrayType(Arg); if (!ConstantArrayArg) return Sema::TDK_NonDeducedMismatch; const ConstantArrayType *ConstantArrayParm = S.Context.getAsConstantArrayType(Param); if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ConstantArrayParm->getElementType(), ConstantArrayArg->getElementType(), Info, Deduced, SubTDF); } // type [i] case Type::DependentSizedArray: { const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); if (!ArrayArg) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; // Check the element type of the arrays const DependentSizedArrayType *DependentArrayParm = S.Context.getAsDependentSizedArrayType(Param); if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, DependentArrayParm->getElementType(), ArrayArg->getElementType(), Info, Deduced, SubTDF)) return Result; // Determine the array bound is something we can deduce. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; // We can perform template argument deduction for the given non-type // template parameter. assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument at depth > 0"); if (const ConstantArrayType *ConstantArrayArg = dyn_cast(ArrayArg)) { llvm::APSInt Size(ConstantArrayArg->getSize()); return DeduceNonTypeTemplateArgument(S, NTTP, Size, S.Context.getSizeType(), /*ArrayBound=*/true, Info, Deduced); } if (const DependentSizedArrayType *DependentArrayArg = dyn_cast(ArrayArg)) if (DependentArrayArg->getSizeExpr()) return DeduceNonTypeTemplateArgument(S, NTTP, DependentArrayArg->getSizeExpr(), Info, Deduced); // Incomplete type does not match a dependently-sized array type return Sema::TDK_NonDeducedMismatch; } // type(*)(T) // T(*)() // T(*)(T) case Type::FunctionProto: { unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList; const FunctionProtoType *FunctionProtoArg = dyn_cast(Arg); if (!FunctionProtoArg) return Sema::TDK_NonDeducedMismatch; const FunctionProtoType *FunctionProtoParam = cast(Param); if (FunctionProtoParam->getTypeQuals() != FunctionProtoArg->getTypeQuals() || FunctionProtoParam->getRefQualifier() != FunctionProtoArg->getRefQualifier() || FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) return Sema::TDK_NonDeducedMismatch; // Check return types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, FunctionProtoParam->getResultType(), FunctionProtoArg->getResultType(), Info, Deduced, 0)) return Result; return DeduceTemplateArguments(S, TemplateParams, FunctionProtoParam->arg_type_begin(), FunctionProtoParam->getNumArgs(), FunctionProtoArg->arg_type_begin(), FunctionProtoArg->getNumArgs(), Info, Deduced, SubTDF); } case Type::InjectedClassName: { // Treat a template's injected-class-name as if the template // specialization type had been used. Param = cast(Param) ->getInjectedSpecializationType(); assert(isa(Param) && "injected class name is not a template specialization type"); // fall through } // template-name (where template-name refers to a class template) // template-name // TT // TT // TT<> case Type::TemplateSpecialization: { const TemplateSpecializationType *SpecParam = cast(Param); // Try to deduce template arguments from the template-id. Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info, Deduced); if (Result && (TDF & TDF_DerivedClass)) { // C++ [temp.deduct.call]p3b3: // If P is a class, and P has the form template-id, then A can be a // derived class of the deduced A. Likewise, if P is a pointer to a // class of the form template-id, A can be a pointer to a derived // class pointed to by the deduced A. // // More importantly: // These alternatives are considered only if type deduction would // otherwise fail. if (const RecordType *RecordT = Arg->getAs()) { // We cannot inspect base classes as part of deduction when the type // is incomplete, so either instantiate any templates necessary to // complete the type, or skip over it if it cannot be completed. if (S.RequireCompleteType(Info.getLocation(), Arg, 0)) return Result; // Use data recursion to crawl through the list of base classes. // Visited contains the set of nodes we have already visited, while // ToVisit is our stack of records that we still need to visit. llvm::SmallPtrSet Visited; SmallVector ToVisit; ToVisit.push_back(RecordT); bool Successful = false; SmallVector DeducedOrig(Deduced.begin(), Deduced.end()); while (!ToVisit.empty()) { // Retrieve the next class in the inheritance hierarchy. const RecordType *NextT = ToVisit.pop_back_val(); // If we have already seen this type, skip it. if (!Visited.insert(NextT)) continue; // If this is a base class, try to perform template argument // deduction from it. if (NextT != RecordT) { TemplateDeductionInfo BaseInfo(Info.getLocation()); Sema::TemplateDeductionResult BaseResult = DeduceTemplateArguments(S, TemplateParams, SpecParam, QualType(NextT, 0), BaseInfo, Deduced); // If template argument deduction for this base was successful, // note that we had some success. Otherwise, ignore any deductions // from this base class. if (BaseResult == Sema::TDK_Success) { Successful = true; DeducedOrig.clear(); DeducedOrig.append(Deduced.begin(), Deduced.end()); Info.Param = BaseInfo.Param; Info.FirstArg = BaseInfo.FirstArg; Info.SecondArg = BaseInfo.SecondArg; } else Deduced = DeducedOrig; } // Visit base classes CXXRecordDecl *Next = cast(NextT->getDecl()); for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), BaseEnd = Next->bases_end(); Base != BaseEnd; ++Base) { assert(Base->getType()->isRecordType() && "Base class that isn't a record?"); ToVisit.push_back(Base->getType()->getAs()); } } if (Successful) return Sema::TDK_Success; } } return Result; } // T type::* // T T::* // T (type::*)() // type (T::*)() // type (type::*)(T) // type (T::*)(T) // T (type::*)(T) // T (T::*)() // T (T::*)(T) case Type::MemberPointer: { const MemberPointerType *MemPtrParam = cast(Param); const MemberPointerType *MemPtrArg = dyn_cast(Arg); if (!MemPtrArg) return Sema::TDK_NonDeducedMismatch; if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, MemPtrParam->getPointeeType(), MemPtrArg->getPointeeType(), Info, Deduced, TDF & TDF_IgnoreQualifiers)) return Result; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, QualType(MemPtrParam->getClass(), 0), QualType(MemPtrArg->getClass(), 0), Info, Deduced, TDF & TDF_IgnoreQualifiers); } // (clang extension) // // type(^)(T) // T(^)() // T(^)(T) case Type::BlockPointer: { const BlockPointerType *BlockPtrParam = cast(Param); const BlockPointerType *BlockPtrArg = dyn_cast(Arg); if (!BlockPtrArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, BlockPtrParam->getPointeeType(), BlockPtrArg->getPointeeType(), Info, Deduced, 0); } // (clang extension) // // T __attribute__(((ext_vector_type()))) case Type::ExtVector: { const ExtVectorType *VectorParam = cast(Param); if (const ExtVectorType *VectorArg = dyn_cast(Arg)) { // Make sure that the vectors have the same number of elements. if (VectorParam->getNumElements() != VectorArg->getNumElements()) return Sema::TDK_NonDeducedMismatch; // Perform deduction on the element types. return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF); } if (const DependentSizedExtVectorType *VectorArg = dyn_cast(Arg)) { // We can't check the number of elements, since the argument has a // dependent number of elements. This can only occur during partial // ordering. // Perform deduction on the element types. return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF); } return Sema::TDK_NonDeducedMismatch; } // (clang extension) // // T __attribute__(((ext_vector_type(N)))) case Type::DependentSizedExtVector: { const DependentSizedExtVectorType *VectorParam = cast(Param); if (const ExtVectorType *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); ArgSize = VectorArg->getNumElements(); return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy, false, Info, Deduced); } if (const DependentSizedExtVectorType *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(), Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } case Type::TypeOfExpr: case Type::TypeOf: case Type::DependentName: case Type::UnresolvedUsing: case Type::Decltype: case Type::UnaryTransform: case Type::Auto: case Type::DependentTemplateSpecialization: case Type::PackExpansion: // No template argument deduction for these types return Sema::TDK_Success; } llvm_unreachable("Invalid Type Class!"); } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { // If the template argument is a pack expansion, perform template argument // deduction against the pattern of that expansion. This only occurs during // partial ordering. if (Arg.isPackExpansion()) Arg = Arg.getPackExpansionPattern(); switch (Param.getKind()) { case TemplateArgument::Null: llvm_unreachable("Null template argument in parameter list"); case TemplateArgument::Type: if (Arg.getKind() == TemplateArgument::Type) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Param.getAsType(), Arg.getAsType(), Info, Deduced, 0); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Template: if (Arg.getKind() == TemplateArgument::Template) return DeduceTemplateArguments(S, TemplateParams, Param.getAsTemplate(), Arg.getAsTemplate(), Info, Deduced); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::TemplateExpansion: llvm_unreachable("caller should handle pack expansions"); case TemplateArgument::Declaration: if (Arg.getKind() == TemplateArgument::Declaration && isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) && Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam()) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::NullPtr: if (Arg.getKind() == TemplateArgument::NullPtr && S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType())) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Integral: if (Arg.getKind() == TemplateArgument::Integral) { if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral())) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } if (Arg.getKind() == TemplateArgument::Expression) { Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Expression: { if (NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(Param.getAsExpr())) { if (Arg.getKind() == TemplateArgument::Integral) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsIntegral(), Arg.getIntegralType(), /*ArrayBound=*/false, Info, Deduced); if (Arg.getKind() == TemplateArgument::Expression) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(), Info, Deduced); if (Arg.getKind() == TemplateArgument::Declaration) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(), Info, Deduced); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } // Can't deduce anything, but that's okay. return Sema::TDK_Success; } case TemplateArgument::Pack: llvm_unreachable("Argument packs should be expanded by the caller!"); } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Determine whether there is a template argument to be used for /// deduction. /// /// This routine "expands" argument packs in-place, overriding its input /// parameters so that \c Args[ArgIdx] will be the available template argument. /// /// \returns true if there is another template argument (which will be at /// \c Args[ArgIdx]), false otherwise. static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args, unsigned &ArgIdx, unsigned &NumArgs) { if (ArgIdx == NumArgs) return false; const TemplateArgument &Arg = Args[ArgIdx]; if (Arg.getKind() != TemplateArgument::Pack) return true; assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?"); Args = Arg.pack_begin(); NumArgs = Arg.pack_size(); ArgIdx = 0; return ArgIdx < NumArgs; } /// \brief Determine whether the given set of template arguments has a pack /// expansion that is not the last template argument. static bool hasPackExpansionBeforeEnd(const TemplateArgument *Args, unsigned NumArgs) { unsigned ArgIdx = 0; while (ArgIdx < NumArgs) { const TemplateArgument &Arg = Args[ArgIdx]; // Unwrap argument packs. if (Args[ArgIdx].getKind() == TemplateArgument::Pack) { Args = Arg.pack_begin(); NumArgs = Arg.pack_size(); ArgIdx = 0; continue; } ++ArgIdx; if (ArgIdx == NumArgs) return false; if (Arg.isPackExpansion()) return true; } return false; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument *Params, unsigned NumParams, const TemplateArgument *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (hasPackExpansionBeforeEnd(Params, NumParams)) return Sema::TDK_Success; // C++0x [temp.deduct.type]p9: // If P has a form that contains or , then each argument Pi of the // respective template argument list P is compared with the corresponding // argument Ai of the corresponding template argument list of A. unsigned ArgIdx = 0, ParamIdx = 0; for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); ++ParamIdx) { if (!Params[ParamIdx].isPackExpansion()) { // The simple case: deduce template arguments by matching Pi and Ai. // Check whether we have enough arguments. if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) return Sema::TDK_Success; if (Args[ArgIdx].isPackExpansion()) { // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here, // but applied to pack expansions that are template arguments. return Sema::TDK_MiscellaneousDeductionFailure; } // Perform deduction for this Pi/Ai pair. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Params[ParamIdx], Args[ArgIdx], Info, Deduced)) return Result; // Move to the next argument. ++ArgIdx; continue; } // The parameter is a pack expansion. // C++0x [temp.deduct.type]p9: // If Pi is a pack expansion, then the pattern of Pi is compared with // each remaining argument in the template argument list of A. Each // comparison deduces template arguments for subsequent positions in the // template parameter packs expanded by Pi. TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); // Compute the set of template parameter indices that correspond to // parameter packs expanded by the pack expansion. SmallVector PackIndices; { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; S.collectUnexpandedParameterPacks(Pattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; PackIndices.push_back(Index); } } } assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); // FIXME: If there are no remaining arguments, we can bail out early // and set any deduced parameter packs to an empty argument pack. // The latter part of this is a (minor) correctness issue. // Save the deduced template arguments for each parameter pack expanded // by this pack expansion, then clear out the deduction. SmallVector SavedPacks(PackIndices.size()); NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks); // Keep track of the deduced template arguments for each parameter pack // expanded by this pack expansion (the outer index) and for each // template argument (the inner SmallVectors). bool HasAnyArguments = false; while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) { HasAnyArguments = true; // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced)) return Result; // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; if (!DeducedArg.isNull()) { NewlyDeducedPacks[I].push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } } ++ArgIdx; } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (Sema::TemplateDeductionResult Result = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks, Info)) return Result; } return Sema::TDK_Success; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgumentList &ParamList, const TemplateArgumentList &ArgList, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { return DeduceTemplateArguments(S, TemplateParams, ParamList.data(), ParamList.size(), ArgList.data(), ArgList.size(), Info, Deduced); } /// \brief Determine whether two template arguments are the same. static bool isSameTemplateArg(ASTContext &Context, const TemplateArgument &X, const TemplateArgument &Y) { if (X.getKind() != Y.getKind()) return false; switch (X.getKind()) { case TemplateArgument::Null: llvm_unreachable("Comparing NULL template argument"); case TemplateArgument::Type: return Context.getCanonicalType(X.getAsType()) == Context.getCanonicalType(Y.getAsType()); case TemplateArgument::Declaration: return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && X.isDeclForReferenceParam() == Y.isDeclForReferenceParam(); case TemplateArgument::NullPtr: return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()); case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: return Context.getCanonicalTemplateName( X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == Context.getCanonicalTemplateName( Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); case TemplateArgument::Integral: return X.getAsIntegral() == Y.getAsIntegral(); case TemplateArgument::Expression: { llvm::FoldingSetNodeID XID, YID; X.getAsExpr()->Profile(XID, Context, true); Y.getAsExpr()->Profile(YID, Context, true); return XID == YID; } case TemplateArgument::Pack: if (X.pack_size() != Y.pack_size()) return false; for (TemplateArgument::pack_iterator XP = X.pack_begin(), XPEnd = X.pack_end(), YP = Y.pack_begin(); XP != XPEnd; ++XP, ++YP) if (!isSameTemplateArg(Context, *XP, *YP)) return false; return true; } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Allocate a TemplateArgumentLoc where all locations have /// been initialized to the given location. /// /// \param S The semantic analysis object. /// /// \param Arg The template argument we are producing template argument /// location information for. /// /// \param NTTPType For a declaration template argument, the type of /// the non-type template parameter that corresponds to this template /// argument. /// /// \param Loc The source location to use for the resulting template /// argument. static TemplateArgumentLoc getTrivialTemplateArgumentLoc(Sema &S, const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc) { switch (Arg.getKind()) { case TemplateArgument::Null: llvm_unreachable("Can't get a NULL template argument here"); case TemplateArgument::Type: return TemplateArgumentLoc(Arg, S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); case TemplateArgument::Declaration: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .takeAs(); return TemplateArgumentLoc(TemplateArgument(E), E); } case TemplateArgument::NullPtr: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .takeAs(); return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true), E); } case TemplateArgument::Integral: { Expr *E = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs(); return TemplateArgumentLoc(TemplateArgument(E), E); } case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: { NestedNameSpecifierLocBuilder Builder; TemplateName Template = Arg.getAsTemplate(); if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc); else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc); if (Arg.getKind() == TemplateArgument::Template) return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), Loc); return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), Loc, Loc); } case TemplateArgument::Expression: return TemplateArgumentLoc(Arg, Arg.getAsExpr()); case TemplateArgument::Pack: return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Convert the given deduced template argument and add it to the set of /// fully-converted template arguments. static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, DeducedTemplateArgument Arg, NamedDecl *Template, QualType NTTPType, unsigned ArgumentPackIndex, TemplateDeductionInfo &Info, bool InFunctionTemplate, SmallVectorImpl &Output) { if (Arg.getKind() == TemplateArgument::Pack) { // This is a template argument pack, so check each of its arguments against // the template parameter. SmallVector PackedArgsBuilder; for (TemplateArgument::pack_iterator PA = Arg.pack_begin(), PAEnd = Arg.pack_end(); PA != PAEnd; ++PA) { // When converting the deduced template argument, append it to the // general output list. We need to do this so that the template argument // checking logic has all of the prior template arguments available. DeducedTemplateArgument InnerArg(*PA); InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, NTTPType, PackedArgsBuilder.size(), Info, InFunctionTemplate, Output)) return true; // Move the converted template argument into our argument pack. PackedArgsBuilder.push_back(Output.pop_back_val()); } // Create the resulting argument pack. Output.push_back(TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder.data(), PackedArgsBuilder.size())); return false; } // Convert the deduced template argument into a template // argument that we can check, almost as if the user had written // the template argument explicitly. TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType, Info.getLocation()); // Check the template argument, converting it as necessary. return S.CheckTemplateArgument(Param, ArgLoc, Template, Template->getLocation(), Template->getSourceRange().getEnd(), ArgumentPackIndex, Output, InFunctionTemplate ? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound : Sema::CTAK_Deduced) : Sema::CTAK_Specified); } /// Complete template argument deduction for a class template partial /// specialization. static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(Sema &S, ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); Sema::ContextRAII SavedContext(S, Partial); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; TemplateParameterList *PartialParams = Partial->getTemplateParameters(); for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { NamedDecl *Param = PartialParams->getParam(I); if (Deduced[I].isNull()) { Info.Param = makeTemplateParameter(Param); return Sema::TDK_Incomplete; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType, 0, Info, false, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the template // arguments of the class template partial specialization, and // verify that the instantiated template arguments are both valid // and are equivalent to the template arguments originally provided // to the class template. LocalInstantiationScope InstScope(S); ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); const ASTTemplateArgumentListInfo *PartialTemplArgInfo = Partial->getTemplateArgsAsWritten(); const TemplateArgumentLoc *PartialTemplateArgs = PartialTemplArgInfo->getTemplateArgs(); TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc, PartialTemplArgInfo->RAngleLoc); if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs, InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; if (ParamIdx >= Partial->getTemplateParameters()->size()) ParamIdx = Partial->getTemplateParameters()->size() - 1; Decl *Param = const_cast( Partial->getTemplateParameters()->getParam(ParamIdx)); Info.Param = makeTemplateParameter(Param); Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); return Sema::TDK_SubstitutionFailure; } SmallVector ConvertedInstArgs; if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(), InstArgs, false, ConvertedInstArgs)) return Sema::TDK_SubstitutionFailure; TemplateParameterList *TemplateParams = ClassTemplate->getTemplateParameters(); for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { TemplateArgument InstArg = ConvertedInstArgs.data()[I]; if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); Info.FirstArg = TemplateArgs[I]; Info.SecondArg = InstArg; return Sema::TDK_NonDeducedMismatch; } } if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return Sema::TDK_Success; } /// \brief Perform template argument deduction to determine whether /// the given template arguments match the given class template /// partial specialization per C++ [temp.class.spec.match]. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, TemplateDeductionInfo &Info) { if (Partial->isInvalidDecl()) return TDK_Invalid; // C++ [temp.class.spec.match]p2: // A partial specialization matches a given actual template // argument list if the template arguments of the partial // specialization can be deduced from the actual template argument // list (14.8.2). // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); SmallVector Deduced; Deduced.resize(Partial->getTemplateParameters()->size()); if (TemplateDeductionResult Result = ::DeduceTemplateArguments(*this, Partial->getTemplateParameters(), Partial->getTemplateArgs(), TemplateArgs, Info, Deduced)) return Result; SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, DeducedArgs, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, Deduced, Info); } /// Complete template argument deduction for a variable template partial /// specialization. /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( Sema &S, VarTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; TemplateParameterList *PartialParams = Partial->getTemplateParameters(); for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { NamedDecl *Param = PartialParams->getParam(I); if (Deduced[I].isNull()) { Info.Param = makeTemplateParameter(Param); return Sema::TDK_Incomplete; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType, 0, Info, false, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy( S.Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the template // arguments of the class template partial specialization, and // verify that the instantiated template arguments are both valid // and are equivalent to the template arguments originally provided // to the class template. LocalInstantiationScope InstScope(S); VarTemplateDecl *VarTemplate = Partial->getSpecializedTemplate(); const ASTTemplateArgumentListInfo *PartialTemplArgInfo = Partial->getTemplateArgsAsWritten(); const TemplateArgumentLoc *PartialTemplateArgs = PartialTemplArgInfo->getTemplateArgs(); TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc, PartialTemplArgInfo->RAngleLoc); if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs, InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; if (ParamIdx >= Partial->getTemplateParameters()->size()) ParamIdx = Partial->getTemplateParameters()->size() - 1; Decl *Param = const_cast( Partial->getTemplateParameters()->getParam(ParamIdx)); Info.Param = makeTemplateParameter(Param); Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); return Sema::TDK_SubstitutionFailure; } SmallVector ConvertedInstArgs; if (S.CheckTemplateArgumentList(VarTemplate, Partial->getLocation(), InstArgs, false, ConvertedInstArgs)) return Sema::TDK_SubstitutionFailure; TemplateParameterList *TemplateParams = VarTemplate->getTemplateParameters(); for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { TemplateArgument InstArg = ConvertedInstArgs.data()[I]; if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); Info.FirstArg = TemplateArgs[I]; Info.SecondArg = InstArg; return Sema::TDK_NonDeducedMismatch; } } if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return Sema::TDK_Success; } /// \brief Perform template argument deduction to determine whether /// the given template arguments match the given variable template /// partial specialization per C++ [temp.class.spec.match]. /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, TemplateDeductionInfo &Info) { if (Partial->isInvalidDecl()) return TDK_Invalid; // C++ [temp.class.spec.match]p2: // A partial specialization matches a given actual template // argument list if the template arguments of the partial // specialization can be deduced from the actual template argument // list (14.8.2). // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); SmallVector Deduced; Deduced.resize(Partial->getTemplateParameters()->size()); if (TemplateDeductionResult Result = ::DeduceTemplateArguments( *this, Partial->getTemplateParameters(), Partial->getTemplateArgs(), TemplateArgs, Info, Deduced)) return Result; SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, DeducedArgs, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, Deduced, Info); } /// \brief Determine whether the given type T is a simple-template-id type. static bool isSimpleTemplateIdType(QualType T) { if (const TemplateSpecializationType *Spec = T->getAs()) return Spec->getTemplateName().getAsTemplateDecl() != 0; return false; } /// \brief Substitute the explicitly-provided template arguments into the /// given function template according to C++ [temp.arg.explicit]. /// /// \param FunctionTemplate the function template into which the explicit /// template arguments will be substituted. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param Deduced the deduced template arguments, which will be populated /// with the converted and checked explicit template arguments. /// /// \param ParamTypes will be populated with the instantiated function /// parameters. /// /// \param FunctionType if non-NULL, the result type of the function template /// will also be instantiated and the pointed-to value will be updated with /// the instantiated function type. /// /// \param Info if substitution fails for any reason, this object will be /// populated with more information about the failure. /// /// \returns TDK_Success if substitution was successful, or some failure /// condition. Sema::TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo &ExplicitTemplateArgs, SmallVectorImpl &Deduced, SmallVectorImpl &ParamTypes, QualType *FunctionType, TemplateDeductionInfo &Info) { FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); if (ExplicitTemplateArgs.size() == 0) { // No arguments to substitute; just copy over the parameter types and // fill in the function type. for (FunctionDecl::param_iterator P = Function->param_begin(), PEnd = Function->param_end(); P != PEnd; ++P) ParamTypes.push_back((*P)->getType()); if (FunctionType) *FunctionType = Function->getType(); return TDK_Success; } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // C++ [temp.arg.explicit]p3: // Template arguments that are present shall be specified in the // declaration order of their corresponding template-parameters. The // template argument list shall not specify more template-arguments than // there are corresponding template-parameters. SmallVector Builder; // Enter a new template instantiation context where we check the // explicitly-specified template arguments against this function template, // and then substitute them into the function parameter types. SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), FunctionTemplate, DeducedArgs, ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (CheckTemplateArgumentList(FunctionTemplate, SourceLocation(), ExplicitTemplateArgs, true, Builder) || Trap.hasErrorOccurred()) { unsigned Index = Builder.size(); if (Index >= TemplateParams->size()) Index = TemplateParams->size() - 1; Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); return TDK_InvalidExplicitArguments; } // Form the template argument list from the explicitly-specified // template arguments. TemplateArgumentList *ExplicitArgumentList = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); Info.reset(ExplicitArgumentList); // Template argument deduction and the final substitution should be // done in the context of the templated declaration. Explicit // argument substitution, on the other hand, needs to happen in the // calling context. ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); // If we deduced template arguments for a template parameter pack, // note that the template argument pack is partially substituted and record // the explicit template arguments. They'll be used as part of deduction // for this template parameter pack. for (unsigned I = 0, N = Builder.size(); I != N; ++I) { const TemplateArgument &Arg = Builder[I]; if (Arg.getKind() == TemplateArgument::Pack) { CurrentInstantiationScope->SetPartiallySubstitutedPack( TemplateParams->getParam(I), Arg.pack_begin(), Arg.pack_size()); break; } } const FunctionProtoType *Proto = Function->getType()->getAs(); assert(Proto && "Function template does not have a prototype?"); // Instantiate the types of each of the function parameters given the // explicitly-specified template arguments. If the function has a trailing // return type, substitute it after the arguments to ensure we substitute // in lexical order. if (Proto->hasTrailingReturn()) { if (SubstParmTypes(Function->getLocation(), Function->param_begin(), Function->getNumParams(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), ParamTypes)) return TDK_SubstitutionFailure; } // Instantiate the return type. QualType ResultType; { // C++11 [expr.prim.general]p3: // If a declaration declares a member function or member function // template of a class X, the expression this is a prvalue of type // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq // and the end of the function-definition, member-declarator, or // declarator. unsigned ThisTypeQuals = 0; CXXRecordDecl *ThisContext = 0; if (CXXMethodDecl *Method = dyn_cast(Function)) { ThisContext = Method->getParent(); ThisTypeQuals = Method->getTypeQualifiers(); } CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals, getLangOpts().CPlusPlus11); ResultType = SubstType(Proto->getResultType(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), Function->getTypeSpecStartLoc(), Function->getDeclName()); if (ResultType.isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; } // Instantiate the types of each of the function parameters given the // explicitly-specified template arguments if we didn't do so earlier. if (!Proto->hasTrailingReturn() && SubstParmTypes(Function->getLocation(), Function->param_begin(), Function->getNumParams(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), ParamTypes)) return TDK_SubstitutionFailure; if (FunctionType) { *FunctionType = BuildFunctionType(ResultType, ParamTypes, Function->getLocation(), Function->getDeclName(), Proto->getExtProtoInfo()); if (FunctionType->isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; } // C++ [temp.arg.explicit]p2: // Trailing template arguments that can be deduced (14.8.2) may be // omitted from the list of explicit template-arguments. If all of the // template arguments can be deduced, they may all be omitted; in this // case, the empty template argument list <> itself may also be omitted. // // Take all of the explicitly-specified arguments and put them into // the set of deduced template arguments. Explicitly-specified // parameter packs, however, will be set to NULL since the deduction // mechanisms handle explicitly-specified argument packs directly. Deduced.reserve(TemplateParams->size()); for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) { const TemplateArgument &Arg = ExplicitArgumentList->get(I); if (Arg.getKind() == TemplateArgument::Pack) Deduced.push_back(DeducedTemplateArgument()); else Deduced.push_back(Arg); } return TDK_Success; } /// \brief Check whether the deduced argument type for a call to a function /// template matches the actual argument type per C++ [temp.deduct.call]p4. static bool CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg, QualType DeducedA) { ASTContext &Context = S.Context; QualType A = OriginalArg.OriginalArgType; QualType OriginalParamType = OriginalArg.OriginalParamType; // Check for type equality (top-level cv-qualifiers are ignored). if (Context.hasSameUnqualifiedType(A, DeducedA)) return false; // Strip off references on the argument types; they aren't needed for // the following checks. if (const ReferenceType *DeducedARef = DeducedA->getAs()) DeducedA = DeducedARef->getPointeeType(); if (const ReferenceType *ARef = A->getAs()) A = ARef->getPointeeType(); // C++ [temp.deduct.call]p4: // [...] However, there are three cases that allow a difference: // - If the original P is a reference type, the deduced A (i.e., the // type referred to by the reference) can be more cv-qualified than // the transformed A. if (const ReferenceType *OriginalParamRef = OriginalParamType->getAs()) { // We don't want to keep the reference around any more. OriginalParamType = OriginalParamRef->getPointeeType(); Qualifiers AQuals = A.getQualifiers(); Qualifiers DeducedAQuals = DeducedA.getQualifiers(); // Under Objective-C++ ARC, the deduced type may have implicitly // been given strong or (when dealing with a const reference) // unsafe_unretained lifetime. If so, update the original // qualifiers to include this lifetime. if (S.getLangOpts().ObjCAutoRefCount && ((DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong && AQuals.getObjCLifetime() == Qualifiers::OCL_None) || (DeducedAQuals.hasConst() && DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone))) { AQuals.setObjCLifetime(DeducedAQuals.getObjCLifetime()); } if (AQuals == DeducedAQuals) { // Qualifiers match; there's nothing to do. } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) { return true; } else { // Qualifiers are compatible, so have the argument type adopt the // deduced argument type's qualifiers as if we had performed the // qualification conversion. A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals); } } // - The transformed A can be another pointer or pointer to member // type that can be converted to the deduced A via a qualification // conversion. // // Also allow conversions which merely strip [[noreturn]] from function types // (recursively) as an extension. // FIXME: Currently, this doesn't play nicely with qualification conversions. bool ObjCLifetimeConversion = false; QualType ResultTy; if ((A->isAnyPointerType() || A->isMemberPointerType()) && (S.IsQualificationConversion(A, DeducedA, false, ObjCLifetimeConversion) || S.IsNoReturnConversion(A, DeducedA, ResultTy))) return false; // - If P is a class and P has the form simple-template-id, then the // transformed A can be a derived class of the deduced A. [...] // [...] Likewise, if P is a pointer to a class of the form // simple-template-id, the transformed A can be a pointer to a // derived class pointed to by the deduced A. if (const PointerType *OriginalParamPtr = OriginalParamType->getAs()) { if (const PointerType *DeducedAPtr = DeducedA->getAs()) { if (const PointerType *APtr = A->getAs()) { if (A->getPointeeType()->isRecordType()) { OriginalParamType = OriginalParamPtr->getPointeeType(); DeducedA = DeducedAPtr->getPointeeType(); A = APtr->getPointeeType(); } } } } if (Context.hasSameUnqualifiedType(A, DeducedA)) return false; if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) && S.IsDerivedFrom(A, DeducedA)) return false; return true; } /// \brief Finish template argument deduction for a function template, /// checking the deduced template arguments for completeness and forming /// the function template specialization. /// /// \param OriginalCallArgs If non-NULL, the original call arguments against /// which the deduced argument types should be compared. Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl &Deduced, unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, SmallVectorImpl const *OriginalCallArgs) { TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // Enter a new template instantiation context while we instantiate the // actual function declaration. SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), FunctionTemplate, DeducedArgs, ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { NamedDecl *Param = TemplateParams->getParam(I); if (!Deduced[I].isNull()) { if (I < NumExplicitlySpecified) { // We have already fully type-checked and converted this // argument, because it was explicitly-specified. Just record the // presence of this argument. Builder.push_back(Deduced[I]); continue; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I], FunctionTemplate, NTTPType, 0, Info, true, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } continue; } // C++0x [temp.arg.explicit]p3: // A trailing template parameter pack (14.5.3) not otherwise deduced will // be deduced to an empty sequence of template arguments. // FIXME: Where did the word "trailing" come from? if (Param->isTemplateParameterPack()) { // We may have had explicitly-specified template arguments for this // template parameter pack. If so, our empty deduction extends the // explicitly-specified set (C++0x [temp.arg.explicit]p9). const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; if (CurrentInstantiationScope && CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs, &NumExplicitArgs) == Param) { Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs)); // Forget the partially-substituted pack; it's substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); } else { Builder.push_back(TemplateArgument::getEmptyPack()); } continue; } // Substitute into the default template argument, if available. bool HasDefaultArg = false; TemplateArgumentLoc DefArg = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate, FunctionTemplate->getLocation(), FunctionTemplate->getSourceRange().getEnd(), Param, Builder, HasDefaultArg); // If there was no default argument, deduction is incomplete. if (DefArg.getArgument().isNull()) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return HasDefaultArg ? TDK_SubstitutionFailure : TDK_Incomplete; } // Check whether we can actually use the default argument. if (CheckTemplateArgument(Param, DefArg, FunctionTemplate, FunctionTemplate->getLocation(), FunctionTemplate->getSourceRange().getEnd(), 0, Builder, CTAK_Specified)) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } // If we get here, we successfully used the default template argument. } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the function template // declaration to produce the function template specialization. DeclContext *Owner = FunctionTemplate->getDeclContext(); if (FunctionTemplate->getFriendObjectKind()) Owner = FunctionTemplate->getLexicalDeclContext(); Specialization = cast_or_null( SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, MultiLevelTemplateArgumentList(*DeducedArgumentList))); if (!Specialization || Specialization->isInvalidDecl()) return TDK_SubstitutionFailure; assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == FunctionTemplate->getCanonicalDecl()); // If the template argument list is owned by the function template // specialization, release it. if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList && !Trap.hasErrorOccurred()) Info.take(); // There may have been an error that did not prevent us from constructing a // declaration. Mark the declaration invalid and return with a substitution // failure. if (Trap.hasErrorOccurred()) { Specialization->setInvalidDecl(true); return TDK_SubstitutionFailure; } if (OriginalCallArgs) { // C++ [temp.deduct.call]p4: // In general, the deduction process attempts to find template argument // values that will make the deduced A identical to A (after the type A // is transformed as described above). [...] for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) { OriginalCallArg OriginalArg = (*OriginalCallArgs)[I]; unsigned ParamIdx = OriginalArg.ArgIdx; if (ParamIdx >= Specialization->getNumParams()) continue; QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType(); if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) return Sema::TDK_SubstitutionFailure; } } // If we suppressed any diagnostics while performing template argument // deduction, and if we haven't already instantiated this declaration, // keep track of these diagnostics. They'll be emitted if this specialization // is actually used. if (Info.diag_begin() != Info.diag_end()) { SuppressedDiagnosticsMap::iterator Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); if (Pos == SuppressedDiagnostics.end()) SuppressedDiagnostics[Specialization->getCanonicalDecl()] .append(Info.diag_begin(), Info.diag_end()); } return TDK_Success; } /// Gets the type of a function for template-argument-deducton /// purposes when it's considered as part of an overload set. static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R, FunctionDecl *Fn) { // We may need to deduce the return type of the function now. if (S.getLangOpts().CPlusPlus1y && Fn->getResultType()->isUndeducedType() && S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/false)) return QualType(); if (CXXMethodDecl *Method = dyn_cast(Fn)) if (Method->isInstance()) { // An instance method that's referenced in a form that doesn't // look like a member pointer is just invalid. if (!R.HasFormOfMemberPointer) return QualType(); return S.Context.getMemberPointerType(Fn->getType(), S.Context.getTypeDeclType(Method->getParent()).getTypePtr()); } if (!R.IsAddressOfOperand) return Fn->getType(); return S.Context.getPointerType(Fn->getType()); } /// Apply the deduction rules for overload sets. /// /// \return the null type if this argument should be treated as an /// undeduced context static QualType ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, Expr *Arg, QualType ParamType, bool ParamWasReference) { OverloadExpr::FindResult R = OverloadExpr::find(Arg); OverloadExpr *Ovl = R.Expression; // C++0x [temp.deduct.call]p4 unsigned TDF = 0; if (ParamWasReference) TDF |= TDF_ParamWithReferenceType; if (R.IsAddressOfOperand) TDF |= TDF_IgnoreQualifiers; // C++0x [temp.deduct.call]p6: // When P is a function type, pointer to function type, or pointer // to member function type: if (!ParamType->isFunctionType() && !ParamType->isFunctionPointerType() && !ParamType->isMemberFunctionPointerType()) { if (Ovl->hasExplicitTemplateArgs()) { // But we can still look for an explicit specialization. if (FunctionDecl *ExplicitSpec = S.ResolveSingleFunctionTemplateSpecialization(Ovl)) return GetTypeOfFunction(S, R, ExplicitSpec); } return QualType(); } // Gather the explicit template arguments, if any. TemplateArgumentListInfo ExplicitTemplateArgs; if (Ovl->hasExplicitTemplateArgs()) Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs); QualType Match; for (UnresolvedSetIterator I = Ovl->decls_begin(), E = Ovl->decls_end(); I != E; ++I) { NamedDecl *D = (*I)->getUnderlyingDecl(); if (FunctionTemplateDecl *FunTmpl = dyn_cast(D)) { // - If the argument is an overload set containing one or more // function templates, the parameter is treated as a // non-deduced context. if (!Ovl->hasExplicitTemplateArgs()) return QualType(); // Otherwise, see if we can resolve a function type FunctionDecl *Specialization = 0; TemplateDeductionInfo Info(Ovl->getNameLoc()); if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs, Specialization, Info)) continue; D = Specialization; } FunctionDecl *Fn = cast(D); QualType ArgType = GetTypeOfFunction(S, R, Fn); if (ArgType.isNull()) continue; // Function-to-pointer conversion. if (!ParamWasReference && ParamType->isPointerType() && ArgType->isFunctionType()) ArgType = S.Context.getPointerType(ArgType); // - If the argument is an overload set (not containing function // templates), trial argument deduction is attempted using each // of the members of the set. If deduction succeeds for only one // of the overload set members, that member is used as the // argument value for the deduction. If deduction succeeds for // more than one member of the overload set the parameter is // treated as a non-deduced context. // We do all of this in a fresh context per C++0x [temp.deduct.type]p2: // Type deduction is done independently for each P/A pair, and // the deduced template argument values are then combined. // So we do not reject deductions which were made elsewhere. SmallVector Deduced(TemplateParams->size()); TemplateDeductionInfo Info(Ovl->getNameLoc()); Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF); if (Result) continue; if (!Match.isNull()) return QualType(); Match = ArgType; } return Match; } /// \brief Perform the adjustments to the parameter and argument types /// described in C++ [temp.deduct.call]. /// /// \returns true if the caller should not attempt to perform any template /// argument deduction based on this P/A pair because the argument is an /// overloaded function set that could not be resolved. static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, TemplateParameterList *TemplateParams, QualType &ParamType, QualType &ArgType, Expr *Arg, unsigned &TDF) { // C++0x [temp.deduct.call]p3: // If P is a cv-qualified type, the top level cv-qualifiers of P's type // are ignored for type deduction. if (ParamType.hasQualifiers()) ParamType = ParamType.getUnqualifiedType(); const ReferenceType *ParamRefType = ParamType->getAs(); if (ParamRefType) { QualType PointeeType = ParamRefType->getPointeeType(); // If the argument has incomplete array type, try to complete its type. if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0)) ArgType = Arg->getType(); // [C++0x] If P is an rvalue reference to a cv-unqualified // template parameter and the argument is an lvalue, the type // "lvalue reference to A" is used in place of A for type // deduction. if (isa(ParamType)) { if (!PointeeType.getQualifiers() && isa(PointeeType) && Arg->Classify(S.Context).isLValue() && Arg->getType() != S.Context.OverloadTy && Arg->getType() != S.Context.BoundMemberTy) ArgType = S.Context.getLValueReferenceType(ArgType); } // [...] If P is a reference type, the type referred to by P is used // for type deduction. ParamType = PointeeType; } // Overload sets usually make this parameter an undeduced // context, but there are sometimes special circumstances. if (ArgType == S.Context.OverloadTy) { ArgType = ResolveOverloadForDeduction(S, TemplateParams, Arg, ParamType, ParamRefType != 0); if (ArgType.isNull()) return true; } if (ParamRefType) { // C++0x [temp.deduct.call]p3: // [...] If P is of the form T&&, where T is a template parameter, and // the argument is an lvalue, the type A& is used in place of A for // type deduction. if (ParamRefType->isRValueReferenceType() && ParamRefType->getAs() && Arg->isLValue()) ArgType = S.Context.getLValueReferenceType(ArgType); } else { // C++ [temp.deduct.call]p2: // If P is not a reference type: // - If A is an array type, the pointer type produced by the // array-to-pointer standard conversion (4.2) is used in place of // A for type deduction; otherwise, if (ArgType->isArrayType()) ArgType = S.Context.getArrayDecayedType(ArgType); // - If A is a function type, the pointer type produced by the // function-to-pointer standard conversion (4.3) is used in place // of A for type deduction; otherwise, else if (ArgType->isFunctionType()) ArgType = S.Context.getPointerType(ArgType); else { // - If A is a cv-qualified type, the top level cv-qualifiers of A's // type are ignored for type deduction. ArgType = ArgType.getUnqualifiedType(); } } // C++0x [temp.deduct.call]p4: // In general, the deduction process attempts to find template argument // values that will make the deduced A identical to A (after the type A // is transformed as described above). [...] TDF = TDF_SkipNonDependent; // - If the original P is a reference type, the deduced A (i.e., the // type referred to by the reference) can be more cv-qualified than // the transformed A. if (ParamRefType) TDF |= TDF_ParamWithReferenceType; // - The transformed A can be another pointer or pointer to member // type that can be converted to the deduced A via a qualification // conversion (4.4). if (ArgType->isPointerType() || ArgType->isMemberPointerType() || ArgType->isObjCObjectPointerType()) TDF |= TDF_IgnoreQualifiers; // - If P is a class and P has the form simple-template-id, then the // transformed A can be a derived class of the deduced A. Likewise, // if P is a pointer to a class of the form simple-template-id, the // transformed A can be a pointer to a derived class pointed to by // the deduced A. if (isSimpleTemplateIdType(ParamType) || (isa(ParamType) && isSimpleTemplateIdType( ParamType->getAs()->getPointeeType()))) TDF |= TDF_DerivedClass; return false; } static bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T); /// \brief Perform template argument deduction by matching a parameter type /// against a single expression, where the expression is an element of /// an initializer list that was originally matched against a parameter /// of type \c initializer_list\. static Sema::TemplateDeductionResult DeduceTemplateArgumentByListElement(Sema &S, TemplateParameterList *TemplateParams, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF) { // Handle the case where an init list contains another init list as the // element. if (InitListExpr *ILE = dyn_cast(Arg)) { QualType X; if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X)) return Sema::TDK_Success; // Just ignore this expression. // Recurse down into the init list. for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentByListElement(S, TemplateParams, X, ILE->getInit(i), Info, Deduced, TDF)) return Result; } return Sema::TDK_Success; } // For all other cases, just match by type. QualType ArgType = Arg->getType(); if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, ArgType, Arg, TDF)) { Info.Expression = Arg; return Sema::TDK_FailedOverloadResolution; } return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF); } /// \brief Perform template argument deduction from a function call /// (C++ [temp.deduct.call]). /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicit template arguments provided /// for this call. /// /// \param Args the function call arguments /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef Args, FunctionDecl *&Specialization, TemplateDeductionInfo &Info) { if (FunctionTemplate->isInvalidDecl()) return TDK_Invalid; FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); // C++ [temp.deduct.call]p1: // Template argument deduction is done by comparing each function template // parameter type (call it P) with the type of the corresponding argument // of the call (call it A) as described below. unsigned CheckArgs = Args.size(); if (Args.size() < Function->getMinRequiredArguments()) return TDK_TooFewArguments; else if (Args.size() > Function->getNumParams()) { const FunctionProtoType *Proto = Function->getType()->getAs(); if (Proto->isTemplateVariadic()) /* Do nothing */; else if (Proto->isVariadic()) CheckArgs = Function->getNumParams(); else return TDK_TooManyArguments; } // The types of the parameters from which we will perform template argument // deduction. LocalInstantiationScope InstScope(*this); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); SmallVector Deduced; SmallVector ParamTypes; unsigned NumExplicitlySpecified = 0; if (ExplicitTemplateArgs) { TemplateDeductionResult Result = SubstituteExplicitTemplateArguments(FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, 0, Info); if (Result) return Result; NumExplicitlySpecified = Deduced.size(); } else { // Just fill in the parameter types from the function declaration. for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) ParamTypes.push_back(Function->getParamDecl(I)->getType()); } // Deduce template arguments from the function parameters. Deduced.resize(TemplateParams->size()); unsigned ArgIdx = 0; SmallVector OriginalCallArgs; for (unsigned ParamIdx = 0, NumParams = ParamTypes.size(); ParamIdx != NumParams; ++ParamIdx) { QualType OrigParamType = ParamTypes[ParamIdx]; QualType ParamType = OrigParamType; const PackExpansionType *ParamExpansion = dyn_cast(ParamType); if (!ParamExpansion) { // Simple case: matching a function parameter to a function argument. if (ArgIdx >= CheckArgs) break; Expr *Arg = Args[ArgIdx++]; QualType ArgType = Arg->getType(); unsigned TDF = 0; if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, ParamType, ArgType, Arg, TDF)) continue; // If we have nothing to deduce, we're done. if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) continue; // If the argument is an initializer list ... if (InitListExpr *ILE = dyn_cast(Arg)) { // ... then the parameter is an undeduced context, unless the parameter // type is (reference to cv) std::initializer_list, in which case // deduction is done for each element of the initializer list, and the // result is the deduced type if it's the same for all elements. QualType X; // Removing references was already done. if (!isStdInitializerList(ParamType, &X)) continue; for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (TemplateDeductionResult Result = DeduceTemplateArgumentByListElement(*this, TemplateParams, X, ILE->getInit(i), Info, Deduced, TDF)) return Result; } // Don't track the argument type, since an initializer list has none. continue; } // Keep track of the argument type and corresponding parameter index, // so we can check for compatibility between the deduced A and A. OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1, ArgType)); if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, ParamType, ArgType, Info, Deduced, TDF)) return Result; continue; } // C++0x [temp.deduct.call]p1: // For a function parameter pack that occurs at the end of the // parameter-declaration-list, the type A of each remaining argument of // the call is compared with the type P of the declarator-id of the // function parameter pack. Each comparison deduces template arguments // for subsequent positions in the template parameter packs expanded by // the function parameter pack. For a function parameter pack that does // not occur at the end of the parameter-declaration-list, the type of // the parameter pack is a non-deduced context. if (ParamIdx + 1 < NumParams) break; QualType ParamPattern = ParamExpansion->getPattern(); SmallVector PackIndices; { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; collectUnexpandedParameterPacks(ParamPattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; PackIndices.push_back(Index); } } } assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); // Keep track of the deduced template arguments for each parameter pack // expanded by this pack expansion (the outer index) and for each // template argument (the inner SmallVectors). NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); SmallVector SavedPacks(PackIndices.size()); PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks); bool HasAnyArguments = false; for (; ArgIdx < Args.size(); ++ArgIdx) { HasAnyArguments = true; QualType OrigParamType = ParamPattern; ParamType = OrigParamType; Expr *Arg = Args[ArgIdx]; QualType ArgType = Arg->getType(); unsigned TDF = 0; if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, ParamType, ArgType, Arg, TDF)) { // We can't actually perform any deduction for this argument, so stop // deduction at this point. ++ArgIdx; break; } // As above, initializer lists need special handling. if (InitListExpr *ILE = dyn_cast(Arg)) { QualType X; if (!isStdInitializerList(ParamType, &X)) { ++ArgIdx; break; } for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X, ILE->getInit(i)->getType(), Info, Deduced, TDF)) return Result; } } else { // Keep track of the argument type and corresponding argument index, // so we can check for compatibility between the deduced A and A. if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx, ArgType)); if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, ParamType, ArgType, Info, Deduced, TDF)) return Result; } // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; if (!DeducedArg.isNull()) { NewlyDeducedPacks[I].push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } } } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (Sema::TemplateDeductionResult Result = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks, Info)) return Result; // After we've matching against a parameter pack, we're done. break; } return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info, &OriginalCallArgs); } /// \brief Deduce template arguments when taking the address of a function /// template (C++ [temp.deduct.funcaddr]) or matching a specialization to /// a template. /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param ArgFunctionType the function type that will be used as the /// "argument" type (A) when performing template argument deduction from the /// function template's function type. This type may be NULL, if there is no /// argument type to compare against, in C++0x [temp.arg.explicit]p3. /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ArgFunctionType, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool InOverloadResolution) { if (FunctionTemplate->isInvalidDecl()) return TDK_Invalid; FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); QualType FunctionType = Function->getType(); if (!InOverloadResolution && !ArgFunctionType.isNull()) { const FunctionProtoType *FunctionTypeP = FunctionType->castAs(); CallingConv CC = FunctionTypeP->getCallConv(); bool NoReturn = FunctionTypeP->getNoReturnAttr(); const FunctionProtoType *ArgFunctionTypeP = ArgFunctionType->getAs(); if (ArgFunctionTypeP->getCallConv() != CC || ArgFunctionTypeP->getNoReturnAttr() != NoReturn) { FunctionType::ExtInfo EI = ArgFunctionTypeP->getExtInfo().withCallingConv(CC); EI = EI.withNoReturn(NoReturn); ArgFunctionTypeP = cast( Context.adjustFunctionType(ArgFunctionTypeP, EI)); ArgFunctionType = QualType(ArgFunctionTypeP, 0); } } // Substitute any explicit template arguments. LocalInstantiationScope InstScope(*this); SmallVector Deduced; unsigned NumExplicitlySpecified = 0; SmallVector ParamTypes; if (ExplicitTemplateArgs) { if (TemplateDeductionResult Result = SubstituteExplicitTemplateArguments(FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, &FunctionType, Info)) return Result; NumExplicitlySpecified = Deduced.size(); } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); Deduced.resize(TemplateParams->size()); // If the function has a deduced return type, substitute it for a dependent // type so that we treat it as a non-deduced context in what follows. bool HasDeducedReturnType = false; if (getLangOpts().CPlusPlus1y && InOverloadResolution && Function->getResultType()->getContainedAutoType()) { FunctionType = SubstAutoType(FunctionType, Context.DependentTy); HasDeducedReturnType = true; } if (!ArgFunctionType.isNull()) { unsigned TDF = TDF_TopLevelParameterTypeList; if (InOverloadResolution) TDF |= TDF_InOverloadResolution; // Deduce template arguments from the function type. if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, FunctionType, ArgFunctionType, Info, Deduced, TDF)) return Result; } if (TemplateDeductionResult Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info)) return Result; // If the function has a deduced return type, deduce it now, so we can check // that the deduced function type matches the requested type. if (HasDeducedReturnType && Specialization->getResultType()->isUndeducedType() && DeduceReturnType(Specialization, Info.getLocation(), false)) return TDK_MiscellaneousDeductionFailure; // If the requested function type does not match the actual type of the // specialization with respect to arguments of compatible pointer to function // types, template argument deduction fails. if (!ArgFunctionType.isNull()) { if (InOverloadResolution && !isSameOrCompatibleFunctionType( Context.getCanonicalType(Specialization->getType()), Context.getCanonicalType(ArgFunctionType))) return TDK_MiscellaneousDeductionFailure; else if(!InOverloadResolution && !Context.hasSameType(Specialization->getType(), ArgFunctionType)) return TDK_MiscellaneousDeductionFailure; } return TDK_Success; } /// \brief Given a function declaration (e.g. a generic lambda conversion /// function) that contains an 'auto' in its result type, substitute it /// with TypeToReplaceAutoWith. Be careful to pass in the type you want /// to replace 'auto' with and not the actual result type you want /// to set the function to. static inline void SubstAutoWithinFunctionReturnType(FunctionDecl *F, QualType TypeToReplaceAutoWith, Sema &S) { assert(!TypeToReplaceAutoWith->getContainedAutoType()); QualType AutoResultType = F->getResultType(); assert(AutoResultType->getContainedAutoType()); QualType DeducedResultType = S.SubstAutoType(AutoResultType, TypeToReplaceAutoWith); S.Context.adjustDeducedFunctionResultType(F, DeducedResultType); } /// \brief Given a specialized conversion operator of a generic lambda /// create the corresponding specializations of the call operator and /// the static-invoker. If the return type of the call operator is auto, /// deduce its return type and check if that matches the /// return type of the destination function ptr. static inline Sema::TemplateDeductionResult SpecializeCorrespondingLambdaCallOperatorAndInvoker( CXXConversionDecl *ConversionSpecialized, SmallVectorImpl &DeducedArguments, QualType ReturnTypeOfDestFunctionPtr, TemplateDeductionInfo &TDInfo, Sema &S) { CXXRecordDecl *LambdaClass = ConversionSpecialized->getParent(); assert(LambdaClass && LambdaClass->isGenericLambda()); CXXMethodDecl *CallOpGeneric = LambdaClass->getLambdaCallOperator(); QualType CallOpResultType = CallOpGeneric->getResultType(); const bool GenericLambdaCallOperatorHasDeducedReturnType = CallOpResultType->getContainedAutoType(); FunctionTemplateDecl *CallOpTemplate = CallOpGeneric->getDescribedFunctionTemplate(); FunctionDecl *CallOpSpecialized = 0; // Use the deduced arguments of the conversion function, to specialize our // generic lambda's call operator. if (Sema::TemplateDeductionResult Result = S.FinishTemplateArgumentDeduction(CallOpTemplate, DeducedArguments, 0, CallOpSpecialized, TDInfo)) return Result; // If we need to deduce the return type, do so (instantiates the callop). if (GenericLambdaCallOperatorHasDeducedReturnType && CallOpSpecialized->getResultType()->isUndeducedType()) S.DeduceReturnType(CallOpSpecialized, CallOpSpecialized->getPointOfInstantiation(), /*Diagnose*/ true); // Check to see if the return type of the destination ptr-to-function // matches the return type of the call operator. if (!S.Context.hasSameType(CallOpSpecialized->getResultType(), ReturnTypeOfDestFunctionPtr)) return Sema::TDK_NonDeducedMismatch; // Since we have succeeded in matching the source and destination // ptr-to-functions (now including return type), and have successfully // specialized our corresponding call operator, we are ready to // specialize the static invoker with the deduced arguments of our // ptr-to-function. FunctionDecl *InvokerSpecialized = 0; FunctionTemplateDecl *InvokerTemplate = LambdaClass-> getLambdaStaticInvoker()->getDescribedFunctionTemplate(); Sema::TemplateDeductionResult LLVM_ATTRIBUTE_UNUSED Result = S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0, InvokerSpecialized, TDInfo); assert(Result == Sema::TDK_Success && "If the call operator succeeded so should the invoker!"); // Set the result type to match the corresponding call operator // specialization's result type. if (GenericLambdaCallOperatorHasDeducedReturnType && InvokerSpecialized->getResultType()->isUndeducedType()) { // Be sure to get the type to replace 'auto' with and not // the full result type of the call op specialization // to substitute into the 'auto' of the invoker and conversion // function. // For e.g. // int* (*fp)(int*) = [](auto* a) -> auto* { return a; }; // We don't want to subst 'int*' into 'auto' to get int**. QualType TypeToReplaceAutoWith = CallOpSpecialized->getResultType()-> getContainedAutoType()->getDeducedType(); SubstAutoWithinFunctionReturnType(InvokerSpecialized, TypeToReplaceAutoWith, S); SubstAutoWithinFunctionReturnType(ConversionSpecialized, TypeToReplaceAutoWith, S); } // Ensure that static invoker doesn't have a const qualifier. // FIXME: When creating the InvokerTemplate in SemaLambda.cpp // do not use the CallOperator's TypeSourceInfo which allows // the const qualifier to leak through. const FunctionProtoType *InvokerFPT = InvokerSpecialized-> getType().getTypePtr()->castAs(); FunctionProtoType::ExtProtoInfo EPI = InvokerFPT->getExtProtoInfo(); EPI.TypeQuals = 0; InvokerSpecialized->setType(S.Context.getFunctionType( InvokerFPT->getResultType(), InvokerFPT->getArgTypes(),EPI)); return Sema::TDK_Success; } /// \brief Deduce template arguments for a templated conversion /// function (C++ [temp.deduct.conv]) and, if successful, produce a /// conversion function template specialization. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate, QualType ToType, CXXConversionDecl *&Specialization, TemplateDeductionInfo &Info) { if (ConversionTemplate->isInvalidDecl()) return TDK_Invalid; CXXConversionDecl *ConversionGeneric = cast(ConversionTemplate->getTemplatedDecl()); QualType FromType = ConversionGeneric->getConversionType(); // Canonicalize the types for deduction. QualType P = Context.getCanonicalType(FromType); QualType A = Context.getCanonicalType(ToType); // C++0x [temp.deduct.conv]p2: // If P is a reference type, the type referred to by P is used for // type deduction. if (const ReferenceType *PRef = P->getAs()) P = PRef->getPointeeType(); // C++0x [temp.deduct.conv]p4: // [...] If A is a reference type, the type referred to by A is used // for type deduction. if (const ReferenceType *ARef = A->getAs()) A = ARef->getPointeeType().getUnqualifiedType(); // C++ [temp.deduct.conv]p3: // // If A is not a reference type: else { assert(!A->isReferenceType() && "Reference types were handled above"); // - If P is an array type, the pointer type produced by the // array-to-pointer standard conversion (4.2) is used in place // of P for type deduction; otherwise, if (P->isArrayType()) P = Context.getArrayDecayedType(P); // - If P is a function type, the pointer type produced by the // function-to-pointer standard conversion (4.3) is used in // place of P for type deduction; otherwise, else if (P->isFunctionType()) P = Context.getPointerType(P); // - If P is a cv-qualified type, the top level cv-qualifiers of // P's type are ignored for type deduction. else P = P.getUnqualifiedType(); // C++0x [temp.deduct.conv]p4: // If A is a cv-qualified type, the top level cv-qualifiers of A's // type are ignored for type deduction. If A is a reference type, the type // referred to by A is used for type deduction. A = A.getUnqualifiedType(); } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // C++ [temp.deduct.conv]p1: // Template argument deduction is done by comparing the return // type of the template conversion function (call it P) with the // type that is required as the result of the conversion (call it // A) as described in 14.8.2.4. TemplateParameterList *TemplateParams = ConversionTemplate->getTemplateParameters(); SmallVector Deduced; Deduced.resize(TemplateParams->size()); // C++0x [temp.deduct.conv]p4: // In general, the deduction process attempts to find template // argument values that will make the deduced A identical to // A. However, there are two cases that allow a difference: unsigned TDF = 0; // - If the original A is a reference type, A can be more // cv-qualified than the deduced A (i.e., the type referred to // by the reference) if (ToType->isReferenceType()) TDF |= TDF_ParamWithReferenceType; // - The deduced A can be another pointer or pointer to member // type that can be converted to A via a qualification // conversion. // // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when // both P and A are pointers or member pointers. In this case, we // just ignore cv-qualifiers completely). if ((P->isPointerType() && A->isPointerType()) || (P->isMemberPointerType() && A->isMemberPointerType())) TDF |= TDF_IgnoreQualifiers; if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, P, A, Info, Deduced, TDF)) return Result; // Create an Instantiation Scope for finalizing the operator. LocalInstantiationScope InstScope(*this); // Finish template argument deduction. FunctionDecl *ConversionSpecialized = 0; TemplateDeductionResult Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0, ConversionSpecialized, Info); Specialization = cast_or_null(ConversionSpecialized); // If the conversion operator is being invoked on a lambda closure to convert // to a ptr-to-function, use the deduced arguments from the conversion function // to specialize the corresponding call operator. // e.g., int (*fp)(int) = [](auto a) { return a; }; if (Result == TDK_Success && isLambdaConversionOperator(ConversionGeneric)) { // Get the return type of the destination ptr-to-function we are converting // to. This is necessary for matching the lambda call operator's return // type to that of the destination ptr-to-function's return type. assert(A->isPointerType() && "Can only convert from lambda to ptr-to-function"); const FunctionType *ToFunType = A->getPointeeType().getTypePtr()->getAs(); const QualType DestFunctionPtrReturnType = ToFunType->getResultType(); // Create the corresponding specializations of the call operator and // the static-invoker; and if the return type is auto, // deduce the return type and check if it matches the // DestFunctionPtrReturnType. // For instance: // auto L = [](auto a) { return f(a); }; // int (*fp)(int) = L; // char (*fp2)(int) = L; <-- Not OK. Result = SpecializeCorrespondingLambdaCallOperatorAndInvoker( Specialization, Deduced, DestFunctionPtrReturnType, Info, *this); } return Result; } /// \brief Deduce template arguments for a function template when there is /// nothing to deduce against (C++0x [temp.arg.explicit]p3). /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool InOverloadResolution) { return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, QualType(), Specialization, Info, InOverloadResolution); } namespace { /// Substitute the 'auto' type specifier within a type for a given replacement /// type. class SubstituteAutoTransform : public TreeTransform { QualType Replacement; public: SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) : TreeTransform(SemaRef), Replacement(Replacement) { } QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) { // If we're building the type pattern to deduce against, don't wrap the // substituted type in an AutoType. Certain template deduction rules // apply only when a template type parameter appears directly (and not if // the parameter is found through desugaring). For instance: // auto &&lref = lvalue; // must transform into "rvalue reference to T" not "rvalue reference to // auto type deduced as T" in order for [temp.deduct.call]p3 to apply. if (!Replacement.isNull() && isa(Replacement)) { QualType Result = Replacement; TemplateTypeParmTypeLoc NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } else { bool Dependent = !Replacement.isNull() && Replacement->isDependentType(); QualType Result = SemaRef.Context.getAutoType(Dependent ? QualType() : Replacement, TL.getTypePtr()->isDecltypeAuto(), Dependent); AutoTypeLoc NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } } ExprResult TransformLambdaExpr(LambdaExpr *E) { // Lambdas never need to be transformed. return E; } QualType Apply(TypeLoc TL) { // Create some scratch storage for the transformed type locations. // FIXME: We're just going to throw this information away. Don't build it. TypeLocBuilder TLB; TLB.reserve(TL.getFullDataSize()); return TransformType(TLB, TL); } }; } Sema::DeduceAutoResult Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result) { return DeduceAutoType(Type->getTypeLoc(), Init, Result); } /// \brief Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) /// /// \param Type the type pattern using the auto type-specifier. /// \param Init the initializer for the variable whose type is to be deduced. /// \param Result if type deduction was successful, this will be set to the /// deduced type. Sema::DeduceAutoResult Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) { if (Init->getType()->isNonOverloadPlaceholderType()) { ExprResult NonPlaceholder = CheckPlaceholderExpr(Init); if (NonPlaceholder.isInvalid()) return DAR_FailedAlreadyDiagnosed; Init = NonPlaceholder.take(); } if (Init->isTypeDependent() || Type.getType()->isDependentType()) { Result = SubstituteAutoTransform(*this, Context.DependentTy).Apply(Type); assert(!Result.isNull() && "substituting DependentTy can't fail"); return DAR_Succeeded; } // If this is a 'decltype(auto)' specifier, do the decltype dance. // Since 'decltype(auto)' can only occur at the top of the type, we // don't need to go digging for it. if (const AutoType *AT = Type.getType()->getAs()) { if (AT->isDecltypeAuto()) { if (isa(Init)) { Diag(Init->getLocStart(), diag::err_decltype_auto_initializer_list); return DAR_FailedAlreadyDiagnosed; } QualType Deduced = BuildDecltypeType(Init, Init->getLocStart()); // FIXME: Support a non-canonical deduced type for 'auto'. Deduced = Context.getCanonicalType(Deduced); Result = SubstituteAutoTransform(*this, Deduced).Apply(Type); if (Result.isNull()) return DAR_FailedAlreadyDiagnosed; return DAR_Succeeded; } } SourceLocation Loc = Init->getExprLoc(); LocalInstantiationScope InstScope(*this); // Build template void Func(FuncParam); TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0, false, false); QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); NamedDecl *TemplParamPtr = TemplParam; FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr, Loc); QualType FuncParam = SubstituteAutoTransform(*this, TemplArg).Apply(Type); assert(!FuncParam.isNull() && "substituting template parameter for 'auto' failed"); // Deduce type of TemplParam in Func(Init) SmallVector Deduced; Deduced.resize(1); QualType InitType = Init->getType(); unsigned TDF = 0; TemplateDeductionInfo Info(Loc); InitListExpr *InitList = dyn_cast(Init); if (InitList) { for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) { if (DeduceTemplateArgumentByListElement(*this, &TemplateParams, TemplArg, InitList->getInit(i), Info, Deduced, TDF)) return DAR_Failed; } } else { if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams, FuncParam, InitType, Init, TDF)) return DAR_Failed; if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam, InitType, Info, Deduced, TDF)) return DAR_Failed; } if (Deduced[0].getKind() != TemplateArgument::Type) return DAR_Failed; QualType DeducedType = Deduced[0].getAsType(); if (InitList) { DeducedType = BuildStdInitializerList(DeducedType, Loc); if (DeducedType.isNull()) return DAR_FailedAlreadyDiagnosed; } Result = SubstituteAutoTransform(*this, DeducedType).Apply(Type); if (Result.isNull()) return DAR_FailedAlreadyDiagnosed; // Check that the deduced argument type is compatible with the original // argument type per C++ [temp.deduct.call]p4. if (!InitList && !Result.isNull() && CheckOriginalCallArgDeduction(*this, Sema::OriginalCallArg(FuncParam,0,InitType), Result)) { Result = QualType(); return DAR_Failed; } return DAR_Succeeded; } QualType Sema::SubstAutoType(QualType TypeWithAuto, QualType TypeToReplaceAuto) { return SubstituteAutoTransform(*this, TypeToReplaceAuto). TransformType(TypeWithAuto); } TypeSourceInfo* Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType TypeToReplaceAuto) { return SubstituteAutoTransform(*this, TypeToReplaceAuto). TransformType(TypeWithAuto); } void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) { if (isa(Init)) Diag(VDecl->getLocation(), VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure_from_init_list : diag::err_auto_var_deduction_failure_from_init_list) << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange(); else Diag(VDecl->getLocation(), VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure : diag::err_auto_var_deduction_failure) << VDecl->getDeclName() << VDecl->getType() << Init->getType() << Init->getSourceRange(); } bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose) { assert(FD->getResultType()->isUndeducedType()); if (FD->getTemplateInstantiationPattern()) InstantiateFunctionDefinition(Loc, FD); bool StillUndeduced = FD->getResultType()->isUndeducedType(); if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) { Diag(Loc, diag::err_auto_fn_used_before_defined) << FD; Diag(FD->getLocation(), diag::note_callee_decl) << FD; } return StillUndeduced; } static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Level, llvm::SmallBitVector &Deduced); /// \brief If this is a non-static member function, static void AddImplicitObjectParameterType(ASTContext &Context, CXXMethodDecl *Method, SmallVectorImpl &ArgTypes) { // C++11 [temp.func.order]p3: // [...] The new parameter is of type "reference to cv A," where cv are // the cv-qualifiers of the function template (if any) and A is // the class of which the function template is a member. // // The standard doesn't say explicitly, but we pick the appropriate kind of // reference type based on [over.match.funcs]p4. QualType ArgTy = Context.getTypeDeclType(Method->getParent()); ArgTy = Context.getQualifiedType(ArgTy, Qualifiers::fromCVRMask(Method->getTypeQualifiers())); if (Method->getRefQualifier() == RQ_RValue) ArgTy = Context.getRValueReferenceType(ArgTy); else ArgTy = Context.getLValueReferenceType(ArgTy); ArgTypes.push_back(ArgTy); } /// \brief Determine whether the function template \p FT1 is at least as /// specialized as \p FT2. static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc, FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, SmallVectorImpl *RefParamComparisons) { FunctionDecl *FD1 = FT1->getTemplatedDecl(); FunctionDecl *FD2 = FT2->getTemplatedDecl(); const FunctionProtoType *Proto1 = FD1->getType()->getAs(); const FunctionProtoType *Proto2 = FD2->getType()->getAs(); assert(Proto1 && Proto2 && "Function templates must have prototypes"); TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); SmallVector Deduced; Deduced.resize(TemplateParams->size()); // C++0x [temp.deduct.partial]p3: // The types used to determine the ordering depend on the context in which // the partial ordering is done: TemplateDeductionInfo Info(Loc); SmallVector Args2; switch (TPOC) { case TPOC_Call: { // - In the context of a function call, the function parameter types are // used. CXXMethodDecl *Method1 = dyn_cast(FD1); CXXMethodDecl *Method2 = dyn_cast(FD2); // C++11 [temp.func.order]p3: // [...] If only one of the function templates is a non-static // member, that function template is considered to have a new // first parameter inserted in its function parameter list. The // new parameter is of type "reference to cv A," where cv are // the cv-qualifiers of the function template (if any) and A is // the class of which the function template is a member. // // Note that we interpret this to mean "if one of the function // templates is a non-static member and the other is a non-member"; // otherwise, the ordering rules for static functions against non-static // functions don't make any sense. // // C++98/03 doesn't have this provision, so instead we drop the // first argument of the free function, which seems to match // existing practice. SmallVector Args1; unsigned Skip1 = 0, Skip2 = 0; unsigned NumComparedArguments = NumCallArguments1; if (!Method2 && Method1 && !Method1->isStatic()) { if (S.getLangOpts().CPlusPlus11) { // Compare 'this' from Method1 against first parameter from Method2. AddImplicitObjectParameterType(S.Context, Method1, Args1); ++NumComparedArguments; } else // Ignore first parameter from Method2. ++Skip2; } else if (!Method1 && Method2 && !Method2->isStatic()) { if (S.getLangOpts().CPlusPlus11) // Compare 'this' from Method2 against first parameter from Method1. AddImplicitObjectParameterType(S.Context, Method2, Args2); else // Ignore first parameter from Method1. ++Skip1; } Args1.insert(Args1.end(), Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end()); Args2.insert(Args2.end(), Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end()); // C++ [temp.func.order]p5: // The presence of unused ellipsis and default arguments has no effect on // the partial ordering of function templates. if (Args1.size() > NumComparedArguments) Args1.resize(NumComparedArguments); if (Args2.size() > NumComparedArguments) Args2.resize(NumComparedArguments); if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(), Args1.data(), Args1.size(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; } case TPOC_Conversion: // - In the context of a call to a conversion operator, the return types // of the conversion function templates are used. if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Proto2->getResultType(), Proto1->getResultType(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; case TPOC_Other: // - In other contexts (14.6.6.2) the function template's function type // is used. if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, FD2->getType(), FD1->getType(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; } // C++0x [temp.deduct.partial]p11: // In most cases, all template parameters must have values in order for // deduction to succeed, but for partial ordering purposes a template // parameter may remain without a value provided it is not used in the // types being used for partial ordering. [ Note: a template parameter used // in a non-deduced context is considered used. -end note] unsigned ArgIdx = 0, NumArgs = Deduced.size(); for (; ArgIdx != NumArgs; ++ArgIdx) if (Deduced[ArgIdx].isNull()) break; if (ArgIdx == NumArgs) { // All template arguments were deduced. FT1 is at least as specialized // as FT2. return true; } // Figure out which template parameters were used. llvm::SmallBitVector UsedParameters(TemplateParams->size()); switch (TPOC) { case TPOC_Call: for (unsigned I = 0, N = Args2.size(); I != N; ++I) ::MarkUsedTemplateParameters(S.Context, Args2[I], false, TemplateParams->getDepth(), UsedParameters); break; case TPOC_Conversion: ::MarkUsedTemplateParameters(S.Context, Proto2->getResultType(), false, TemplateParams->getDepth(), UsedParameters); break; case TPOC_Other: ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false, TemplateParams->getDepth(), UsedParameters); break; } for (; ArgIdx != NumArgs; ++ArgIdx) // If this argument had no value deduced but was used in one of the types // used for partial ordering, then deduction fails. if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) return false; return true; } /// \brief Determine whether this a function template whose parameter-type-list /// ends with a function parameter pack. static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { FunctionDecl *Function = FunTmpl->getTemplatedDecl(); unsigned NumParams = Function->getNumParams(); if (NumParams == 0) return false; ParmVarDecl *Last = Function->getParamDecl(NumParams - 1); if (!Last->isParameterPack()) return false; // Make sure that no previous parameter is a parameter pack. while (--NumParams > 0) { if (Function->getParamDecl(NumParams - 1)->isParameterPack()) return false; } return true; } /// \brief Returns the more specialized function template according /// to the rules of function template partial ordering (C++ [temp.func.order]). /// /// \param FT1 the first function template /// /// \param FT2 the second function template /// /// \param TPOC the context in which we are performing partial ordering of /// function templates. /// /// \param NumCallArguments1 The number of arguments in the call to FT1, used /// only when \c TPOC is \c TPOC_Call. /// /// \param NumCallArguments2 The number of arguments in the call to FT2, used /// only when \c TPOC is \c TPOC_Call. /// /// \returns the more specialized function template. If neither /// template is more specialized, returns NULL. FunctionTemplateDecl * Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, unsigned NumCallArguments2) { SmallVector RefParamComparisons; bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, NumCallArguments1, 0); bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, NumCallArguments2, &RefParamComparisons); if (Better1 != Better2) // We have a clear winner return Better1? FT1 : FT2; if (!Better1 && !Better2) // Neither is better than the other return 0; // C++0x [temp.deduct.partial]p10: // If for each type being considered a given template is at least as // specialized for all types and more specialized for some set of types and // the other template is not more specialized for any types or is not at // least as specialized for any types, then the given template is more // specialized than the other template. Otherwise, neither template is more // specialized than the other. Better1 = false; Better2 = false; for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) { // C++0x [temp.deduct.partial]p9: // If, for a given type, deduction succeeds in both directions (i.e., the // types are identical after the transformations above) and both P and A // were reference types (before being replaced with the type referred to // above): // -- if the type from the argument template was an lvalue reference // and the type from the parameter template was not, the argument // type is considered to be more specialized than the other; // otherwise, if (!RefParamComparisons[I].ArgIsRvalueRef && RefParamComparisons[I].ParamIsRvalueRef) { Better2 = true; if (Better1) return 0; continue; } else if (!RefParamComparisons[I].ParamIsRvalueRef && RefParamComparisons[I].ArgIsRvalueRef) { Better1 = true; if (Better2) return 0; continue; } // -- if the type from the argument template is more cv-qualified than // the type from the parameter template (as described above), the // argument type is considered to be more specialized than the // other; otherwise, switch (RefParamComparisons[I].Qualifiers) { case NeitherMoreQualified: break; case ParamMoreQualified: Better1 = true; if (Better2) return 0; continue; case ArgMoreQualified: Better2 = true; if (Better1) return 0; continue; } // -- neither type is more specialized than the other. } assert(!(Better1 && Better2) && "Should have broken out in the loop above"); if (Better1) return FT1; else if (Better2) return FT2; // FIXME: This mimics what GCC implements, but doesn't match up with the // proposed resolution for core issue 692. This area needs to be sorted out, // but for now we attempt to maintain compatibility. bool Variadic1 = isVariadicFunctionTemplate(FT1); bool Variadic2 = isVariadicFunctionTemplate(FT2); if (Variadic1 != Variadic2) return Variadic1? FT2 : FT1; return 0; } /// \brief Determine if the two templates are equivalent. static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { if (T1 == T2) return true; if (!T1 || !T2) return false; return T1->getCanonicalDecl() == T2->getCanonicalDecl(); } /// \brief Retrieve the most specialized of the given function template /// specializations. /// /// \param SpecBegin the start iterator of the function template /// specializations that we will be comparing. /// /// \param SpecEnd the end iterator of the function template /// specializations, paired with \p SpecBegin. /// /// \param Loc the location where the ambiguity or no-specializations /// diagnostic should occur. /// /// \param NoneDiag partial diagnostic used to diagnose cases where there are /// no matching candidates. /// /// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one /// occurs. /// /// \param CandidateDiag partial diagnostic used for each function template /// specialization that is a candidate in the ambiguous ordering. One parameter /// in this diagnostic should be unbound, which will correspond to the string /// describing the template arguments for the function template specialization. /// /// \returns the most specialized function template specialization, if /// found. Otherwise, returns SpecEnd. UnresolvedSetIterator Sema::getMostSpecialized( UnresolvedSetIterator SpecBegin, UnresolvedSetIterator SpecEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain, QualType TargetType) { if (SpecBegin == SpecEnd) { if (Complain) { Diag(Loc, NoneDiag); FailedCandidates.NoteCandidates(*this, Loc); } return SpecEnd; } if (SpecBegin + 1 == SpecEnd) return SpecBegin; // Find the function template that is better than all of the templates it // has been compared to. UnresolvedSetIterator Best = SpecBegin; FunctionTemplateDecl *BestTemplate = cast(*Best)->getPrimaryTemplate(); assert(BestTemplate && "Not a function template specialization?"); for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) { FunctionTemplateDecl *Challenger = cast(*I)->getPrimaryTemplate(); assert(Challenger && "Not a function template specialization?"); if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, Loc, TPOC_Other, 0, 0), Challenger)) { Best = I; BestTemplate = Challenger; } } // Make sure that the "best" function template is more specialized than all // of the others. bool Ambiguous = false; for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { FunctionTemplateDecl *Challenger = cast(*I)->getPrimaryTemplate(); if (I != Best && !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, Loc, TPOC_Other, 0, 0), BestTemplate)) { Ambiguous = true; break; } } if (!Ambiguous) { // We found an answer. Return it. return Best; } // Diagnose the ambiguity. if (Complain) { Diag(Loc, AmbigDiag); // FIXME: Can we order the candidates in some sane way? for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { PartialDiagnostic PD = CandidateDiag; PD << getTemplateArgumentBindingsText( cast(*I)->getPrimaryTemplate()->getTemplateParameters(), *cast(*I)->getTemplateSpecializationArgs()); if (!TargetType.isNull()) HandleFunctionTypeMismatch(PD, cast(*I)->getType(), TargetType); Diag((*I)->getLocation(), PD); } } return SpecEnd; } /// \brief Returns the more specialized class template partial specialization /// according to the rules of partial ordering of class template partial /// specializations (C++ [temp.class.order]). /// /// \param PS1 the first class template partial specialization /// /// \param PS2 the second class template partial specialization /// /// \returns the more specialized class template partial specialization. If /// neither partial specialization is more specialized, returns NULL. ClassTemplatePartialSpecializationDecl * Sema::getMoreSpecializedPartialSpecialization( ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { // C++ [temp.class.order]p1: // For two class template partial specializations, the first is at least as // specialized as the second if, given the following rewrite to two // function templates, the first function template is at least as // specialized as the second according to the ordering rules for function // templates (14.6.6.2): // - the first function template has the same template parameters as the // first partial specialization and has a single function parameter // whose type is a class template specialization with the template // arguments of the first partial specialization, and // - the second function template has the same template parameters as the // second partial specialization and has a single function parameter // whose type is a class template specialization with the template // arguments of the second partial specialization. // // Rather than synthesize function templates, we merely perform the // equivalent partial ordering by performing deduction directly on // the template arguments of the class template partial // specializations. This computation is slightly simpler than the // general problem of function template partial ordering, because // class template partial specializations are more constrained. We // know that every template parameter is deducible from the class // template partial specialization's template arguments, for // example. SmallVector Deduced; TemplateDeductionInfo Info(Loc); QualType PT1 = PS1->getInjectedSpecializationType(); QualType PT2 = PS2->getInjectedSpecializationType(); // Determine whether PS1 is at least as specialized as PS2 Deduced.resize(PS2->getTemplateParameters()->size()); bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); if (Better1) { SmallVector DeducedArgs(Deduced.begin(),Deduced.end()); InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, DeducedArgs, Info); Better1 = !::FinishTemplateArgumentDeduction( *this, PS2, PS1->getTemplateArgs(), Deduced, Info); } // Determine whether PS2 is at least as specialized as PS1 Deduced.clear(); Deduced.resize(PS1->getTemplateParameters()->size()); bool Better2 = !DeduceTemplateArgumentsByTypeMatch( *this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); if (Better2) { SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, DeducedArgs, Info); Better2 = !::FinishTemplateArgumentDeduction( *this, PS1, PS2->getTemplateArgs(), Deduced, Info); } if (Better1 == Better2) return 0; return Better1 ? PS1 : PS2; } /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. VarTemplatePartialSpecializationDecl * Sema::getMoreSpecializedPartialSpecialization( VarTemplatePartialSpecializationDecl *PS1, VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { SmallVector Deduced; TemplateDeductionInfo Info(Loc); assert(PS1->getSpecializedTemplate() == PS1->getSpecializedTemplate() && "the partial specializations being compared should specialize" " the same template."); TemplateName Name(PS1->getSpecializedTemplate()); TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name); QualType PT1 = Context.getTemplateSpecializationType( CanonTemplate, PS1->getTemplateArgs().data(), PS1->getTemplateArgs().size()); QualType PT2 = Context.getTemplateSpecializationType( CanonTemplate, PS2->getTemplateArgs().data(), PS2->getTemplateArgs().size()); // Determine whether PS1 is at least as specialized as PS2 Deduced.resize(PS2->getTemplateParameters()->size()); bool Better1 = !DeduceTemplateArgumentsByTypeMatch( *this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); if (Better1) { SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, DeducedArgs, Info); Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, PS1->getTemplateArgs(), Deduced, Info); } // Determine whether PS2 is at least as specialized as PS1 Deduced.clear(); Deduced.resize(PS1->getTemplateParameters()->size()); bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); if (Better2) { SmallVector DeducedArgs(Deduced.begin(),Deduced.end()); InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, DeducedArgs, Info); Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, PS2->getTemplateArgs(), Deduced, Info); } if (Better1 == Better2) return 0; return Better1? PS1 : PS2; } static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used); /// \brief Mark the template parameters that are used by the given /// expression. static void MarkUsedTemplateParameters(ASTContext &Ctx, const Expr *E, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { // We can deduce from a pack expansion. if (const PackExpansionExpr *Expansion = dyn_cast(E)) E = Expansion->getPattern(); // Skip through any implicit casts we added while type-checking, and any // substitutions performed by template alias expansion. while (1) { if (const ImplicitCastExpr *ICE = dyn_cast(E)) E = ICE->getSubExpr(); else if (const SubstNonTypeTemplateParmExpr *Subst = dyn_cast(E)) E = Subst->getReplacement(); else break; } // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to // find other occurrences of template parameters. const DeclRefExpr *DRE = dyn_cast(E); if (!DRE) return; const NonTypeTemplateParmDecl *NTTP = dyn_cast(DRE->getDecl()); if (!NTTP) return; if (NTTP->getDepth() == Depth) Used[NTTP->getIndex()] = true; } /// \brief Mark the template parameters that are used by the given /// nested name specifier. static void MarkUsedTemplateParameters(ASTContext &Ctx, NestedNameSpecifier *NNS, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (!NNS) return; MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0), OnlyDeduced, Depth, Used); } /// \brief Mark the template parameters that are used by the given /// template name. static void MarkUsedTemplateParameters(ASTContext &Ctx, TemplateName Name, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (TemplateDecl *Template = Name.getAsTemplateDecl()) { if (TemplateTemplateParmDecl *TTP = dyn_cast(Template)) { if (TTP->getDepth() == Depth) Used[TTP->getIndex()] = true; } return; } if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced, Depth, Used); if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced, Depth, Used); } /// \brief Mark the template parameters that are used by the given /// type. static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (T.isNull()) return; // Non-dependent types have nothing deducible if (!T->isDependentType()) return; T = Ctx.getCanonicalType(T); switch (T->getTypeClass()) { case Type::Pointer: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::BlockPointer: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::LValueReference: case Type::RValueReference: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::MemberPointer: { const MemberPointerType *MemPtr = cast(T.getTypePtr()); MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0), OnlyDeduced, Depth, Used); break; } case Type::DependentSizedArray: MarkUsedTemplateParameters(Ctx, cast(T)->getSizeExpr(), OnlyDeduced, Depth, Used); // Fall through to check the element type case Type::ConstantArray: case Type::IncompleteArray: MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::Vector: case Type::ExtVector: MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::DependentSizedExtVector: { const DependentSizedExtVectorType *VecType = cast(T); MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, Depth, Used); break; } case Type::FunctionProto: { const FunctionProtoType *Proto = cast(T); MarkUsedTemplateParameters(Ctx, Proto->getResultType(), OnlyDeduced, Depth, Used); for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Proto->getArgType(I), OnlyDeduced, Depth, Used); break; } case Type::TemplateTypeParm: { const TemplateTypeParmType *TTP = cast(T); if (TTP->getDepth() == Depth) Used[TTP->getIndex()] = true; break; } case Type::SubstTemplateTypeParmPack: { const SubstTemplateTypeParmPackType *Subst = cast(T); MarkUsedTemplateParameters(Ctx, QualType(Subst->getReplacedParameter(), 0), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(), OnlyDeduced, Depth, Used); break; } case Type::InjectedClassName: T = cast(T)->getInjectedSpecializationType(); // fall through case Type::TemplateSpecialization: { const TemplateSpecializationType *Spec = cast(T); MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced, Depth, Used); // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) break; for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, Used); break; } case Type::Complex: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::Atomic: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getValueType(), OnlyDeduced, Depth, Used); break; case Type::DependentName: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getQualifier(), OnlyDeduced, Depth, Used); break; case Type::DependentTemplateSpecialization: { const DependentTemplateSpecializationType *Spec = cast(T); if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, Spec->getQualifier(), OnlyDeduced, Depth, Used); // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) break; for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, Used); break; } case Type::TypeOf: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingType(), OnlyDeduced, Depth, Used); break; case Type::TypeOfExpr: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingExpr(), OnlyDeduced, Depth, Used); break; case Type::Decltype: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingExpr(), OnlyDeduced, Depth, Used); break; case Type::UnaryTransform: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingType(), OnlyDeduced, Depth, Used); break; case Type::PackExpansion: MarkUsedTemplateParameters(Ctx, cast(T)->getPattern(), OnlyDeduced, Depth, Used); break; case Type::Auto: MarkUsedTemplateParameters(Ctx, cast(T)->getDeducedType(), OnlyDeduced, Depth, Used); // None of these types have any template parameters in them. case Type::Builtin: case Type::VariableArray: case Type::FunctionNoProto: case Type::Record: case Type::Enum: case Type::ObjCInterface: case Type::ObjCObject: case Type::ObjCObjectPointer: case Type::UnresolvedUsing: #define TYPE(Class, Base) #define ABSTRACT_TYPE(Class, Base) #define DEPENDENT_TYPE(Class, Base) #define NON_CANONICAL_TYPE(Class, Base) case Type::Class: #include "clang/AST/TypeNodes.def" break; } } /// \brief Mark the template parameters that are used by this /// template argument. static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { switch (TemplateArg.getKind()) { case TemplateArgument::Null: case TemplateArgument::Integral: case TemplateArgument::Declaration: break; case TemplateArgument::NullPtr: MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Type: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsTemplateOrTemplatePattern(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Expression: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Pack: for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(), PEnd = TemplateArg.pack_end(); P != PEnd; ++P) MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used); break; } } /// \brief Mark which template parameters can be deduced from a given /// template argument list. /// /// \param TemplateArgs the template argument list from which template /// parameters will be deduced. /// /// \param Used a bit vector whose elements will be set to \c true /// to indicate when the corresponding template parameter will be /// deduced. void Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size())) return; for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced, Depth, Used); } /// \brief Marks all of the template parameters that will be deduced by a /// call to the given function template. void Sema::MarkDeducedTemplateParameters(ASTContext &Ctx, const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced) { TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); Deduced.clear(); Deduced.resize(TemplateParams->size()); FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(), true, TemplateParams->getDepth(), Deduced); } bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T) { if (!T->isDependentType()) return false; TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); llvm::SmallBitVector Deduced(TemplateParams->size()); ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), Deduced); return Deduced.any(); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.4rc2 r196603. Many bug fixes and improvements for the driver NetBSD/ARM EABI. @ text @a3503 22 QualType Sema::adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType) { if (ArgFunctionType.isNull()) return ArgFunctionType; const FunctionProtoType *FunctionTypeP = FunctionType->castAs(); CallingConv CC = FunctionTypeP->getCallConv(); bool NoReturn = FunctionTypeP->getNoReturnAttr(); const FunctionProtoType *ArgFunctionTypeP = ArgFunctionType->getAs(); if (ArgFunctionTypeP->getCallConv() == CC && ArgFunctionTypeP->getNoReturnAttr() == NoReturn) return ArgFunctionType; FunctionType::ExtInfo EI = ArgFunctionTypeP->getExtInfo().withCallingConv(CC); EI = EI.withNoReturn(NoReturn); ArgFunctionTypeP = cast(Context.adjustFunctionType(ArgFunctionTypeP, EI)); return QualType(ArgFunctionTypeP, 0); } d3541 17 a3557 2 if (!InOverloadResolution) ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType); @ 1.1.1.3 log @Import clang 3.5svn r198450. @ text @a983 11 else if (ArgQuals.getObjCLifetime() != ParamQuals.getObjCLifetime() && ArgQuals.withoutObjCLifetime() == ParamQuals.withoutObjCLifetime()) { // Prefer binding to non-__unsafe_autoretained parameters. if (ArgQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && ParamQuals.getObjCLifetime()) Comparison.Qualifiers = ParamMoreQualified; else if (ParamQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && ArgQuals.getObjCLifetime()) Comparison.Qualifiers = ArgMoreQualified; } d4656 1 a4656 1 assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() && @ 1.1.1.4 log @Import Clang 3.5svn r199312 @ text @d2288 2 a2289 2 InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, Info); d2452 2 a2453 2 InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, Info); d2538 2 a2539 2 InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate, DeducedArgs, d2792 2 a2793 2 InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate, DeducedArgs, d4627 2 a4628 1 InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info); d4643 2 a4644 1 InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info); d4688 2 a4689 1 InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info); d4705 2 a4706 1 InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info); @ 1.1.1.5 log @Import Clang 3.5svn r201163. @ text @d1378 5 a1382 4 if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, FunctionProtoParam->getReturnType(), FunctionProtoArg->getReturnType(), Info, Deduced, 0)) d1385 6 a1390 5 return DeduceTemplateArguments( S, TemplateParams, FunctionProtoParam->param_type_begin(), FunctionProtoParam->getNumParams(), FunctionProtoArg->param_type_begin(), FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF); d2618 5 a2622 5 ResultType = SubstType(Proto->getReturnType(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), Function->getTypeSpecStartLoc(), Function->getDeclName()); d2990 2 a2991 2 if (S.getLangOpts().CPlusPlus1y && Fn->getReturnType()->isUndeducedType() && S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false)) d3603 1 a3603 1 Function->getReturnType()->getContainedAutoType()) { d3628 1 a3628 1 Specialization->getReturnType()->isUndeducedType() && d3657 1 a3657 1 QualType AutoResultType = F->getReturnType(); d3682 1 a3682 1 QualType CallOpResultType = CallOpGeneric->getReturnType(); d3699 2 a3700 2 if (GenericLambdaCallOperatorHasDeducedReturnType && CallOpSpecialized->getReturnType()->isUndeducedType()) d3707 1 a3707 1 if (!S.Context.hasSameType(CallOpSpecialized->getReturnType(), d3726 2 a3727 2 if (GenericLambdaCallOperatorHasDeducedReturnType && InvokerSpecialized->getReturnType()->isUndeducedType()) { d3736 3 a3738 3 QualType TypeToReplaceAutoWith = CallOpSpecialized->getReturnType() ->getContainedAutoType() ->getDeducedType(); d3754 1 a3754 1 InvokerFPT->getReturnType(), InvokerFPT->getParamTypes(), EPI)); d3877 2 a3878 2 const QualType DestFunctionPtrReturnType = ToFunType->getReturnType(); d4123 1 a4123 1 assert(FD->getReturnType()->isUndeducedType()); d4128 1 a4128 1 bool StillUndeduced = FD->getReturnType()->isUndeducedType(); d4234 4 a4237 4 Args1.insert(Args1.end(), Proto1->param_type_begin() + Skip1, Proto1->param_type_end()); Args2.insert(Args2.end(), Proto2->param_type_begin() + Skip2, Proto2->param_type_end()); d4258 6 a4263 4 if (DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) d4307 3 a4309 2 ::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), false, TemplateParams->getDepth(), UsedParameters); d4884 4 a4887 4 MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth, Used); for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced, @ 1.1.1.5.2.1 log @Rebase. @ text @d129 1 a129 1 RefParamComparisons = nullptr); d158 1 a158 1 return nullptr; a299 1 // FIXME: Do we need to merge the results together here? d385 1 a385 1 D = D ? cast(D->getCanonicalDecl()) : nullptr; d584 2 a585 39 /// A pack that we're currently deducing. struct clang::DeducedPack { DeducedPack(unsigned Index) : Index(Index), Outer(nullptr) {} // The index of the pack. unsigned Index; // The old value of the pack before we started deducing it. DeducedTemplateArgument Saved; // A deferred value of this pack from an inner deduction, that couldn't be // deduced because this deduction hadn't happened yet. DeducedTemplateArgument DeferredDeduction; // The new value of the pack. SmallVector New; // The outer deduction for this pack, if any. DeducedPack *Outer; }; /// A scope in which we're performing pack deduction. class PackDeductionScope { public: PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info, TemplateArgument Pattern) : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) { // Compute the set of template parameter indices that correspond to // parameter packs expanded by the pack expansion. { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; S.collectUnexpandedParameterPacks(Pattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; std::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; d587 15 a601 5 // Save the deduced template argument for the parameter pack expanded // by this pack expansion, then clear out the deduction. DeducedPack Pack(Index); Pack.Saved = Deduced[Index]; Deduced[Index] = TemplateArgument(); d603 2 a604 12 Packs.push_back(Pack); } } } assert(!Packs.empty() && "Pack expansion without unexpanded packs?"); for (auto &Pack : Packs) { if (Info.PendingDeducedPacks.size() > Pack.Index) Pack.Outer = Info.PendingDeducedPacks[Pack.Index]; else Info.PendingDeducedPacks.resize(Pack.Index + 1); Info.PendingDeducedPacks[Pack.Index] = &Pack; d606 11 a616 12 if (S.CurrentInstantiationScope) { // If the template argument pack was explicitly specified, add that to // the set of deduced arguments. const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; NamedDecl *PartiallySubstitutedPack = S.CurrentInstantiationScope->getPartiallySubstitutedPack( &ExplicitArgs, &NumExplicitArgs); if (PartiallySubstitutedPack && getDepthAndIndex(PartiallySubstitutedPack).second == Pack.Index) Pack.New.append(ExplicitArgs, ExplicitArgs + NumExplicitArgs); } d619 1 d621 20 a640 16 ~PackDeductionScope() { for (auto &Pack : Packs) Info.PendingDeducedPacks[Pack.Index] = Pack.Outer; } /// Move to deducing the next element in each pack that is being deduced. void nextPackElement() { // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (auto &Pack : Packs) { DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index]; if (!DeducedArg.isNull()) { Pack.New.push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } a641 1 } d643 1 a643 19 /// \brief Finish template argument deduction for a set of argument packs, /// producing the argument packs and checking for consistency with prior /// deductions. Sema::TemplateDeductionResult finish(bool HasAnyArguments) { // Build argument packs for each of the parameter packs expanded by this // pack expansion. for (auto &Pack : Packs) { // Put back the old value for this pack. Deduced[Pack.Index] = Pack.Saved; // Build or find a new value for this pack. DeducedTemplateArgument NewPack; if (HasAnyArguments && Pack.New.empty()) { if (Pack.DeferredDeduction.isNull()) { // We were not able to deduce anything for this parameter pack // (because it only appeared in non-deduced contexts), so just // restore the saved argument pack. continue; } d645 13 a657 13 NewPack = Pack.DeferredDeduction; Pack.DeferredDeduction = TemplateArgument(); } else if (Pack.New.empty()) { // If we deduced an empty argument pack, create it now. NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); } else { TemplateArgument *ArgumentPack = new (S.Context) TemplateArgument[Pack.New.size()]; std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack); NewPack = DeducedTemplateArgument( TemplateArgument(ArgumentPack, Pack.New.size()), Pack.New[0].wasDeducedFromArrayBound()); } d659 8 a666 35 // Pick where we're going to put the merged pack. DeducedTemplateArgument *Loc; if (Pack.Outer) { if (Pack.Outer->DeferredDeduction.isNull()) { // Defer checking this pack until we have a complete pack to compare // it against. Pack.Outer->DeferredDeduction = NewPack; continue; } Loc = &Pack.Outer->DeferredDeduction; } else { Loc = &Deduced[Pack.Index]; } // Check the new pack matches any previous value. DeducedTemplateArgument OldPack = *Loc; DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack); // If we deferred a deduction of this pack, check that one now too. if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) { OldPack = Result; NewPack = Pack.DeferredDeduction; Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack); } if (Result.isNull()) { Info.Param = makeTemplateParameter(TemplateParams->getParam(Pack.Index)); Info.FirstArg = OldPack; Info.SecondArg = NewPack; return Sema::TDK_Inconsistent; } *Loc = Result; d669 1 a669 1 return Sema::TDK_Success; d672 2 a673 8 private: Sema &S; TemplateParameterList *TemplateParams; SmallVectorImpl &Deduced; TemplateDeductionInfo &Info; SmallVector Packs; }; d718 1 a718 1 RefParamComparisons = nullptr) { d776 3 d780 23 a802 1 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); d816 10 a825 1 PackScope.nextPackElement(); d830 4 a833 1 if (auto Result = PackScope.finish(HasAnyArguments)) d1475 4 a1478 2 for (const auto &Base : Next->bases()) { assert(Base.getType()->isRecordType() && d1480 1 a1480 1 ToVisit.push_back(Base.getType()->getAs()); d1857 18 d1879 7 a1885 2 // Prepare to deduce the packs within the pattern. PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); d1891 1 a1891 1 for (; hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs); ++ArgIdx) { d1900 12 a1911 1 PackScope.nextPackElement(); d1916 4 a1919 1 if (auto Result = PackScope.finish(HasAnyArguments)) d2025 1 a2025 1 .getAs(); d2032 1 a2032 1 .getAs(); d2039 1 a2039 1 = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs(); d2466 1 a2466 1 return Spec->getTemplateName().getAsTemplateDecl() != nullptr; d2510 5 a2514 2 for (auto P : Function->params()) ParamTypes.push_back(P->getType()); d2608 1 a2608 1 CXXRecordDecl *ThisContext = nullptr; d3060 1 a3060 1 FunctionDecl *Specialization = nullptr; d3152 1 a3152 1 ParamRefType != nullptr); d3321 1 a3321 1 nullptr, d3411 15 a3425 2 PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info, ParamPattern); d3427 8 d3443 1 a3443 1 d3484 10 a3493 1 PackScope.nextPackElement(); d3498 4 a3501 1 if (auto Result = PackScope.finish(HasAnyArguments)) d3687 1 a3687 1 FunctionDecl *CallOpSpecialized = nullptr; d3713 1 a3713 1 FunctionDecl *InvokerSpecialized = nullptr; d3856 1 a3856 1 FunctionDecl *ConversionSpecialized = nullptr; d3990 1 a3990 1 Init = NonPlaceholder.get(); d4025 2 a4026 2 TemplateTypeParmDecl::Create(Context, nullptr, SourceLocation(), Loc, 0, 0, nullptr, false, false); d4248 1 a4248 1 return false; d4371 1 a4371 1 NumCallArguments1, nullptr); d4380 1 a4380 1 return nullptr; d4406 1 a4406 1 return nullptr; d4412 1 a4412 1 return nullptr; d4427 1 a4427 1 return nullptr; d4433 1 a4433 1 return nullptr; d4454 1 a4454 1 return nullptr; d4619 1 a4619 1 /*RefParamComparisons=*/nullptr); d4633 1 a4633 1 /*RefParamComparisons=*/nullptr); d4643 1 a4643 1 return nullptr; d4677 1 a4677 1 /*RefParamComparisons=*/nullptr); d4694 1 a4694 1 /*RefParamComparisons=*/nullptr); d4704 1 a4704 1 return nullptr; @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @d129 1 a129 1 RefParamComparisons = nullptr); d158 1 a158 1 return nullptr; a299 1 // FIXME: Do we need to merge the results together here? d385 1 a385 1 D = D ? cast(D->getCanonicalDecl()) : nullptr; d584 2 a585 39 /// A pack that we're currently deducing. struct clang::DeducedPack { DeducedPack(unsigned Index) : Index(Index), Outer(nullptr) {} // The index of the pack. unsigned Index; // The old value of the pack before we started deducing it. DeducedTemplateArgument Saved; // A deferred value of this pack from an inner deduction, that couldn't be // deduced because this deduction hadn't happened yet. DeducedTemplateArgument DeferredDeduction; // The new value of the pack. SmallVector New; // The outer deduction for this pack, if any. DeducedPack *Outer; }; /// A scope in which we're performing pack deduction. class PackDeductionScope { public: PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info, TemplateArgument Pattern) : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) { // Compute the set of template parameter indices that correspond to // parameter packs expanded by the pack expansion. { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; S.collectUnexpandedParameterPacks(Pattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; std::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; d587 15 a601 5 // Save the deduced template argument for the parameter pack expanded // by this pack expansion, then clear out the deduction. DeducedPack Pack(Index); Pack.Saved = Deduced[Index]; Deduced[Index] = TemplateArgument(); d603 2 a604 12 Packs.push_back(Pack); } } } assert(!Packs.empty() && "Pack expansion without unexpanded packs?"); for (auto &Pack : Packs) { if (Info.PendingDeducedPacks.size() > Pack.Index) Pack.Outer = Info.PendingDeducedPacks[Pack.Index]; else Info.PendingDeducedPacks.resize(Pack.Index + 1); Info.PendingDeducedPacks[Pack.Index] = &Pack; d606 11 a616 12 if (S.CurrentInstantiationScope) { // If the template argument pack was explicitly specified, add that to // the set of deduced arguments. const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; NamedDecl *PartiallySubstitutedPack = S.CurrentInstantiationScope->getPartiallySubstitutedPack( &ExplicitArgs, &NumExplicitArgs); if (PartiallySubstitutedPack && getDepthAndIndex(PartiallySubstitutedPack).second == Pack.Index) Pack.New.append(ExplicitArgs, ExplicitArgs + NumExplicitArgs); } d619 1 d621 20 a640 16 ~PackDeductionScope() { for (auto &Pack : Packs) Info.PendingDeducedPacks[Pack.Index] = Pack.Outer; } /// Move to deducing the next element in each pack that is being deduced. void nextPackElement() { // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (auto &Pack : Packs) { DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index]; if (!DeducedArg.isNull()) { Pack.New.push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } a641 1 } d643 1 a643 19 /// \brief Finish template argument deduction for a set of argument packs, /// producing the argument packs and checking for consistency with prior /// deductions. Sema::TemplateDeductionResult finish(bool HasAnyArguments) { // Build argument packs for each of the parameter packs expanded by this // pack expansion. for (auto &Pack : Packs) { // Put back the old value for this pack. Deduced[Pack.Index] = Pack.Saved; // Build or find a new value for this pack. DeducedTemplateArgument NewPack; if (HasAnyArguments && Pack.New.empty()) { if (Pack.DeferredDeduction.isNull()) { // We were not able to deduce anything for this parameter pack // (because it only appeared in non-deduced contexts), so just // restore the saved argument pack. continue; } d645 13 a657 13 NewPack = Pack.DeferredDeduction; Pack.DeferredDeduction = TemplateArgument(); } else if (Pack.New.empty()) { // If we deduced an empty argument pack, create it now. NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); } else { TemplateArgument *ArgumentPack = new (S.Context) TemplateArgument[Pack.New.size()]; std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack); NewPack = DeducedTemplateArgument( TemplateArgument(ArgumentPack, Pack.New.size()), Pack.New[0].wasDeducedFromArrayBound()); } d659 8 a666 35 // Pick where we're going to put the merged pack. DeducedTemplateArgument *Loc; if (Pack.Outer) { if (Pack.Outer->DeferredDeduction.isNull()) { // Defer checking this pack until we have a complete pack to compare // it against. Pack.Outer->DeferredDeduction = NewPack; continue; } Loc = &Pack.Outer->DeferredDeduction; } else { Loc = &Deduced[Pack.Index]; } // Check the new pack matches any previous value. DeducedTemplateArgument OldPack = *Loc; DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack); // If we deferred a deduction of this pack, check that one now too. if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) { OldPack = Result; NewPack = Pack.DeferredDeduction; Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack); } if (Result.isNull()) { Info.Param = makeTemplateParameter(TemplateParams->getParam(Pack.Index)); Info.FirstArg = OldPack; Info.SecondArg = NewPack; return Sema::TDK_Inconsistent; } *Loc = Result; d669 1 a669 1 return Sema::TDK_Success; d672 2 a673 8 private: Sema &S; TemplateParameterList *TemplateParams; SmallVectorImpl &Deduced; TemplateDeductionInfo &Info; SmallVector Packs; }; d718 1 a718 1 RefParamComparisons = nullptr) { d776 3 d780 23 a802 1 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); d816 10 a825 1 PackScope.nextPackElement(); d830 4 a833 1 if (auto Result = PackScope.finish(HasAnyArguments)) d1475 4 a1478 2 for (const auto &Base : Next->bases()) { assert(Base.getType()->isRecordType() && d1480 1 a1480 1 ToVisit.push_back(Base.getType()->getAs()); d1857 18 d1879 7 a1885 2 // Prepare to deduce the packs within the pattern. PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); d1891 1 a1891 1 for (; hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs); ++ArgIdx) { d1900 12 a1911 1 PackScope.nextPackElement(); d1916 4 a1919 1 if (auto Result = PackScope.finish(HasAnyArguments)) d2025 1 a2025 1 .getAs(); d2032 1 a2032 1 .getAs(); d2039 1 a2039 1 = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs(); d2466 1 a2466 1 return Spec->getTemplateName().getAsTemplateDecl() != nullptr; d2510 5 a2514 2 for (auto P : Function->params()) ParamTypes.push_back(P->getType()); d2608 1 a2608 1 CXXRecordDecl *ThisContext = nullptr; d3060 1 a3060 1 FunctionDecl *Specialization = nullptr; d3152 1 a3152 1 ParamRefType != nullptr); d3321 1 a3321 1 nullptr, d3411 15 a3425 2 PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info, ParamPattern); d3427 8 d3443 1 a3443 1 d3484 10 a3493 1 PackScope.nextPackElement(); d3498 4 a3501 1 if (auto Result = PackScope.finish(HasAnyArguments)) d3687 1 a3687 1 FunctionDecl *CallOpSpecialized = nullptr; d3713 1 a3713 1 FunctionDecl *InvokerSpecialized = nullptr; d3856 1 a3856 1 FunctionDecl *ConversionSpecialized = nullptr; d3990 1 a3990 1 Init = NonPlaceholder.get(); d4025 2 a4026 2 TemplateTypeParmDecl::Create(Context, nullptr, SourceLocation(), Loc, 0, 0, nullptr, false, false); d4248 1 a4248 1 return false; d4371 1 a4371 1 NumCallArguments1, nullptr); d4380 1 a4380 1 return nullptr; d4406 1 a4406 1 return nullptr; d4412 1 a4412 1 return nullptr; d4427 1 a4427 1 return nullptr; d4433 1 a4433 1 return nullptr; d4454 1 a4454 1 return nullptr; d4619 1 a4619 1 /*RefParamComparisons=*/nullptr); d4633 1 a4633 1 /*RefParamComparisons=*/nullptr); d4643 1 a4643 1 return nullptr; d4677 1 a4677 1 /*RefParamComparisons=*/nullptr); d4694 1 a4694 1 /*RefParamComparisons=*/nullptr); d4704 1 a4704 1 return nullptr; @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @d1305 1 a1305 2 const LValueReferenceType *ReferenceArg = Arg->getAs(); d1316 1 a1316 2 const RValueReferenceType *ReferenceArg = Arg->getAs(); d2059 1 a2059 2 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) d2098 3 a2100 1 for (const auto &P : Arg.pack_elements()) { d2104 1 a2104 1 DeducedTemplateArgument InnerArg(P); a2818 11 // We may have had explicitly-specified template arguments for a // template parameter pack (that may or may not have been extended // via additional deduced arguments). if (Param->isParameterPack() && CurrentInstantiationScope) { if (CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) { // Forget the partially-substituted pack; its substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); } } d2821 1 d3224 3 a3226 3 static bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T); d3483 2 a3484 2 NumExplicitlySpecified, Specialization, Info, &OriginalCallArgs); d3783 1 a3783 1 // type are ignored for type deduction. If A is a reference type, the type d3837 2 a3838 2 // to a ptr-to-function, use the deduced arguments from the conversion // function to specialize the corresponding call operator. d3902 3 a3904 4 SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) : TreeTransform(SemaRef), Replacement(Replacement) {} d4181 3 a4183 2 // C++98/03 doesn't have this provision but we've extended DR532 to cover // it as wording was broken prior to it. d4186 1 d4190 7 a4196 3 // Compare 'this' from Method1 against first parameter from Method2. AddImplicitObjectParameterType(S.Context, Method1, Args1); ++NumComparedArguments; d4198 6 a4203 2 // Compare 'this' from Method2 against first parameter from Method1. AddImplicitObjectParameterType(S.Context, Method2, Args2); d4206 1 a4206 1 Args1.insert(Args1.end(), Proto1->param_type_begin(), d4208 1 a4208 1 Args2.insert(Args2.end(), Proto2->param_type_begin(), d4890 2 a4891 2 // If the template argument list of P contains a pack expansion that is // not the last template argument, the entire template argument list is a d5040 4 a5043 2 for (const auto &P : TemplateArg.pack_elements()) MarkUsedTemplateParameters(Ctx, P, OnlyDeduced, Depth, Used); d5076 4 a5079 3 void Sema::MarkDeducedTemplateParameters( ASTContext &Ctx, const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced) { @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d265 2 a266 1 isSameDeclaration(X.getAsDecl(), Y.getAsDecl())) d387 1 a387 1 TemplateArgument New(D, NTTP->getType()); d1497 1 a1497 1 if (!Visited.insert(NextT).second) d1731 2 a1732 1 isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl())) d1967 2 a1968 1 return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()); a2593 3 // Isolate our substituted parameters from our caller. LocalInstantiationScope InstScope(*this, /*MergeWithOuterScope*/true); d3006 1 a3006 1 if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() && d3585 1 a3585 1 if (getLangOpts().CPlusPlus14 && InOverloadResolution && d3995 1 a3995 1 QualType Deduced = BuildDecltypeType(Init, Init->getLocStart(), false); @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @d265 2 a266 1 isSameDeclaration(X.getAsDecl(), Y.getAsDecl())) d387 1 a387 1 TemplateArgument New(D, NTTP->getType()); d1497 1 a1497 1 if (!Visited.insert(NextT).second) d1731 2 a1732 1 isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl())) d1967 2 a1968 1 return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()); a2593 3 // Isolate our substituted parameters from our caller. LocalInstantiationScope InstScope(*this, /*MergeWithOuterScope*/true); d3006 1 a3006 1 if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() && d3585 1 a3585 1 if (getLangOpts().CPlusPlus14 && InOverloadResolution && d3995 1 a3995 1 QualType Deduced = BuildDecltypeType(Init, Init->getLocStart(), false); @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @d94 24 d127 3 a129 1 bool PartialOrdering = false); a604 1 namespace { d707 1 a707 1 TemplateArgument(llvm::makeArrayRef(ArgumentPack, Pack.New.size())), a758 1 } // namespace d787 3 d801 3 a803 1 bool PartialOrdering = false) { d839 2 a840 1 PartialOrdering)) d872 2 a873 1 TDF, PartialOrdering)) d970 3 d983 3 a985 1 bool PartialOrdering) { d998 1 a998 1 // C++11 [temp.deduct.partial]p5: d1011 7 a1017 15 if (ParamRef && ArgRef && S.Context.hasSameUnqualifiedType(Param, Arg)) { // C++11 [temp.deduct.partial]p9: // If, for a given type, deduction succeeds in both directions (i.e., // the types are identical after the transformations above) and both // P and A were reference types [...]: // - if [one type] was an lvalue reference and [the other type] was // not, [the other type] is not considered to be at least as // specialized as [the first type] // - if [one type] is more cv-qualified than [the other type], // [the other type] is not considered to be at least as specialized // as [the first type] // Objective-C ARC adds: // - [one type] has non-trivial lifetime, [the other type] has // __unsafe_unretained lifetime, and the types are otherwise // identical d1019 7 a1025 4 // A is "considered to be at least as specialized" as P iff deduction // succeeds, so we model this as a deduction failure. Note that // [the first type] is P and [the other type] is A here; the standard // gets this backwards. d1028 14 a1041 10 if ((ParamRef->isLValueReferenceType() && !ArgRef->isLValueReferenceType()) || ParamQuals.isStrictSupersetOf(ArgQuals) || (ParamQuals.hasNonTrivialObjCLifetime() && ArgQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && ParamQuals.withoutObjCLifetime() == ArgQuals.withoutObjCLifetime())) { Info.FirstArg = TemplateArgument(ParamIn); Info.SecondArg = TemplateArgument(ArgIn); return Sema::TDK_NonDeducedMismatch; d1043 1 d1046 1 a1046 1 // C++11 [temp.deduct.partial]p7: d1479 1 a1479 1 if (!S.isCompleteType(Info.getLocation(), Arg)) a1555 9 QualType ParamPointeeType = MemPtrParam->getPointeeType(); if (ParamPointeeType->isFunctionType()) S.adjustMemberFunctionCC(ParamPointeeType, /*IsStatic=*/true, /*IsCtorOrDtor=*/false, Info.getLocation()); QualType ArgPointeeType = MemPtrArg->getPointeeType(); if (ArgPointeeType->isFunctionType()) S.adjustMemberFunctionCC(ArgPointeeType, /*IsStatic=*/true, /*IsCtorOrDtor=*/false, Info.getLocation()); d1558 2 a1559 2 ParamPointeeType, ArgPointeeType, a1681 1 case Type::Pipe: d2114 3 a2116 2 Output.push_back( TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder)); d2769 1 a2769 1 S.IsDerivedFrom(SourceLocation(), A, DeducedA)) d2787 1 a2787 2 SmallVectorImpl const *OriginalCallArgs, bool PartialOverloading) { d2888 1 a2888 2 Builder.push_back(TemplateArgument( llvm::makeArrayRef(ExplicitArgs, NumExplicitArgs))); a2913 2 if (PartialOverloading) break; d2981 2 a2982 6 if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) { Info.FirstArg = TemplateArgument(DeducedA); Info.SecondArg = TemplateArgument(OriginalArg.OriginalArgType); Info.CallArgIndex = OriginalArg.ArgIdx; return TDK_DeducedMismatch; } d3064 1 a3064 1 Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs); d3139 7 d3147 17 a3163 5 // [...] If P is a reference type, the type referred to by P is // used for type deduction. const ReferenceType *ParamRefType = ParamType->getAs(); if (ParamRefType) ParamType = ParamRefType->getPointeeType(); d3165 2 a3166 3 // Overload sets usually make this parameter an undeduced context, // but there are sometimes special circumstances. Typically // involving a template-id-expr. a3175 6 // If the argument has incomplete array type, try to complete its type. if (ArgType->isIncompleteArrayType()) { S.completeExprArrayBound(Arg); ArgType = Arg->getType(); } d3177 3 a3179 3 // If P is an rvalue reference to a cv-unqualified template // parameter and the argument is an lvalue, the type "lvalue // reference to A" is used in place of A for type deduction. d3181 1 a3181 2 !ParamType.getQualifiers() && isa(ParamType) && a3238 73 static Sema::TemplateDeductionResult DeduceTemplateArgumentByListElement( Sema &S, TemplateParameterList *TemplateParams, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF); /// \brief Attempt template argument deduction from an initializer list /// deemed to be an argument in a function call. static bool DeduceFromInitializerList(Sema &S, TemplateParameterList *TemplateParams, QualType AdjustedParamType, InitListExpr *ILE, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF, Sema::TemplateDeductionResult &Result) { // [temp.deduct.call] p1 (post CWG-1591) // If removing references and cv-qualifiers from P gives // std::initializer_list or P0[N] for some P0 and N and the argument is a // non-empty initializer list (8.5.4), then deduction is performed instead for // each element of the initializer list, taking P0 as a function template // parameter type and the initializer element as its argument, and in the // P0[N] case, if N is a non-type template parameter, N is deduced from the // length of the initializer list. Otherwise, an initializer list argument // causes the parameter to be considered a non-deduced context const bool IsConstSizedArray = AdjustedParamType->isConstantArrayType(); const bool IsDependentSizedArray = !IsConstSizedArray && AdjustedParamType->isDependentSizedArrayType(); QualType ElTy; // The element type of the std::initializer_list or the array. const bool IsSTDList = !IsConstSizedArray && !IsDependentSizedArray && S.isStdInitializerList(AdjustedParamType, &ElTy); if (!IsConstSizedArray && !IsDependentSizedArray && !IsSTDList) return false; Result = Sema::TDK_Success; // If we are not deducing against the 'T' in a std::initializer_list then // deduce against the 'T' in T[N]. if (ElTy.isNull()) { assert(!IsSTDList); ElTy = S.Context.getAsArrayType(AdjustedParamType)->getElementType(); } // Deduction only needs to be done for dependent types. if (ElTy->isDependentType()) { for (Expr *E : ILE->inits()) { if ((Result = DeduceTemplateArgumentByListElement(S, TemplateParams, ElTy, E, Info, Deduced, TDF))) return true; } } if (IsDependentSizedArray) { const DependentSizedArrayType *ArrTy = S.Context.getAsDependentSizedArrayType(AdjustedParamType); // Determine the array bound is something we can deduce. if (NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(ArrTy->getSizeExpr())) { // We can perform template argument deduction for the given non-type // template parameter. assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument at depth > 0"); llvm::APInt Size(S.Context.getIntWidth(NTTP->getType()), ILE->getNumInits()); Result = DeduceNonTypeTemplateArgument( S, NTTP, llvm::APSInt(Size), NTTP->getType(), /*ArrayBound=*/true, Info, Deduced); } } return true; } d3253 2 a3254 4 Sema::TemplateDeductionResult Result; if (!DeduceFromInitializerList(S, TemplateParams, ParamType.getNonReferenceType(), ILE, Info, Deduced, TDF, Result)) d3257 9 a3265 1 return Result; d3301 1 a3301 2 FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool PartialOverloading) { a3305 1 unsigned NumParams = Function->getNumParams(); d3312 1 a3312 1 if (Args.size() < Function->getMinRequiredArguments() && !PartialOverloading) d3314 1 a3314 1 else if (TooManyArguments(NumParams, Args.size(), PartialOverloading)) { d3320 1 a3320 1 CheckArgs = NumParams; d3347 1 a3347 1 for (unsigned I = 0; I != NumParams; ++I) d3355 2 a3356 2 for (unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(); ParamIdx != NumParamTypes; ++ParamIdx) { d3382 5 a3386 1 TemplateDeductionResult Result; d3388 1 a3388 2 if (!DeduceFromInitializerList(*this, TemplateParams, ParamType, ILE, Info, Deduced, TDF, Result)) d3391 7 a3397 2 if (Result) return Result; d3425 1 a3425 1 if (ParamIdx + 1 < NumParamTypes) d3453 2 a3454 3 TemplateDeductionResult Result; if (!DeduceFromInitializerList(*this, TemplateParams, ParamType, ILE, Info, Deduced, TDF, Result)) { d3459 7 a3465 2 if (Result) return Result; d3495 1 a3495 2 Info, &OriginalCallArgs, PartialOverloading); d3702 2 a3703 4 #ifndef NDEBUG Sema::TemplateDeductionResult LLVM_ATTRIBUTE_UNUSED Result = #endif S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0, d3936 1 a3936 1 TL.getTypePtr()->getKeyword(), a3995 2 if (Deduced.isNull()) return DAR_FailedAlreadyDiagnosed; a4001 5 } else if (!getLangOpts().CPlusPlus) { if (isa(Init)) { Diag(Init->getLocStart(), diag::err_auto_init_list_from_c); return DAR_FailedAlreadyDiagnosed; } d4015 2 a4016 2 FixedSizeTemplateParameterListStorage<1> TemplateParamsSt( Loc, Loc, TemplParamPtr, Loc); d4033 3 a4035 2 if (DeduceTemplateArgumentByListElement(*this, TemplateParamsSt.get(), TemplArg, InitList->getInit(i), d4040 3 a4042 7 if (!getLangOpts().CPlusPlus && Init->refersToBitField()) { Diag(Loc, diag::err_auto_bitfield); return DAR_FailedAlreadyDiagnosed; } if (AdjustFunctionParmAndArgTypesForDeduction( *this, TemplateParamsSt.get(), FuncParam, InitType, Init, TDF)) d4045 2 a4046 3 if (DeduceTemplateArgumentsByTypeMatch(*this, TemplateParamsSt.get(), FuncParam, InitType, Info, Deduced, TDF)) d4156 2 a4157 1 unsigned NumCallArguments1) { d4222 2 a4223 1 TDF_None, /*PartialOrdering=*/true)) d4235 1 a4235 1 /*PartialOrdering=*/true)) d4245 2 a4246 1 /*PartialOrdering=*/true)) d4345 1 d4347 1 a4347 1 NumCallArguments1); d4349 2 a4350 1 NumCallArguments2); d4353 1 a4353 1 return Better1 ? FT1 : FT2; d4358 64 d4594 2 a4595 1 /*PartialOrdering=*/true); d4608 2 a4609 1 /*PartialOrdering=*/true); d4652 2 a4653 1 /*PartialOrdering=*/true); d4669 2 a4670 1 /*PartialOrdering=*/true); a4926 12 // C++14 [temp.deduct.type]p5: // The non-deduced contexts are: // -- The nested-name-specifier of a type that was specified using a // qualified-id // // C++14 [temp.deduct.type]p6: // When a type name is specified in a way that includes a non-deduced // context, all of the types that comprise that type name are also // non-deduced. if (OnlyDeduced) break; d4929 3 d4933 7 a4939 2 MarkUsedTemplateParameters(Ctx, Spec->getQualifier(), OnlyDeduced, Depth, Used); a4995 1 case Type::Pipe: @ 1.1.1.9.2.1 log @Sync with HEAD @ text @a21 1 #include "clang/AST/TypeOrdering.h" d103 1 a103 2 bool PartialOrdering = false, bool DeducedFromArrayBound = false); d106 4 a109 3 DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, ArrayRef Params, ArrayRef Args, d111 1 a111 2 SmallVectorImpl &Deduced, bool NumberOfArgumentsMustMatch); d116 1 a116 2 static NonTypeTemplateParmDecl * getDeducedParameterFromExpr(TemplateDeductionInfo &Info, Expr *E) { d130 1 a130 3 if (auto *NTTP = dyn_cast(DRE->getDecl())) if (NTTP->getDepth() == Info.getDeducedDepth()) return NTTP; a159 14 // If we have two non-type template argument values deduced for the same // parameter, they must both match the type of the parameter, and thus must // match each other's type. As we're only keeping one of them, we must check // for that now. The exception is that if either was deduced from an array // bound, the type is permitted to differ. if (!X.wasDeducedFromArrayBound() && !Y.wasDeducedFromArrayBound()) { QualType XType = X.getNonTypeTemplateArgumentType(); if (!XType.isNull()) { QualType YType = Y.getNonTypeTemplateArgumentType(); if (YType.isNull() || !Context.hasSameType(XType, YType)) return DeducedTemplateArgument(); } } a169 6 // If one of the two arguments was deduced from an array bound, the other // supersedes it. if (X.wasDeducedFromArrayBound() != Y.wasDeducedFromArrayBound()) return X.wasDeducedFromArrayBound() ? Y : X; // The arguments are not compatible. d180 3 a182 1 return X.wasDeducedFromArrayBound() ? Y : X; d204 17 a220 3 case TemplateArgument::Expression: { if (Y.getKind() != TemplateArgument::Expression) return checkDeducedTemplateArguments(Context, Y, X); d222 1 a222 8 // Compare the expressions for equality llvm::FoldingSetNodeID ID1, ID2; X.getAsExpr()->Profile(ID1, Context, true); Y.getAsExpr()->Profile(ID2, Context, true); if (ID1 == ID2) return X.wasDeducedFromArrayBound() ? Y : X; // Differing dependent expressions are incompatible. a223 1 } a225 2 assert(!X.wasDeducedFromArrayBound()); d232 2 a233 6 // integral constant and whichever type did not come from an array // bound. if (Y.getKind() == TemplateArgument::Integral) { if (Y.wasDeducedFromArrayBound()) return TemplateArgument(Context, Y.getAsIntegral(), X.getParamTypeForDecl()); a234 1 } d256 3 a258 2 // If we deduced two null pointers, they are the same. if (Y.getKind() == TemplateArgument::NullPtr) a268 1 llvm::SmallVector NewPack; d273 5 a277 4 TemplateArgument Merged = checkDeducedTemplateArguments( Context, DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())); if (Merged.isNull()) a278 1 NewPack.push_back(Merged); d281 1 a281 3 return DeducedTemplateArgument( TemplateArgument::CreatePackCopy(Context, NewPack), X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); d288 16 a303 12 /// as the given deduced template argument. All non-type template parameter /// deduction is funneled through here. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, const DeducedTemplateArgument &NewDeduced, QualType ValueType, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == Info.getDeducedDepth() && "deducing non-type template argument with wrong depth"); DeducedTemplateArgument Result = checkDeducedTemplateArguments( S.Context, Deduced[NTTP->getIndex()], NewDeduced); d312 1 a312 43 if (!S.getLangOpts().CPlusPlus1z) return Sema::TDK_Success; // FIXME: It's not clear how deduction of a parameter of reference // type from an argument (of non-reference type) should be performed. // For now, we just remove reference types from both sides and let // the final check for matching types sort out the mess. return DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, NTTP->getType().getNonReferenceType(), ValueType.getNonReferenceType(), Info, Deduced, TDF_SkipNonDependent, /*PartialOrdering=*/false, /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound()); } /// \brief Deduce the value of the given non-type template parameter /// from the given integral constant. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value, QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, DeducedTemplateArgument(S.Context, Value, ValueType, DeducedFromArrayBound), ValueType, Info, Deduced); } /// \brief Deduce the value of the given non-type template parameter /// from the given null pointer template argument type. static Sema::TemplateDeductionResult DeduceNullPtrTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, QualType NullPtrType, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { Expr *Value = S.ImpCastExprToType(new (S.Context) CXXNullPtrLiteralExpr( S.Context.NullPtrTy, NTTP->getLocation()), NullPtrType, CK_NullToPointer) .get(); return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, DeducedTemplateArgument(Value), Value->getType(), Info, Deduced); d319 25 a343 7 static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, Expr *Value, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, DeducedTemplateArgument(Value), Value->getType(), Info, Deduced); d350 9 a358 5 static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, ValueDecl *D, QualType T, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { d360 14 a373 3 TemplateArgument New(D, T); return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info, Deduced); a391 4 // If we're not deducing at this depth, there's nothing to deduce. if (TempParam->getDepth() != Info.getDeducedDepth()) return Sema::TDK_Success; d460 3 a462 3 Param->template_arguments(), SpecArg->template_arguments(), Info, Deduced, /*NumberOfArgumentsMustMatch=*/false); d493 5 a497 3 return DeduceTemplateArguments(S, TemplateParams, Param->template_arguments(), SpecArg->getTemplateArgs().asArray(), Info, Deduced, /*NumberOfArgumentsMustMatch=*/true); d596 1 a596 1 if (Depth == Info.getDeducedDepth() && !SawIndices[Index]) { d627 1 a627 2 getDepthAndIndex(PartiallySubstitutedPack) == std::make_pair(Info.getDeducedDepth(), Pack.Index)) a637 13 /// Determine whether this pack has already been partially expanded into a /// sequence of (prior) function parameters / template arguments. bool isPartiallyExpanded() { if (Packs.size() != 1 || !S.CurrentInstantiationScope) return false; auto *PartiallySubstitutedPack = S.CurrentInstantiationScope->getPartiallySubstitutedPack(); return PartiallySubstitutedPack && getDepthAndIndex(PartiallySubstitutedPack) == std::make_pair(Info.getDeducedDepth(), Packs.front().Index); } d645 1 a645 3 if (!Pack.New.empty() || !DeducedArg.isNull()) { while (Pack.New.size() < PackElements) Pack.New.push_back(DeducedTemplateArgument()); a649 1 ++PackElements; d655 1 a655 1 Sema::TemplateDeductionResult finish() { d664 1 a664 1 if (PackElements && Pack.New.empty()) { a730 1 unsigned PackElements = 0; d834 1 d836 2 d850 1 a850 1 if (auto Result = PackScope.finish()) d870 1 a870 1 d872 1 a872 1 if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && d875 1 a875 1 d885 1 a885 1 d908 1 a908 1 // Noreturn and noexcept adjustment. d910 1 a910 1 if (IsFunctionConversion(Param, Arg, AdjustedParam)) d949 1 a949 2 bool PartialOrdering, bool DeducedFromArrayBound) { d1064 2 a1065 4 // Just skip any attempts to deduce from a placeholder type or a parameter // at a different depth. if (Arg->isPlaceholderType() || Info.getDeducedDepth() != TemplateTypeParm->getDepth()) d1067 1 a1067 1 d1092 1 a1092 2 assert(TemplateTypeParm->getDepth() == Info.getDeducedDepth() && "saw template type parameter with wrong depth"); d1107 1 a1107 1 d1116 1 a1116 1 return Sema::TDK_Underqualified; d1118 1 a1118 1 d1126 1 a1126 1 d1129 1 a1129 1 d1133 1 a1133 1 DeducedTemplateArgument NewDeduced(DeducedType, DeducedFromArrayBound); d1170 1 a1170 1 d1200 1 a1200 1 d1218 1 a1218 1 d1223 1 a1223 1 d1226 2 a1227 2 // _Complex T [placeholder extension] d1230 2 a1231 2 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getElementType(), d1344 1 a1344 1 = getDeducedParameterFromExpr(Info, DependentArrayParm->getSizeExpr()); d1350 2 a1351 2 assert(NTTP->getDepth() == Info.getDeducedDepth() && "saw non-type template parameter with wrong depth"); d1355 1 a1355 1 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Size, d1363 1 a1363 1 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, d1421 2 a1422 18 const TemplateSpecializationType *SpecParam = cast(Param); // When Arg cannot be a derived class, we can just try to deduce template // arguments from the template-id. const RecordType *RecordT = Arg->getAs(); if (!(TDF & TDF_DerivedClass) || !RecordT) return DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info, Deduced); SmallVector DeducedOrig(Deduced.begin(), Deduced.end()); Sema::TemplateDeductionResult Result = DeduceTemplateArguments( S, TemplateParams, SpecParam, Arg, Info, Deduced); if (Result == Sema::TDK_Success) return Result; d1424 70 a1493 59 // We cannot inspect base classes as part of deduction when the type // is incomplete, so either instantiate any templates necessary to // complete the type, or skip over it if it cannot be completed. if (!S.isCompleteType(Info.getLocation(), Arg)) return Result; // C++14 [temp.deduct.call] p4b3: // If P is a class and P has the form simple-template-id, then the // transformed A can be a derived class of the deduced A. Likewise if // P is a pointer to a class of the form simple-template-id, the // transformed A can be a pointer to a derived class pointed to by the // deduced A. // // These alternatives are considered only if type deduction would // otherwise fail. If they yield more than one possible deduced A, the // type deduction fails. // Reset the incorrectly deduced argument from above. Deduced = DeducedOrig; // Use data recursion to crawl through the list of base classes. // Visited contains the set of nodes we have already visited, while // ToVisit is our stack of records that we still need to visit. llvm::SmallPtrSet Visited; SmallVector ToVisit; ToVisit.push_back(RecordT); bool Successful = false; SmallVector SuccessfulDeduced; while (!ToVisit.empty()) { // Retrieve the next class in the inheritance hierarchy. const RecordType *NextT = ToVisit.pop_back_val(); // If we have already seen this type, skip it. if (!Visited.insert(NextT).second) continue; // If this is a base class, try to perform template argument // deduction from it. if (NextT != RecordT) { TemplateDeductionInfo BaseInfo(Info.getLocation()); Sema::TemplateDeductionResult BaseResult = DeduceTemplateArguments(S, TemplateParams, SpecParam, QualType(NextT, 0), BaseInfo, Deduced); // If template argument deduction for this base was successful, // note that we had some success. Otherwise, ignore any deductions // from this base class. if (BaseResult == Sema::TDK_Success) { // If we've already seen some success, then deduction fails due to // an ambiguity (temp.deduct.call p5). if (Successful) return Sema::TDK_MiscellaneousDeductionFailure; Successful = true; std::swap(SuccessfulDeduced, Deduced); Info.Param = BaseInfo.Param; Info.FirstArg = BaseInfo.FirstArg; Info.SecondArg = BaseInfo.SecondArg; d1496 2 a1497 9 Deduced = DeducedOrig; } // Visit base classes CXXRecordDecl *Next = cast(NextT->getDecl()); for (const auto &Base : Next->bases()) { assert(Base.getType()->isRecordType() && "Base class that isn't a record?"); ToVisit.push_back(Base.getType()->getAs()); a1498 1 } a1499 3 if (Successful) { std::swap(SuccessfulDeduced, Deduced); return Sema::TDK_Success; d1540 1 a1540 1 Info, Deduced, d1571 1 a1571 1 d1578 2 a1579 2 if (const DependentSizedExtVectorType *VectorArg d1591 1 a1591 1 d1594 1 a1594 1 d1610 1 a1610 1 d1613 1 a1613 1 = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); d1619 2 a1620 6 // Note that we use the "array bound" rules here; just like in that // case, we don't have any particular type for the vector size, but // we can provide one if necessary. return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize, S.Context.IntTy, true, Info, Deduced); d1622 2 a1623 2 if (const DependentSizedExtVectorType *VectorArg d1632 1 a1632 1 d1635 1 a1635 1 = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); d1638 2 a1639 3 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, VectorArg->getSizeExpr(), d1642 1 a1642 1 d1645 1 a1645 1 d1742 1 a1742 1 = getDeducedParameterFromExpr(Info, Param.getAsExpr())) { d1744 1 a1744 1 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, d1749 2 a1750 3 if (Arg.getKind() == TemplateArgument::NullPtr) return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP, Arg.getNullPtrType(), a1751 3 if (Arg.getKind() == TemplateArgument::Expression) return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Arg.getAsExpr(), Info, Deduced); d1753 1 a1753 3 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Arg.getAsDecl(), Arg.getParamTypeForDecl(), d1779 4 a1782 3 static bool hasTemplateArgumentForDeduction(ArrayRef &Args, unsigned &ArgIdx) { if (ArgIdx == Args.size()) d1789 3 a1791 2 assert(ArgIdx == Args.size() - 1 && "Pack not at the end of argument list?"); Args = Arg.pack_elements(); d1793 1 a1793 1 return ArgIdx < Args.size(); d1798 13 a1810 5 static bool hasPackExpansionBeforeEnd(ArrayRef Args) { bool FoundPackExpansion = false; for (const auto &A : Args) { if (FoundPackExpansion) return true; d1812 3 a1814 2 if (A.getKind() == TemplateArgument::Pack) return hasPackExpansionBeforeEnd(A.pack_elements()); d1816 2 a1817 2 if (A.isPackExpansion()) FoundPackExpansion = true; d1824 4 a1827 3 DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, ArrayRef Params, ArrayRef Args, d1829 1 a1829 2 SmallVectorImpl &Deduced, bool NumberOfArgumentsMustMatch) { d1834 1 a1834 1 if (hasPackExpansionBeforeEnd(Params)) d1842 2 a1843 1 for (; hasTemplateArgumentForDeduction(Params, ParamIdx); ++ParamIdx) { d1848 6 a1853 9 if (!hasTemplateArgumentForDeduction(Args, ArgIdx)) return NumberOfArgumentsMustMatch ? Sema::TDK_MiscellaneousDeductionFailure : Sema::TDK_Success; // C++1z [temp.deduct.type]p9: // During partial ordering, if Ai was originally a pack expansion [and] // Pi is not a pack expansion, template argument deduction fails. if (Args[ArgIdx].isPackExpansion()) d1855 1 d1888 4 a1891 1 for (; hasTemplateArgumentForDeduction(Args, ArgIdx); ++ArgIdx) { d1903 1 a1903 1 if (auto Result = PackScope.finish()) d1917 4 a1920 3 return DeduceTemplateArguments(S, TemplateParams, ParamList.asArray(), ArgList.asArray(), Info, Deduced, /*NumberOfArgumentsMustMatch*/false); d1925 2 a1926 8 TemplateArgument X, const TemplateArgument &Y, bool PackExpansionMatchesPack = false) { // If we're checking deduced arguments (X) against original arguments (Y), // we will have flattened packs to non-expansions in X. if (PackExpansionMatchesPack && X.isPackExpansion() && !Y.isPackExpansion()) X = X.getPackExpansionPattern(); d1952 1 a1952 1 return hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()); d1969 1 a1969 1 if (!isSameTemplateArg(Context, *XP, *YP, PackExpansionMatchesPack)) d1981 2 d1988 1 a1988 2 /// argument. Can be null if no type sugar is available to add to the /// type from the template argument. d1992 5 a1996 3 TemplateArgumentLoc Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc) { d2002 2 a2003 2 return TemplateArgumentLoc( Arg, Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); d2006 3 a2008 4 if (NTTPType.isNull()) NTTPType = Arg.getParamTypeForDecl(); Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .getAs(); d2013 3 a2015 4 if (NTTPType.isNull()) NTTPType = Arg.getNullPtrType(); Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .getAs(); d2021 2 a2022 2 Expr *E = BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs(); d2031 1 a2031 1 Builder.MakeTrivial(Context, DTN->getQualifier(), Loc); d2034 2 a2035 2 Builder.MakeTrivial(Context, QTN->getQualifier(), Loc); d2037 2 a2038 1 return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context), d2040 3 a2042 2 return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context), d2063 2 d2066 1 a2066 1 bool IsDeduced, a2067 18 auto ConvertArg = [&](DeducedTemplateArgument Arg, unsigned ArgumentPackIndex) { // Convert the deduced template argument into a template // argument that we can check, almost as if the user had written // the template argument explicitly. TemplateArgumentLoc ArgLoc = S.getTrivialTemplateArgumentLoc(Arg, QualType(), Info.getLocation()); // Check the template argument, converting it as necessary. return S.CheckTemplateArgument( Param, ArgLoc, Template, Template->getLocation(), Template->getSourceRange().getEnd(), ArgumentPackIndex, Output, IsDeduced ? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound : Sema::CTAK_Deduced) : Sema::CTAK_Specified); }; d2078 3 a2080 13 assert(InnerArg.getKind() != TemplateArgument::Pack && "deduced nested pack"); if (P.isNull()) { // We deduced arguments for some elements of this pack, but not for // all of them. This happens if we get a conditionally-non-deduced // context in a pack expansion (such as an overload set in one of the // arguments). S.Diag(Param->getLocation(), diag::err_template_arg_deduced_incomplete_pack) << Arg << Param; return true; } if (ConvertArg(InnerArg, PackedArgsBuilder.size())) a2086 25 // If the pack is empty, we still need to substitute into the parameter // itself, in case that substitution fails. if (PackedArgsBuilder.empty()) { LocalInstantiationScope Scope(S); TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Output); MultiLevelTemplateArgumentList Args(TemplateArgs); if (auto *NTTP = dyn_cast(Param)) { Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template, NTTP, Output, Template->getSourceRange()); if (Inst.isInvalid() || S.SubstType(NTTP->getType(), Args, NTTP->getLocation(), NTTP->getDeclName()).isNull()) return true; } else if (auto *TTP = dyn_cast(Param)) { Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template, TTP, Output, Template->getSourceRange()); if (Inst.isInvalid() || !S.SubstDecl(TTP, S.CurContext, Args)) return true; } // For type parameters, no substitution is ever required. } d2093 18 a2110 1 return ConvertArg(Arg, 0); d2113 11 a2123 11 // FIXME: This should not be a template, but // ClassTemplatePartialSpecializationDecl sadly does not derive from // TemplateDecl. template static Sema::TemplateDeductionResult ConvertDeducedTemplateArguments( Sema &S, TemplateDeclT *Template, bool IsDeduced, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info, SmallVectorImpl &Builder, LocalInstantiationScope *CurrentInstantiationScope = nullptr, unsigned NumAlreadyConverted = 0, bool PartialOverloading = false) { TemplateParameterList *TemplateParams = Template->getTemplateParameters(); d2125 1 a2125 2 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { NamedDecl *Param = TemplateParams->getParam(I); d2127 10 a2136 32 if (!Deduced[I].isNull()) { if (I < NumAlreadyConverted) { // We may have had explicitly-specified template arguments for a // template parameter pack (that may or may not have been extended // via additional deduced arguments). if (Param->isParameterPack() && CurrentInstantiationScope && CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) { // Forget the partially-substituted pack; its substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); // We still need to check the argument in case it was extended by // deduction. } else { // We have already fully type-checked and converted this // argument, because it was explicitly-specified. Just record the // presence of this argument. Builder.push_back(Deduced[I]); continue; } } // We may have deduced this argument, so it still needs to be // checked and converted. if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Template, Info, IsDeduced, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); return Sema::TDK_SubstitutionFailure; } continue; d2139 2 a2140 15 // C++0x [temp.arg.explicit]p3: // A trailing template parameter pack (14.5.3) not otherwise deduced will // be deduced to an empty sequence of template arguments. // FIXME: Where did the word "trailing" come from? if (Param->isTemplateParameterPack()) { // We may have had explicitly-specified template arguments for this // template parameter pack. If so, our empty deduction extends the // explicitly-specified set (C++0x [temp.arg.explicit]p9). const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; if (CurrentInstantiationScope && CurrentInstantiationScope->getPartiallySubstitutedPack( &ExplicitArgs, &NumExplicitArgs) == Param) { Builder.push_back(TemplateArgument( llvm::makeArrayRef(ExplicitArgs, NumExplicitArgs))); d2142 15 a2156 9 // Forget the partially-substituted pack; its substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); } else { // Go through the motions of checking the empty argument pack against // the parameter pack. DeducedTemplateArgument DeducedPack(TemplateArgument::getEmptyPack()); if (ConvertDeducedTemplateArgument(S, Param, DeducedPack, Template, Info, IsDeduced, Builder)) { d2159 3 a2161 1 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); a2164 9 continue; } // Substitute into the default template argument, if available. bool HasDefaultArg = false; TemplateDecl *TD = dyn_cast(Template); if (!TD) { assert(isa(Template)); return Sema::TDK_Incomplete; d2167 4 a2170 21 TemplateArgumentLoc DefArg = S.SubstDefaultTemplateArgumentIfAvailable( TD, TD->getLocation(), TD->getSourceRange().getEnd(), Param, Builder, HasDefaultArg); // If there was no default argument, deduction is incomplete. if (DefArg.getArgument().isNull()) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); if (PartialOverloading) break; return HasDefaultArg ? Sema::TDK_SubstitutionFailure : Sema::TDK_Incomplete; } // Check whether we can actually use the default argument. if (S.CheckTemplateArgument(Param, DefArg, TD, TD->getLocation(), TD->getSourceRange().getEnd(), 0, Builder, Sema::CTAK_Specified)) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); d2172 2 a2173 1 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); a2175 2 // If we get here, we successfully used the default template argument. a2177 44 return Sema::TDK_Success; } DeclContext *getAsDeclContextOrEnclosing(Decl *D) { if (auto *DC = dyn_cast(D)) return DC; return D->getDeclContext(); } template struct IsPartialSpecialization { static constexpr bool value = false; }; template<> struct IsPartialSpecialization { static constexpr bool value = true; }; template<> struct IsPartialSpecialization { static constexpr bool value = true; }; /// Complete template argument deduction for a partial specialization. template static typename std::enable_if::value, Sema::TemplateDeductionResult>::type FinishTemplateArgumentDeduction( Sema &S, T *Partial, bool IsPartialOrdering, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Partial)); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; if (auto Result = ConvertDeducedTemplateArguments( S, Partial, IsPartialOrdering, Deduced, Info, Builder)) return Result; d2180 2 a2181 1 = TemplateArgumentList::CreateCopy(S.Context, Builder); d2191 5 a2195 5 auto *Template = Partial->getSpecializedTemplate(); const ASTTemplateArgumentListInfo *PartialTemplArgInfo = Partial->getTemplateArgsAsWritten(); const TemplateArgumentLoc *PartialTemplateArgs = PartialTemplArgInfo->getTemplateArgs(); d2206 3 a2208 2 Decl *Param = const_cast( Partial->getTemplateParameters()->getParam(ParamIdx)); d2215 2 a2216 2 if (S.CheckTemplateArgumentList(Template, Partial->getLocation(), InstArgs, false, ConvertedInstArgs)) d2219 2 a2220 1 TemplateParameterList *TemplateParams = Template->getTemplateParameters(); a2236 42 /// Complete template argument deduction for a class or variable template, /// when partial ordering against a partial specialization. // FIXME: Factor out duplication with partial specialization version above. Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( Sema &S, TemplateDecl *Template, bool PartialOrdering, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Template)); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; if (auto Result = ConvertDeducedTemplateArguments( S, Template, /*IsDeduced*/PartialOrdering, Deduced, Info, Builder)) return Result; // Check that we produced the correct argument list. TemplateParameterList *TemplateParams = Template->getTemplateParameters(); for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { TemplateArgument InstArg = Builder[I]; if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg, /*PackExpansionMatchesPack*/true)) { Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); Info.FirstArg = TemplateArgs[I]; Info.SecondArg = InstArg; return Sema::TDK_NonDeducedMismatch; } } if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return Sema::TDK_Success; } d2275 121 a2395 2 return ::FinishTemplateArgumentDeduction( *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info); d2401 5 d2439 2 a2440 2 return ::FinishTemplateArgumentDeduction( *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info); a2451 6 static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Level, llvm::SmallBitVector &Deduced); d2491 1 a2491 1 for (auto P : Function->parameters()) d2513 1 a2513 1 SmallVector DeducedArgs; d2536 1 a2536 1 = TemplateArgumentList::CreateCopy(Context, Builder); a2566 2 ExtParameterInfoBuilder ExtParamInfos; d2572 2 a2573 2 if (SubstParmTypes(Function->getLocation(), Function->parameters(), Proto->getExtParameterInfosOrNull(), d2575 1 a2575 1 ParamTypes, /*params*/ nullptr, ExtParamInfos)) d2578 1 a2578 1 d2583 2 a2584 2 // If a declaration declares a member function or member function // template of a class X, the expression this is a prvalue of type d2586 1 a2586 1 // and the end of the function-definition, member-declarator, or d2594 1 a2594 1 d2605 1 a2605 1 d2609 2 a2610 2 SubstParmTypes(Function->getLocation(), Function->parameters(), Proto->getExtParameterInfosOrNull(), d2612 1 a2612 1 ParamTypes, /*params*/ nullptr, ExtParamInfos)) a2615 2 auto EPI = Proto->getExtProtoInfo(); EPI.ExtParameterInfos = ExtParamInfos.getPointerOrNull(ParamTypes.size()); d2619 1 a2619 1 EPI); d2648 2 a2649 2 static bool CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg, d2652 1 a2652 1 d2655 1 a2655 1 d2659 1 a2659 1 d2666 1 a2666 1 d2669 2 a2670 2 // - If the original P is a reference type, the deduced A (i.e., the // type referred to by the reference) can be more cv-qualified than d2676 1 a2676 8 // FIXME: Resolve core issue (no number yet): if the original P is a // reference type and the transformed A is function type "noexcept F", // the deduced A can be F. QualType Tmp; if (A->isFunctionType() && S.IsFunctionConversion(A, DeducedA, Tmp)) return false; d2696 1 a2696 1 } else { d2703 4 a2706 4 // - The transformed A can be another pointer or pointer to member // type that can be converted to the deduced A via a function pointer // conversion and/or a qualification conversion. d2708 3 a2710 2 // Also allow conversions which merely strip __attribute__((noreturn)) from // function types (recursively). d2716 1 a2716 1 S.IsFunctionConversion(A, DeducedA, ResultTy))) d2718 3 a2720 2 // - If P is a class and P has the form simple-template-id, then the d2722 2 a2723 2 // [...] Likewise, if P is a pointer to a class of the form // simple-template-id, the transformed A can be a pointer to a d2737 1 a2737 1 d2740 1 a2740 1 d2744 1 a2744 1 a2747 30 /// Find the pack index for a particular parameter index in an instantiation of /// a function template with specific arguments. /// /// \return The pack index for whichever pack produced this parameter, or -1 /// if this was not produced by a parameter. Intended to be used as the /// ArgumentPackSubstitutionIndex for further substitutions. // FIXME: We should track this in OriginalCallArgs so we don't need to // reconstruct it here. static unsigned getPackIndexForParam(Sema &S, FunctionTemplateDecl *FunctionTemplate, const MultiLevelTemplateArgumentList &Args, unsigned ParamIdx) { unsigned Idx = 0; for (auto *PD : FunctionTemplate->getTemplatedDecl()->parameters()) { if (PD->isParameterPack()) { unsigned NumExpansions = S.getNumArgumentsInExpansion(PD->getType(), Args).getValueOr(1); if (Idx + NumExpansions > ParamIdx) return ParamIdx - Idx; Idx += NumExpansions; } else { if (Idx == ParamIdx) return -1; // Not a pack expansion ++Idx; } } llvm_unreachable("parameter index would not be produced from template"); } d2754 11 a2764 7 Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction( FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl &Deduced, unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, SmallVectorImpl const *OriginalCallArgs, bool PartialOverloading, llvm::function_ref CheckNonDependent) { d2785 123 a2907 5 if (auto Result = ConvertDeducedTemplateArguments( *this, FunctionTemplate, /*IsDeduced*/true, Deduced, Info, Builder, CurrentInstantiationScope, NumExplicitlySpecified, PartialOverloading)) return Result; d2909 2 a2910 11 // C++ [temp.deduct.call]p10: [DR1391] // If deduction succeeds for all parameters that contain // template-parameters that participate in template argument deduction, // and all template arguments are explicitly specified, deduced, or // obtained from default template arguments, remaining parameters are then // compared with the corresponding arguments. For each remaining parameter // P with a type that was non-dependent before substitution of any // explicitly-specified template arguments, if the corresponding argument // A cannot be implicitly converted to P, deduction fails. if (CheckNonDependent()) return TDK_NonDependentConversionFailure; d2914 1 a2914 1 = TemplateArgumentList::CreateCopy(Context, Builder); a2921 1 MultiLevelTemplateArgumentList SubstArgs(*DeducedArgumentList); d2923 2 a2924 1 SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, SubstArgs)); d2948 1 a2948 1 // values that will make the deduced A identical to A (after the type A a2949 1 llvm::SmallDenseMap, QualType> DeducedATypes; d2952 2 a2953 2 auto ParamIdx = OriginalArg.ArgIdx; a2954 3 // FIXME: This presumably means a pack ended up smaller than we // expected while deducing. Should this not result in deduction // failure? Can it even happen? d2956 2 a2957 24 QualType DeducedA; if (!OriginalArg.DecomposedParam) { // P is one of the function parameters, just look up its substituted // type. DeducedA = Specialization->getParamDecl(ParamIdx)->getType(); } else { // P is a decomposed element of a parameter corresponding to a // braced-init-list argument. Substitute back into P to find the // deduced A. QualType &CacheEntry = DeducedATypes[{ParamIdx, OriginalArg.OriginalParamType}]; if (CacheEntry.isNull()) { ArgumentPackSubstitutionIndexRAII PackIndex( *this, getPackIndexForParam(*this, FunctionTemplate, SubstArgs, ParamIdx)); CacheEntry = SubstType(OriginalArg.OriginalParamType, SubstArgs, Specialization->getTypeSpecStartLoc(), Specialization->getDeclName()); } DeducedA = CacheEntry; } d2962 1 a2962 2 return OriginalArg.DecomposedParam ? TDK_DeducedMismatchNested : TDK_DeducedMismatch; d2966 1 a2966 1 a3038 5 DeclAccessPair DAP; if (FunctionDecl *Viable = S.resolveAddressOfOnlyViableOverloadCandidate(Arg, DAP)) return GetTypeOfFunction(S, R, Viable); d3041 1 a3041 1 d3057 2 a3058 2 // Otherwise, see if we can resolve a function type d3064 1 a3064 1 d3209 1 a3209 1 static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument( d3212 1 a3212 3 SmallVectorImpl &Deduced, SmallVectorImpl &OriginalCallArgs, bool DecomposedParam, unsigned ArgIdx, unsigned TDF); d3216 29 a3244 16 static Sema::TemplateDeductionResult DeduceFromInitializerList( Sema &S, TemplateParameterList *TemplateParams, QualType AdjustedParamType, InitListExpr *ILE, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, SmallVectorImpl &OriginalCallArgs, unsigned ArgIdx, unsigned TDF) { // C++ [temp.deduct.call]p1: (CWG 1591) // If removing references and cv-qualifiers from P gives // std::initializer_list or P0[N] for some P0 and N and the argument is // a non-empty initializer list, then deduction is performed instead for // each element of the initializer list, taking P0 as a function template // parameter type and the initializer element as its argument // // We've already removed references and cv-qualifiers here. if (!ILE->getNumInits()) return Sema::TDK_Success; d3246 6 a3251 8 QualType ElTy; auto *ArrTy = S.Context.getAsArrayType(AdjustedParamType); if (ArrTy) ElTy = ArrTy->getElementType(); else if (!S.isStdInitializerList(AdjustedParamType, &ElTy)) { // Otherwise, an initializer list argument causes the parameter to be // considered a non-deduced context return Sema::TDK_Success; a3252 1 d3256 3 a3258 4 if (auto Result = DeduceTemplateArgumentsFromCallArgument( S, TemplateParams, ElTy, E, Info, Deduced, OriginalCallArgs, true, ArgIdx, TDF)) return Result; d3261 3 a3263 4 // in the P0[N] case, if N is a non-type template parameter, N is deduced // from the length of the initializer list. if (auto *DependentArrTy = dyn_cast_or_null(ArrTy)) { d3266 1 a3266 1 getDeducedParameterFromExpr(Info, DependentArrTy->getSizeExpr())) { d3269 2 d3273 4 a3276 4 if (auto Result = DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, llvm::APSInt(Size), NTTP->getType(), /*ArrayBound=*/true, Info, Deduced)) return Result; d3279 1 a3279 2 return Sema::TDK_Success; d3282 19 a3300 10 /// \brief Perform template argument deduction per [temp.deduct.call] for a /// single parameter / argument pair. static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument( Sema &S, TemplateParameterList *TemplateParams, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, SmallVectorImpl &OriginalCallArgs, bool DecomposedParam, unsigned ArgIdx, unsigned TDF) { QualType ArgType = Arg->getType(); QualType OrigParamType = ParamType; d3302 2 a3303 5 // If P is a reference type [...] // If P is a cv-qualified type [...] if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, ArgType, Arg, TDF)) return Sema::TDK_Success; d3305 7 a3311 12 // If [...] the argument is a non-empty initializer list [...] if (InitListExpr *ILE = dyn_cast(Arg)) return DeduceFromInitializerList(S, TemplateParams, ParamType, ILE, Info, Deduced, OriginalCallArgs, ArgIdx, TDF); // [...] the deduction process attempts to find template argument values // that will make the deduced A identical to A // // Keep track of the argument type and corresponding parameter index, // so we can check for compatibility between the deduced A and A. OriginalCallArgs.push_back( Sema::OriginalCallArg(OrigParamType, DecomposedParam, ArgIdx, ArgType)); a3333 6 /// \param CheckNonDependent A callback to invoke to check conversions for /// non-dependent parameters, between deduction and substitution, per DR1391. /// If this returns true, substitution will be skipped and we return /// TDK_NonDependentConversionFailure. The callback is passed the parameter /// types (after substituting explicit template arguments). /// d3339 1 a3339 2 bool PartialOverloading, llvm::function_ref)> CheckNonDependent) { d3350 1 d3358 3 a3360 1 else if (!Proto->isVariadic()) d3370 1 a3370 1 SmallVector ParamTypes; a3389 17 SmallVector OriginalCallArgs; // Deduce an argument of type ParamType from an expression with index ArgIdx. auto DeduceCallArgument = [&](QualType ParamType, unsigned ArgIdx) { // C++ [demp.deduct.call]p1: (DR1391) // Template argument deduction is done by comparing each function template // parameter that contains template-parameters that participate in // template argument deduction ... if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) return Sema::TDK_Success; // ... with the type of the corresponding argument return DeduceTemplateArgumentsFromCallArgument( *this, TemplateParams, ParamType, Args[ArgIdx], Info, Deduced, OriginalCallArgs, /*Decomposed*/false, ArgIdx, /*TDF*/ 0); }; d3392 3 a3394 2 SmallVector ParamTypesForArgChecking; for (unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0; d3396 5 a3400 4 QualType ParamType = ParamTypes[ParamIdx]; const PackExpansionType *ParamExpansion = dyn_cast(ParamType); d3403 1 a3403 1 if (ArgIdx >= Args.size()) d3406 36 a3441 2 ParamTypesForArgChecking.push_back(ParamType); if (auto Result = DeduceCallArgument(ParamType, ArgIdx++)) a3446 4 QualType ParamPattern = ParamExpansion->getPattern(); PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info, ParamPattern); d3453 27 a3479 15 // the function parameter pack. When a function parameter pack appears // in a non-deduced context [not at the end of the list], the type of // that parameter pack is never deduced. // // FIXME: The above rule allows the size of the parameter pack to change // after we skip it (in the non-deduced case). That makes no sense, so // we instead notionally deduce the pack against N arguments, where N is // the length of the explicitly-specified pack if it's expanded by the // parameter pack and 0 otherwise, and we treat each deduction as a // non-deduced context. if (ParamIdx + 1 == NumParamTypes) { for (; ArgIdx < Args.size(); PackScope.nextPackElement(), ++ArgIdx) { ParamTypesForArgChecking.push_back(ParamPattern); if (auto Result = DeduceCallArgument(ParamPattern, ArgIdx)) return Result; d3481 8 a3488 12 } else { // If the parameter type contains an explicitly-specified pack that we // could not expand, skip the number of parameters notionally created // by the expansion. Optional NumExpansions = ParamExpansion->getNumExpansions(); if (NumExpansions && !PackScope.isPartiallyExpanded()) { for (unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size(); ++I, ++ArgIdx) { ParamTypesForArgChecking.push_back(ParamPattern); // FIXME: Should we add OriginalCallArgs for these? What if the // corresponding argument is a list? PackScope.nextPackElement(); d3490 16 d3507 2 d3513 1 a3513 1 if (auto Result = PackScope.finish()) d3515 3 d3520 4 a3523 4 return FinishTemplateArgumentDeduction( FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info, &OriginalCallArgs, PartialOverloading, [&]() { return CheckNonDependent(ParamTypesForArgChecking); }); d3527 1 a3527 2 QualType FunctionType, bool AdjustExceptionSpec) { d3533 2 d3537 2 a3538 23 FunctionProtoType::ExtProtoInfo EPI = ArgFunctionTypeP->getExtProtoInfo(); bool Rebuild = false; CallingConv CC = FunctionTypeP->getCallConv(); if (EPI.ExtInfo.getCC() != CC) { EPI.ExtInfo = EPI.ExtInfo.withCallingConv(CC); Rebuild = true; } bool NoReturn = FunctionTypeP->getNoReturnAttr(); if (EPI.ExtInfo.getNoReturn() != NoReturn) { EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn); Rebuild = true; } if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() || ArgFunctionTypeP->hasExceptionSpec())) { EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec; Rebuild = true; } if (!Rebuild) d3541 5 a3545 2 return Context.getFunctionType(ArgFunctionTypeP->getReturnType(), ArgFunctionTypeP->getParamTypes(), EPI); a3569 5 /// \param IsAddressOfFunction If \c true, we are deducing as part of taking /// the address of a function template per [temp.deduct.funcaddr] and /// [over.over]. If \c false, we are looking up a function template /// specialization based on its signature, per [temp.deduct.decl]. /// d3571 7 a3577 5 Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ArgFunctionType, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool IsAddressOfFunction) { d3585 2 a3586 7 // When taking the address of a function, we require convertibility of // the resulting function type. Otherwise, we allow arbitrary mismatches // of calling convention, noreturn, and noexcept. if (!IsAddressOfFunction) ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType, /*AdjustExceptionSpec*/true); d3611 1 a3611 3 // type so that we treat it as a non-deduced context in what follows. If we // are looking up by signature, the signature type should also have a deduced // return type, which we instead expect to exactly match. d3613 1 a3613 1 if (getLangOpts().CPlusPlus14 && IsAddressOfFunction && d3621 1 a3621 2 if (IsAddressOfFunction) TDF |= TDF_InOverloadResolution; a3642 18 // If the function has a dependent exception specification, resolve it now, // so we can check that the exception specification matches. auto *SpecializationFPT = Specialization->getType()->castAs(); if (getLangOpts().CPlusPlus1z && isUnresolvedExceptionSpec(SpecializationFPT->getExceptionSpecType()) && !ResolveExceptionSpec(Info.getLocation(), SpecializationFPT)) return TDK_MiscellaneousDeductionFailure; // Adjust the exception specification of the argument again to match the // substituted and resolved type we just formed. (Calling convention and // noreturn can't be dependent, so we don't actually need this for them // right now.) QualType SpecializationType = Specialization->getType(); if (!IsAddressOfFunction) ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, SpecializationType, /*AdjustExceptionSpec*/true); d3647 3 a3649 4 if (IsAddressOfFunction && !isSameOrCompatibleFunctionType( Context.getCanonicalType(SpecializationType), Context.getCanonicalType(ArgFunctionType))) d3651 2 a3652 3 if (!IsAddressOfFunction && !Context.hasSameType(SpecializationType, ArgFunctionType)) d3659 2 a3660 2 /// \brief Given a function declaration (e.g. a generic lambda conversion /// function) that contains an 'auto' in its result type, substitute it d3664 2 a3665 2 static inline void SubstAutoWithinFunctionReturnType(FunctionDecl *F, d3669 2 a3670 2 assert(AutoResultType->getContainedAutoType()); QualType DeducedResultType = S.SubstAutoType(AutoResultType, d3675 4 a3678 4 /// \brief Given a specialized conversion operator of a generic lambda /// create the corresponding specializations of the call operator and /// the static-invoker. If the return type of the call operator is auto, /// deduce its return type and check if that matches the d3681 1 a3681 1 static inline Sema::TemplateDeductionResult d3688 1 a3688 1 d3690 2 a3691 2 assert(LambdaClass && LambdaClass->isGenericLambda()); d3694 1 a3694 1 const bool GenericLambdaCallOperatorHasDeducedReturnType = d3696 2 a3697 2 FunctionTemplateDecl *CallOpTemplate = d3701 1 a3701 1 // Use the deduced arguments of the conversion function, to specialize our d3704 2 a3705 2 = S.FinishTemplateArgumentDeduction(CallOpTemplate, DeducedArguments, d3708 1 a3708 1 d3712 1 a3712 1 S.DeduceReturnType(CallOpSpecialized, d3715 1 a3715 1 d3722 1 a3722 1 // ptr-to-functions (now including return type), and have successfully d3733 1 a3733 1 S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0, d3735 1 a3735 1 assert(Result == Sema::TDK_Success && d3742 1 a3742 1 // the full result type of the call op specialization d3754 1 a3754 1 SubstAutoWithinFunctionReturnType(ConversionSpecialized, d3757 1 a3757 1 d3759 1 a3759 1 // FIXME: When creating the InvokerTemplate in SemaLambda.cpp d3761 1 a3761 1 // the const qualifier to leak through. d3873 1 a3873 1 = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0, d3882 1 a3882 1 d3884 1 a3884 1 // to. This is necessary for matching the lambda call operator's return d3886 1 a3886 1 assert(A->isPointerType() && d3888 1 a3888 1 const FunctionType *ToFunType = d3892 3 a3894 3 // Create the corresponding specializations of the call operator and // the static-invoker; and if the return type is auto, // deduce the return type and check if it matches the d3902 1 a3902 1 Specialization, Deduced, DestFunctionPtrReturnType, a3923 7 /// \param IsAddressOfFunction If \c true, we are deducing as part of taking /// the address of a function template in a context where we do not have a /// target type, per [over.over]. If \c false, we are looking up a function /// template specialization based on its signature, which only happens when /// deducing a function parameter type from an argument that is a template-id /// naming a function template specialization. /// d3925 6 a3930 5 Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool IsAddressOfFunction) { d3933 1 a3933 1 IsAddressOfFunction); a3941 1 bool UseAutoSugar; d3943 1 a3943 2 SubstituteAutoTransform(Sema &SemaRef, QualType Replacement, bool UseAutoSugar = true) d3945 1 a3945 1 Replacement(Replacement), UseAutoSugar(UseAutoSugar) {} d3955 1 a3955 3 if (!UseAutoSugar) { assert(isa(Replacement) && "unexpected unsugared replacement kind"); d3962 6 a3967 2 QualType Result = SemaRef.Context.getAutoType( Replacement, TL.getTypePtr()->getKeyword(), Replacement.isNull()); d3990 2 a3991 4 Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result, Optional DependentDeductionDepth) { return DeduceAutoType(Type->getTypeLoc(), Init, Result, DependentDeductionDepth); a3995 4 /// Note that this is done even if the initializer is dependent. (This is /// necessary to support partial ordering of templates using 'auto'.) /// A dependent type will be produced when deducing from a dependent type. /// a3999 4 /// \param DependentDeductionDepth Set if we should permit deduction in /// dependent cases. This is necessary for template partial ordering with /// 'auto' template parameters. The value specified is the template /// parameter depth at which we should perform 'auto' deduction. d4001 1 a4001 2 Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result, Optional DependentDeductionDepth) { d4009 2 a4010 3 if (!DependentDeductionDepth && (Type.getType()->isDependentType() || Init->isTypeDependent())) { Result = SubstituteAutoTransform(*this, QualType()).Apply(Type); a4014 3 // Find the depth of template parameter to synthesize. unsigned Depth = DependentDeductionDepth.getValueOr(0); d4047 3 a4049 2 TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create( Context, nullptr, SourceLocation(), Loc, Depth, 0, nullptr, false, false); d4052 2 a4053 2 FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt( Loc, Loc, TemplParamPtr, Loc, nullptr); d4055 1 a4055 3 QualType FuncParam = SubstituteAutoTransform(*this, TemplArg, /*UseAutoSugar*/false) .Apply(Type); d4062 2 d4065 1 a4065 14 TemplateDeductionInfo Info(Loc, Depth); // If deduction failed, don't diagnose if the initializer is dependent; it // might acquire a matching type in the instantiation. auto DeductionFailed = [&]() -> DeduceAutoResult { if (Init->isTypeDependent()) { Result = SubstituteAutoTransform(*this, QualType()).Apply(Type); assert(!Result.isNull() && "substituting DependentTy can't fail"); return DAR_Succeeded; } return DAR_Failed; }; SmallVector OriginalCallArgs; a4068 6 // Notionally, we substitute std::initializer_list for 'auto' and deduce // against that. Such deduction only succeeds if removing cv-qualifiers and // references results in std::initializer_list. if (!Type.getType().getNonReferenceType()->getAs()) return DAR_Failed; d4070 4 a4073 5 if (DeduceTemplateArgumentsFromCallArgument( *this, TemplateParamsSt.get(), TemplArg, InitList->getInit(i), Info, Deduced, OriginalCallArgs, /*Decomposed*/ true, /*ArgIdx*/ 0, /*TDF*/ 0)) return DeductionFailed(); d4081 8 a4088 4 if (DeduceTemplateArgumentsFromCallArgument( *this, TemplateParamsSt.get(), FuncParam, Init, Info, Deduced, OriginalCallArgs, /*Decomposed*/ false, /*ArgIdx*/ 0, /*TDF*/ 0)) return DeductionFailed(); a4090 1 // Could be null if somehow 'auto' appears in a non-deduced context. d4092 1 a4092 1 return DeductionFailed(); d4104 1 a4104 1 return DAR_FailedAlreadyDiagnosed; d4108 6 a4113 8 QualType DeducedA = InitList ? Deduced[0].getAsType() : Result; for (const OriginalCallArg &OriginalArg : OriginalCallArgs) { assert((bool)InitList == OriginalArg.DecomposedParam && "decomposed non-init-list in auto deduction?"); if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) { Result = QualType(); return DeductionFailed(); } d4119 1 a4119 1 QualType Sema::SubstAutoType(QualType TypeWithAuto, d4121 2 a4122 4 if (TypeToReplaceAuto->isDependentType()) TypeToReplaceAuto = QualType(); return SubstituteAutoTransform(*this, TypeToReplaceAuto) .TransformType(TypeWithAuto); d4125 1 a4125 1 TypeSourceInfo* Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, d4127 2 a4128 4 if (TypeToReplaceAuto->isDependentType()) TypeToReplaceAuto = QualType(); return SubstituteAutoTransform(*this, TypeToReplaceAuto) .TransformType(TypeWithAuto); d4162 6 a4299 4 // FIXME: We fail to implement [temp.deduct.type]p1 along this path. We need // to substitute the deduced arguments back into the template and check that // we get the right type. d4503 3 a4505 4 const auto *FD = cast(*I); PD << FD << getTemplateArgumentBindingsText( FD->getPrimaryTemplate()->getTemplateParameters(), *FD->getTemplateSpecializationArgs()); d4507 2 a4508 1 HandleFunctionTypeMismatch(PD, FD->getType(), TargetType); d4516 5 a4520 2 /// Determine whether one partial specialization, P1, is at least as /// specialized than another, P2. d4522 9 a4530 8 /// \tparam TemplateLikeDecl The kind of P2, which must be a /// TemplateDecl or {Class,Var}TemplatePartialSpecializationDecl. /// \param T1 The injected-class-name of P1 (faked for a variable template). /// \param T2 The injected-class-name of P2 (faked for a variable template). template static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P2, TemplateDeductionInfo &Info) { d4556 1 a4557 37 // Determine whether P1 is at least as specialized as P2. Deduced.resize(P2->getTemplateParameters()->size()); if (DeduceTemplateArgumentsByTypeMatch(S, P2->getTemplateParameters(), T2, T1, Info, Deduced, TDF_None, /*PartialOrdering=*/true)) return false; SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); Sema::InstantiatingTemplate Inst(S, Info.getLocation(), P2, DeducedArgs, Info); auto *TST1 = T1->castAs(); if (FinishTemplateArgumentDeduction( S, P2, /*PartialOrdering=*/true, TemplateArgumentList(TemplateArgumentList::OnStack, TST1->template_arguments()), Deduced, Info)) return false; return true; } /// \brief Returns the more specialized class template partial specialization /// according to the rules of partial ordering of class template partial /// specializations (C++ [temp.class.order]). /// /// \param PS1 the first class template partial specialization /// /// \param PS2 the second class template partial specialization /// /// \returns the more specialized class template partial specialization. If /// neither partial specialization is more specialized, returns NULL. ClassTemplatePartialSpecializationDecl * Sema::getMoreSpecializedPartialSpecialization( ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { d4561 26 a4586 3 TemplateDeductionInfo Info(Loc); bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info); bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info); d4594 5 a4598 14 bool Sema::isMoreSpecializedThanPrimary( ClassTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) { ClassTemplateDecl *Primary = Spec->getSpecializedTemplate(); QualType PrimaryT = Primary->getInjectedClassNameSpecialization(); QualType PartialT = Spec->getInjectedSpecializationType(); if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info)) return false; if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) { Info.clearSFINAEDiagnostic(); return false; } return true; } d4603 3 a4605 2 // Pretend the variable template specializations are class template // specializations and form a fake injected class name type for comparison. d4612 2 a4613 1 CanonTemplate, PS1->getTemplateArgs().asArray()); d4615 2 a4616 5 CanonTemplate, PS2->getTemplateArgs().asArray()); TemplateDeductionInfo Info(Loc); bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info); bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info); d4618 12 a4629 26 if (Better1 == Better2) return nullptr; return Better1 ? PS1 : PS2; } bool Sema::isMoreSpecializedThanPrimary( VarTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) { TemplateDecl *Primary = Spec->getSpecializedTemplate(); // FIXME: Cache the injected template arguments rather than recomputing // them for each partial specialization. SmallVector PrimaryArgs; Context.getInjectedTemplateArgs(Primary->getTemplateParameters(), PrimaryArgs); TemplateName CanonTemplate = Context.getCanonicalTemplateName(TemplateName(Primary)); QualType PrimaryT = Context.getTemplateSpecializationType( CanonTemplate, PrimaryArgs); QualType PartialT = Context.getTemplateSpecializationType( CanonTemplate, Spec->getTemplateArgs().asArray()); if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info)) return false; if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) { Info.clearSFINAEDiagnostic(); return false; a4630 2 return true; } d4632 13 a4644 51 bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs( TemplateParameterList *P, TemplateDecl *AArg, SourceLocation Loc) { // C++1z [temp.arg.template]p4: (DR 150) // A template template-parameter P is at least as specialized as a // template template-argument A if, given the following rewrite to two // function templates... // Rather than synthesize function templates, we merely perform the // equivalent partial ordering by performing deduction directly on // the template parameter lists of the template template parameters. // // Given an invented class template X with the template parameter list of // A (including default arguments): TemplateName X = Context.getCanonicalTemplateName(TemplateName(AArg)); TemplateParameterList *A = AArg->getTemplateParameters(); // - Each function template has a single function parameter whose type is // a specialization of X with template arguments corresponding to the // template parameters from the respective function template SmallVector AArgs; Context.getInjectedTemplateArgs(A, AArgs); // Check P's arguments against A's parameter list. This will fill in default // template arguments as needed. AArgs are already correct by construction. // We can't just use CheckTemplateIdType because that will expand alias // templates. SmallVector PArgs; { SFINAETrap Trap(*this); Context.getInjectedTemplateArgs(P, PArgs); TemplateArgumentListInfo PArgList(P->getLAngleLoc(), P->getRAngleLoc()); for (unsigned I = 0, N = P->size(); I != N; ++I) { // Unwrap packs that getInjectedTemplateArgs wrapped around pack // expansions, to form an "as written" argument list. TemplateArgument Arg = PArgs[I]; if (Arg.getKind() == TemplateArgument::Pack) { assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion()); Arg = *Arg.pack_begin(); } PArgList.addArgument(getTrivialTemplateArgumentLoc( Arg, QualType(), P->getParam(I)->getLocation())); } PArgs.clear(); // C++1z [temp.arg.template]p3: // If the rewrite produces an invalid type, then P is not at least as // specialized as A. if (CheckTemplateArgumentList(AArg, Loc, PArgList, false, PArgs) || Trap.hasErrorOccurred()) return false; d4647 2 a4648 2 QualType AType = Context.getTemplateSpecializationType(X, AArgs); QualType PType = Context.getTemplateSpecializationType(X, PArgs); d4650 1 a4650 5 // ... the function template corresponding to P is at least as specialized // as the function template corresponding to A according to the partial // ordering rules for function templates. TemplateDeductionInfo Info(Loc, A->getDepth()); return isAtLeastAsSpecializedAs(*this, PType, AType, AArg, Info); a4696 5 // In C++1z mode, additional arguments may be deduced from the type of a // non-type argument. if (Ctx.getLangOpts().CPlusPlus1z) MarkUsedTemplateParameters(Ctx, NTTP->getType(), OnlyDeduced, Depth, Used); d4864 1 a4864 1 hasPackExpansionBeforeEnd(Spec->template_arguments())) d4943 1 a4943 1 cast(T)->getUnderlyingType(), d5039 1 a5039 1 hasPackExpansionBeforeEnd(TemplateArgs.asArray())) d5072 1 a5072 1 ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @a21 1 #include "clang/AST/TypeOrdering.h" d103 1 a103 2 bool PartialOrdering = false, bool DeducedFromArrayBound = false); d106 4 a109 3 DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, ArrayRef Params, ArrayRef Args, d111 1 a111 2 SmallVectorImpl &Deduced, bool NumberOfArgumentsMustMatch); d116 1 a116 2 static NonTypeTemplateParmDecl * getDeducedParameterFromExpr(TemplateDeductionInfo &Info, Expr *E) { d130 1 a130 3 if (auto *NTTP = dyn_cast(DRE->getDecl())) if (NTTP->getDepth() == Info.getDeducedDepth()) return NTTP; a159 14 // If we have two non-type template argument values deduced for the same // parameter, they must both match the type of the parameter, and thus must // match each other's type. As we're only keeping one of them, we must check // for that now. The exception is that if either was deduced from an array // bound, the type is permitted to differ. if (!X.wasDeducedFromArrayBound() && !Y.wasDeducedFromArrayBound()) { QualType XType = X.getNonTypeTemplateArgumentType(); if (!XType.isNull()) { QualType YType = Y.getNonTypeTemplateArgumentType(); if (YType.isNull() || !Context.hasSameType(XType, YType)) return DeducedTemplateArgument(); } } a169 6 // If one of the two arguments was deduced from an array bound, the other // supersedes it. if (X.wasDeducedFromArrayBound() != Y.wasDeducedFromArrayBound()) return X.wasDeducedFromArrayBound() ? Y : X; // The arguments are not compatible. d180 3 a182 1 return X.wasDeducedFromArrayBound() ? Y : X; d204 17 a220 3 case TemplateArgument::Expression: { if (Y.getKind() != TemplateArgument::Expression) return checkDeducedTemplateArguments(Context, Y, X); d222 1 a222 8 // Compare the expressions for equality llvm::FoldingSetNodeID ID1, ID2; X.getAsExpr()->Profile(ID1, Context, true); Y.getAsExpr()->Profile(ID2, Context, true); if (ID1 == ID2) return X.wasDeducedFromArrayBound() ? Y : X; // Differing dependent expressions are incompatible. a223 1 } a225 2 assert(!X.wasDeducedFromArrayBound()); d232 2 a233 6 // integral constant and whichever type did not come from an array // bound. if (Y.getKind() == TemplateArgument::Integral) { if (Y.wasDeducedFromArrayBound()) return TemplateArgument(Context, Y.getAsIntegral(), X.getParamTypeForDecl()); a234 1 } d256 3 a258 2 // If we deduced two null pointers, they are the same. if (Y.getKind() == TemplateArgument::NullPtr) a268 1 llvm::SmallVector NewPack; d273 5 a277 4 TemplateArgument Merged = checkDeducedTemplateArguments( Context, DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())); if (Merged.isNull()) a278 1 NewPack.push_back(Merged); d281 1 a281 3 return DeducedTemplateArgument( TemplateArgument::CreatePackCopy(Context, NewPack), X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); d288 16 a303 12 /// as the given deduced template argument. All non-type template parameter /// deduction is funneled through here. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, const DeducedTemplateArgument &NewDeduced, QualType ValueType, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == Info.getDeducedDepth() && "deducing non-type template argument with wrong depth"); DeducedTemplateArgument Result = checkDeducedTemplateArguments( S.Context, Deduced[NTTP->getIndex()], NewDeduced); d312 1 a312 43 if (!S.getLangOpts().CPlusPlus1z) return Sema::TDK_Success; // FIXME: It's not clear how deduction of a parameter of reference // type from an argument (of non-reference type) should be performed. // For now, we just remove reference types from both sides and let // the final check for matching types sort out the mess. return DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, NTTP->getType().getNonReferenceType(), ValueType.getNonReferenceType(), Info, Deduced, TDF_SkipNonDependent, /*PartialOrdering=*/false, /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound()); } /// \brief Deduce the value of the given non-type template parameter /// from the given integral constant. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value, QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, DeducedTemplateArgument(S.Context, Value, ValueType, DeducedFromArrayBound), ValueType, Info, Deduced); } /// \brief Deduce the value of the given non-type template parameter /// from the given null pointer template argument type. static Sema::TemplateDeductionResult DeduceNullPtrTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, QualType NullPtrType, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { Expr *Value = S.ImpCastExprToType(new (S.Context) CXXNullPtrLiteralExpr( S.Context.NullPtrTy, NTTP->getLocation()), NullPtrType, CK_NullToPointer) .get(); return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, DeducedTemplateArgument(Value), Value->getType(), Info, Deduced); d319 25 a343 7 static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, Expr *Value, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, DeducedTemplateArgument(Value), Value->getType(), Info, Deduced); d350 9 a358 5 static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, ValueDecl *D, QualType T, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { d360 14 a373 3 TemplateArgument New(D, T); return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info, Deduced); a391 4 // If we're not deducing at this depth, there's nothing to deduce. if (TempParam->getDepth() != Info.getDeducedDepth()) return Sema::TDK_Success; d460 3 a462 3 Param->template_arguments(), SpecArg->template_arguments(), Info, Deduced, /*NumberOfArgumentsMustMatch=*/false); d493 5 a497 3 return DeduceTemplateArguments(S, TemplateParams, Param->template_arguments(), SpecArg->getTemplateArgs().asArray(), Info, Deduced, /*NumberOfArgumentsMustMatch=*/true); d596 1 a596 1 if (Depth == Info.getDeducedDepth() && !SawIndices[Index]) { d627 1 a627 2 getDepthAndIndex(PartiallySubstitutedPack) == std::make_pair(Info.getDeducedDepth(), Pack.Index)) a637 13 /// Determine whether this pack has already been partially expanded into a /// sequence of (prior) function parameters / template arguments. bool isPartiallyExpanded() { if (Packs.size() != 1 || !S.CurrentInstantiationScope) return false; auto *PartiallySubstitutedPack = S.CurrentInstantiationScope->getPartiallySubstitutedPack(); return PartiallySubstitutedPack && getDepthAndIndex(PartiallySubstitutedPack) == std::make_pair(Info.getDeducedDepth(), Packs.front().Index); } d645 1 a645 3 if (!Pack.New.empty() || !DeducedArg.isNull()) { while (Pack.New.size() < PackElements) Pack.New.push_back(DeducedTemplateArgument()); a649 1 ++PackElements; d655 1 a655 1 Sema::TemplateDeductionResult finish() { d664 1 a664 1 if (PackElements && Pack.New.empty()) { a730 1 unsigned PackElements = 0; d834 1 d836 2 d850 1 a850 1 if (auto Result = PackScope.finish()) d870 1 a870 1 d872 1 a872 1 if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && d875 1 a875 1 d885 1 a885 1 d908 1 a908 1 // Noreturn and noexcept adjustment. d910 1 a910 1 if (IsFunctionConversion(Param, Arg, AdjustedParam)) d949 1 a949 2 bool PartialOrdering, bool DeducedFromArrayBound) { d1064 2 a1065 4 // Just skip any attempts to deduce from a placeholder type or a parameter // at a different depth. if (Arg->isPlaceholderType() || Info.getDeducedDepth() != TemplateTypeParm->getDepth()) d1067 1 a1067 1 d1092 1 a1092 2 assert(TemplateTypeParm->getDepth() == Info.getDeducedDepth() && "saw template type parameter with wrong depth"); d1107 1 a1107 1 d1116 1 a1116 1 return Sema::TDK_Underqualified; d1118 1 a1118 1 d1126 1 a1126 1 d1129 1 a1129 1 d1133 1 a1133 1 DeducedTemplateArgument NewDeduced(DeducedType, DeducedFromArrayBound); d1170 1 a1170 1 d1200 1 a1200 1 d1218 1 a1218 1 d1223 1 a1223 1 d1226 2 a1227 2 // _Complex T [placeholder extension] d1230 2 a1231 2 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getElementType(), d1344 1 a1344 1 = getDeducedParameterFromExpr(Info, DependentArrayParm->getSizeExpr()); d1350 2 a1351 2 assert(NTTP->getDepth() == Info.getDeducedDepth() && "saw non-type template parameter with wrong depth"); d1355 1 a1355 1 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Size, d1363 1 a1363 1 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, d1421 2 a1422 18 const TemplateSpecializationType *SpecParam = cast(Param); // When Arg cannot be a derived class, we can just try to deduce template // arguments from the template-id. const RecordType *RecordT = Arg->getAs(); if (!(TDF & TDF_DerivedClass) || !RecordT) return DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info, Deduced); SmallVector DeducedOrig(Deduced.begin(), Deduced.end()); Sema::TemplateDeductionResult Result = DeduceTemplateArguments( S, TemplateParams, SpecParam, Arg, Info, Deduced); if (Result == Sema::TDK_Success) return Result; d1424 70 a1493 59 // We cannot inspect base classes as part of deduction when the type // is incomplete, so either instantiate any templates necessary to // complete the type, or skip over it if it cannot be completed. if (!S.isCompleteType(Info.getLocation(), Arg)) return Result; // C++14 [temp.deduct.call] p4b3: // If P is a class and P has the form simple-template-id, then the // transformed A can be a derived class of the deduced A. Likewise if // P is a pointer to a class of the form simple-template-id, the // transformed A can be a pointer to a derived class pointed to by the // deduced A. // // These alternatives are considered only if type deduction would // otherwise fail. If they yield more than one possible deduced A, the // type deduction fails. // Reset the incorrectly deduced argument from above. Deduced = DeducedOrig; // Use data recursion to crawl through the list of base classes. // Visited contains the set of nodes we have already visited, while // ToVisit is our stack of records that we still need to visit. llvm::SmallPtrSet Visited; SmallVector ToVisit; ToVisit.push_back(RecordT); bool Successful = false; SmallVector SuccessfulDeduced; while (!ToVisit.empty()) { // Retrieve the next class in the inheritance hierarchy. const RecordType *NextT = ToVisit.pop_back_val(); // If we have already seen this type, skip it. if (!Visited.insert(NextT).second) continue; // If this is a base class, try to perform template argument // deduction from it. if (NextT != RecordT) { TemplateDeductionInfo BaseInfo(Info.getLocation()); Sema::TemplateDeductionResult BaseResult = DeduceTemplateArguments(S, TemplateParams, SpecParam, QualType(NextT, 0), BaseInfo, Deduced); // If template argument deduction for this base was successful, // note that we had some success. Otherwise, ignore any deductions // from this base class. if (BaseResult == Sema::TDK_Success) { // If we've already seen some success, then deduction fails due to // an ambiguity (temp.deduct.call p5). if (Successful) return Sema::TDK_MiscellaneousDeductionFailure; Successful = true; std::swap(SuccessfulDeduced, Deduced); Info.Param = BaseInfo.Param; Info.FirstArg = BaseInfo.FirstArg; Info.SecondArg = BaseInfo.SecondArg; d1496 2 a1497 9 Deduced = DeducedOrig; } // Visit base classes CXXRecordDecl *Next = cast(NextT->getDecl()); for (const auto &Base : Next->bases()) { assert(Base.getType()->isRecordType() && "Base class that isn't a record?"); ToVisit.push_back(Base.getType()->getAs()); a1498 1 } a1499 3 if (Successful) { std::swap(SuccessfulDeduced, Deduced); return Sema::TDK_Success; d1540 1 a1540 1 Info, Deduced, d1571 1 a1571 1 d1578 2 a1579 2 if (const DependentSizedExtVectorType *VectorArg d1591 1 a1591 1 d1594 1 a1594 1 d1610 1 a1610 1 d1613 1 a1613 1 = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); d1619 2 a1620 6 // Note that we use the "array bound" rules here; just like in that // case, we don't have any particular type for the vector size, but // we can provide one if necessary. return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize, S.Context.IntTy, true, Info, Deduced); d1622 2 a1623 2 if (const DependentSizedExtVectorType *VectorArg d1632 1 a1632 1 d1635 1 a1635 1 = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); d1638 2 a1639 3 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, VectorArg->getSizeExpr(), d1642 1 a1642 1 d1645 1 a1645 1 d1742 1 a1742 1 = getDeducedParameterFromExpr(Info, Param.getAsExpr())) { d1744 1 a1744 1 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, d1749 2 a1750 3 if (Arg.getKind() == TemplateArgument::NullPtr) return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP, Arg.getNullPtrType(), a1751 3 if (Arg.getKind() == TemplateArgument::Expression) return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Arg.getAsExpr(), Info, Deduced); d1753 1 a1753 3 return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Arg.getAsDecl(), Arg.getParamTypeForDecl(), d1779 4 a1782 3 static bool hasTemplateArgumentForDeduction(ArrayRef &Args, unsigned &ArgIdx) { if (ArgIdx == Args.size()) d1789 3 a1791 2 assert(ArgIdx == Args.size() - 1 && "Pack not at the end of argument list?"); Args = Arg.pack_elements(); d1793 1 a1793 1 return ArgIdx < Args.size(); d1798 13 a1810 5 static bool hasPackExpansionBeforeEnd(ArrayRef Args) { bool FoundPackExpansion = false; for (const auto &A : Args) { if (FoundPackExpansion) return true; d1812 3 a1814 2 if (A.getKind() == TemplateArgument::Pack) return hasPackExpansionBeforeEnd(A.pack_elements()); d1816 2 a1817 2 if (A.isPackExpansion()) FoundPackExpansion = true; d1824 4 a1827 3 DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, ArrayRef Params, ArrayRef Args, d1829 1 a1829 2 SmallVectorImpl &Deduced, bool NumberOfArgumentsMustMatch) { d1834 1 a1834 1 if (hasPackExpansionBeforeEnd(Params)) d1842 2 a1843 1 for (; hasTemplateArgumentForDeduction(Params, ParamIdx); ++ParamIdx) { d1848 6 a1853 9 if (!hasTemplateArgumentForDeduction(Args, ArgIdx)) return NumberOfArgumentsMustMatch ? Sema::TDK_MiscellaneousDeductionFailure : Sema::TDK_Success; // C++1z [temp.deduct.type]p9: // During partial ordering, if Ai was originally a pack expansion [and] // Pi is not a pack expansion, template argument deduction fails. if (Args[ArgIdx].isPackExpansion()) d1855 1 d1888 4 a1891 1 for (; hasTemplateArgumentForDeduction(Args, ArgIdx); ++ArgIdx) { d1903 1 a1903 1 if (auto Result = PackScope.finish()) d1917 4 a1920 3 return DeduceTemplateArguments(S, TemplateParams, ParamList.asArray(), ArgList.asArray(), Info, Deduced, /*NumberOfArgumentsMustMatch*/false); d1925 2 a1926 8 TemplateArgument X, const TemplateArgument &Y, bool PackExpansionMatchesPack = false) { // If we're checking deduced arguments (X) against original arguments (Y), // we will have flattened packs to non-expansions in X. if (PackExpansionMatchesPack && X.isPackExpansion() && !Y.isPackExpansion()) X = X.getPackExpansionPattern(); d1952 1 a1952 1 return hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()); d1969 1 a1969 1 if (!isSameTemplateArg(Context, *XP, *YP, PackExpansionMatchesPack)) d1981 2 d1988 1 a1988 2 /// argument. Can be null if no type sugar is available to add to the /// type from the template argument. d1992 5 a1996 3 TemplateArgumentLoc Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc) { d2002 2 a2003 2 return TemplateArgumentLoc( Arg, Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); d2006 3 a2008 4 if (NTTPType.isNull()) NTTPType = Arg.getParamTypeForDecl(); Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .getAs(); d2013 3 a2015 4 if (NTTPType.isNull()) NTTPType = Arg.getNullPtrType(); Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .getAs(); d2021 2 a2022 2 Expr *E = BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs(); d2031 1 a2031 1 Builder.MakeTrivial(Context, DTN->getQualifier(), Loc); d2034 2 a2035 2 Builder.MakeTrivial(Context, QTN->getQualifier(), Loc); d2037 2 a2038 1 return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context), d2040 3 a2042 2 return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context), d2063 2 d2066 1 a2066 1 bool IsDeduced, a2067 18 auto ConvertArg = [&](DeducedTemplateArgument Arg, unsigned ArgumentPackIndex) { // Convert the deduced template argument into a template // argument that we can check, almost as if the user had written // the template argument explicitly. TemplateArgumentLoc ArgLoc = S.getTrivialTemplateArgumentLoc(Arg, QualType(), Info.getLocation()); // Check the template argument, converting it as necessary. return S.CheckTemplateArgument( Param, ArgLoc, Template, Template->getLocation(), Template->getSourceRange().getEnd(), ArgumentPackIndex, Output, IsDeduced ? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound : Sema::CTAK_Deduced) : Sema::CTAK_Specified); }; d2078 3 a2080 13 assert(InnerArg.getKind() != TemplateArgument::Pack && "deduced nested pack"); if (P.isNull()) { // We deduced arguments for some elements of this pack, but not for // all of them. This happens if we get a conditionally-non-deduced // context in a pack expansion (such as an overload set in one of the // arguments). S.Diag(Param->getLocation(), diag::err_template_arg_deduced_incomplete_pack) << Arg << Param; return true; } if (ConvertArg(InnerArg, PackedArgsBuilder.size())) a2086 25 // If the pack is empty, we still need to substitute into the parameter // itself, in case that substitution fails. if (PackedArgsBuilder.empty()) { LocalInstantiationScope Scope(S); TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Output); MultiLevelTemplateArgumentList Args(TemplateArgs); if (auto *NTTP = dyn_cast(Param)) { Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template, NTTP, Output, Template->getSourceRange()); if (Inst.isInvalid() || S.SubstType(NTTP->getType(), Args, NTTP->getLocation(), NTTP->getDeclName()).isNull()) return true; } else if (auto *TTP = dyn_cast(Param)) { Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template, TTP, Output, Template->getSourceRange()); if (Inst.isInvalid() || !S.SubstDecl(TTP, S.CurContext, Args)) return true; } // For type parameters, no substitution is ever required. } d2093 18 a2110 1 return ConvertArg(Arg, 0); d2113 11 a2123 11 // FIXME: This should not be a template, but // ClassTemplatePartialSpecializationDecl sadly does not derive from // TemplateDecl. template static Sema::TemplateDeductionResult ConvertDeducedTemplateArguments( Sema &S, TemplateDeclT *Template, bool IsDeduced, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info, SmallVectorImpl &Builder, LocalInstantiationScope *CurrentInstantiationScope = nullptr, unsigned NumAlreadyConverted = 0, bool PartialOverloading = false) { TemplateParameterList *TemplateParams = Template->getTemplateParameters(); d2125 1 a2125 2 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { NamedDecl *Param = TemplateParams->getParam(I); d2127 10 a2136 32 if (!Deduced[I].isNull()) { if (I < NumAlreadyConverted) { // We may have had explicitly-specified template arguments for a // template parameter pack (that may or may not have been extended // via additional deduced arguments). if (Param->isParameterPack() && CurrentInstantiationScope && CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) { // Forget the partially-substituted pack; its substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); // We still need to check the argument in case it was extended by // deduction. } else { // We have already fully type-checked and converted this // argument, because it was explicitly-specified. Just record the // presence of this argument. Builder.push_back(Deduced[I]); continue; } } // We may have deduced this argument, so it still needs to be // checked and converted. if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Template, Info, IsDeduced, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); return Sema::TDK_SubstitutionFailure; } continue; d2139 2 a2140 15 // C++0x [temp.arg.explicit]p3: // A trailing template parameter pack (14.5.3) not otherwise deduced will // be deduced to an empty sequence of template arguments. // FIXME: Where did the word "trailing" come from? if (Param->isTemplateParameterPack()) { // We may have had explicitly-specified template arguments for this // template parameter pack. If so, our empty deduction extends the // explicitly-specified set (C++0x [temp.arg.explicit]p9). const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; if (CurrentInstantiationScope && CurrentInstantiationScope->getPartiallySubstitutedPack( &ExplicitArgs, &NumExplicitArgs) == Param) { Builder.push_back(TemplateArgument( llvm::makeArrayRef(ExplicitArgs, NumExplicitArgs))); d2142 15 a2156 9 // Forget the partially-substituted pack; its substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); } else { // Go through the motions of checking the empty argument pack against // the parameter pack. DeducedTemplateArgument DeducedPack(TemplateArgument::getEmptyPack()); if (ConvertDeducedTemplateArgument(S, Param, DeducedPack, Template, Info, IsDeduced, Builder)) { d2159 3 a2161 1 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); a2164 9 continue; } // Substitute into the default template argument, if available. bool HasDefaultArg = false; TemplateDecl *TD = dyn_cast(Template); if (!TD) { assert(isa(Template)); return Sema::TDK_Incomplete; d2167 4 a2170 21 TemplateArgumentLoc DefArg = S.SubstDefaultTemplateArgumentIfAvailable( TD, TD->getLocation(), TD->getSourceRange().getEnd(), Param, Builder, HasDefaultArg); // If there was no default argument, deduction is incomplete. if (DefArg.getArgument().isNull()) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); if (PartialOverloading) break; return HasDefaultArg ? Sema::TDK_SubstitutionFailure : Sema::TDK_Incomplete; } // Check whether we can actually use the default argument. if (S.CheckTemplateArgument(Param, DefArg, TD, TD->getLocation(), TD->getSourceRange().getEnd(), 0, Builder, Sema::CTAK_Specified)) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); d2172 2 a2173 1 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); a2175 2 // If we get here, we successfully used the default template argument. a2177 44 return Sema::TDK_Success; } DeclContext *getAsDeclContextOrEnclosing(Decl *D) { if (auto *DC = dyn_cast(D)) return DC; return D->getDeclContext(); } template struct IsPartialSpecialization { static constexpr bool value = false; }; template<> struct IsPartialSpecialization { static constexpr bool value = true; }; template<> struct IsPartialSpecialization { static constexpr bool value = true; }; /// Complete template argument deduction for a partial specialization. template static typename std::enable_if::value, Sema::TemplateDeductionResult>::type FinishTemplateArgumentDeduction( Sema &S, T *Partial, bool IsPartialOrdering, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Partial)); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; if (auto Result = ConvertDeducedTemplateArguments( S, Partial, IsPartialOrdering, Deduced, Info, Builder)) return Result; d2180 2 a2181 1 = TemplateArgumentList::CreateCopy(S.Context, Builder); d2191 5 a2195 5 auto *Template = Partial->getSpecializedTemplate(); const ASTTemplateArgumentListInfo *PartialTemplArgInfo = Partial->getTemplateArgsAsWritten(); const TemplateArgumentLoc *PartialTemplateArgs = PartialTemplArgInfo->getTemplateArgs(); d2206 3 a2208 2 Decl *Param = const_cast( Partial->getTemplateParameters()->getParam(ParamIdx)); d2215 2 a2216 2 if (S.CheckTemplateArgumentList(Template, Partial->getLocation(), InstArgs, false, ConvertedInstArgs)) d2219 2 a2220 1 TemplateParameterList *TemplateParams = Template->getTemplateParameters(); a2236 42 /// Complete template argument deduction for a class or variable template, /// when partial ordering against a partial specialization. // FIXME: Factor out duplication with partial specialization version above. Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( Sema &S, TemplateDecl *Template, bool PartialOrdering, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Template)); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; if (auto Result = ConvertDeducedTemplateArguments( S, Template, /*IsDeduced*/PartialOrdering, Deduced, Info, Builder)) return Result; // Check that we produced the correct argument list. TemplateParameterList *TemplateParams = Template->getTemplateParameters(); for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { TemplateArgument InstArg = Builder[I]; if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg, /*PackExpansionMatchesPack*/true)) { Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); Info.FirstArg = TemplateArgs[I]; Info.SecondArg = InstArg; return Sema::TDK_NonDeducedMismatch; } } if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return Sema::TDK_Success; } d2275 121 a2395 2 return ::FinishTemplateArgumentDeduction( *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info); d2401 5 d2439 2 a2440 2 return ::FinishTemplateArgumentDeduction( *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info); a2451 6 static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Level, llvm::SmallBitVector &Deduced); d2491 1 a2491 1 for (auto P : Function->parameters()) d2513 1 a2513 1 SmallVector DeducedArgs; d2536 1 a2536 1 = TemplateArgumentList::CreateCopy(Context, Builder); a2566 2 ExtParameterInfoBuilder ExtParamInfos; d2572 2 a2573 2 if (SubstParmTypes(Function->getLocation(), Function->parameters(), Proto->getExtParameterInfosOrNull(), d2575 1 a2575 1 ParamTypes, /*params*/ nullptr, ExtParamInfos)) d2578 1 a2578 1 d2583 2 a2584 2 // If a declaration declares a member function or member function // template of a class X, the expression this is a prvalue of type d2586 1 a2586 1 // and the end of the function-definition, member-declarator, or d2594 1 a2594 1 d2605 1 a2605 1 d2609 2 a2610 2 SubstParmTypes(Function->getLocation(), Function->parameters(), Proto->getExtParameterInfosOrNull(), d2612 1 a2612 1 ParamTypes, /*params*/ nullptr, ExtParamInfos)) a2615 2 auto EPI = Proto->getExtProtoInfo(); EPI.ExtParameterInfos = ExtParamInfos.getPointerOrNull(ParamTypes.size()); d2619 1 a2619 1 EPI); d2648 2 a2649 2 static bool CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg, d2652 1 a2652 1 d2655 1 a2655 1 d2659 1 a2659 1 d2666 1 a2666 1 d2669 2 a2670 2 // - If the original P is a reference type, the deduced A (i.e., the // type referred to by the reference) can be more cv-qualified than d2676 1 a2676 8 // FIXME: Resolve core issue (no number yet): if the original P is a // reference type and the transformed A is function type "noexcept F", // the deduced A can be F. QualType Tmp; if (A->isFunctionType() && S.IsFunctionConversion(A, DeducedA, Tmp)) return false; d2696 1 a2696 1 } else { d2703 4 a2706 4 // - The transformed A can be another pointer or pointer to member // type that can be converted to the deduced A via a function pointer // conversion and/or a qualification conversion. d2708 3 a2710 2 // Also allow conversions which merely strip __attribute__((noreturn)) from // function types (recursively). d2716 1 a2716 1 S.IsFunctionConversion(A, DeducedA, ResultTy))) d2718 3 a2720 2 // - If P is a class and P has the form simple-template-id, then the d2722 2 a2723 2 // [...] Likewise, if P is a pointer to a class of the form // simple-template-id, the transformed A can be a pointer to a d2737 1 a2737 1 d2740 1 a2740 1 d2744 1 a2744 1 a2747 30 /// Find the pack index for a particular parameter index in an instantiation of /// a function template with specific arguments. /// /// \return The pack index for whichever pack produced this parameter, or -1 /// if this was not produced by a parameter. Intended to be used as the /// ArgumentPackSubstitutionIndex for further substitutions. // FIXME: We should track this in OriginalCallArgs so we don't need to // reconstruct it here. static unsigned getPackIndexForParam(Sema &S, FunctionTemplateDecl *FunctionTemplate, const MultiLevelTemplateArgumentList &Args, unsigned ParamIdx) { unsigned Idx = 0; for (auto *PD : FunctionTemplate->getTemplatedDecl()->parameters()) { if (PD->isParameterPack()) { unsigned NumExpansions = S.getNumArgumentsInExpansion(PD->getType(), Args).getValueOr(1); if (Idx + NumExpansions > ParamIdx) return ParamIdx - Idx; Idx += NumExpansions; } else { if (Idx == ParamIdx) return -1; // Not a pack expansion ++Idx; } } llvm_unreachable("parameter index would not be produced from template"); } d2754 11 a2764 7 Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction( FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl &Deduced, unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, SmallVectorImpl const *OriginalCallArgs, bool PartialOverloading, llvm::function_ref CheckNonDependent) { d2785 123 a2907 5 if (auto Result = ConvertDeducedTemplateArguments( *this, FunctionTemplate, /*IsDeduced*/true, Deduced, Info, Builder, CurrentInstantiationScope, NumExplicitlySpecified, PartialOverloading)) return Result; d2909 2 a2910 11 // C++ [temp.deduct.call]p10: [DR1391] // If deduction succeeds for all parameters that contain // template-parameters that participate in template argument deduction, // and all template arguments are explicitly specified, deduced, or // obtained from default template arguments, remaining parameters are then // compared with the corresponding arguments. For each remaining parameter // P with a type that was non-dependent before substitution of any // explicitly-specified template arguments, if the corresponding argument // A cannot be implicitly converted to P, deduction fails. if (CheckNonDependent()) return TDK_NonDependentConversionFailure; d2914 1 a2914 1 = TemplateArgumentList::CreateCopy(Context, Builder); a2921 1 MultiLevelTemplateArgumentList SubstArgs(*DeducedArgumentList); d2923 2 a2924 1 SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, SubstArgs)); d2948 1 a2948 1 // values that will make the deduced A identical to A (after the type A a2949 1 llvm::SmallDenseMap, QualType> DeducedATypes; d2952 2 a2953 2 auto ParamIdx = OriginalArg.ArgIdx; a2954 3 // FIXME: This presumably means a pack ended up smaller than we // expected while deducing. Should this not result in deduction // failure? Can it even happen? d2956 2 a2957 24 QualType DeducedA; if (!OriginalArg.DecomposedParam) { // P is one of the function parameters, just look up its substituted // type. DeducedA = Specialization->getParamDecl(ParamIdx)->getType(); } else { // P is a decomposed element of a parameter corresponding to a // braced-init-list argument. Substitute back into P to find the // deduced A. QualType &CacheEntry = DeducedATypes[{ParamIdx, OriginalArg.OriginalParamType}]; if (CacheEntry.isNull()) { ArgumentPackSubstitutionIndexRAII PackIndex( *this, getPackIndexForParam(*this, FunctionTemplate, SubstArgs, ParamIdx)); CacheEntry = SubstType(OriginalArg.OriginalParamType, SubstArgs, Specialization->getTypeSpecStartLoc(), Specialization->getDeclName()); } DeducedA = CacheEntry; } d2962 1 a2962 2 return OriginalArg.DecomposedParam ? TDK_DeducedMismatchNested : TDK_DeducedMismatch; d2966 1 a2966 1 a3038 5 DeclAccessPair DAP; if (FunctionDecl *Viable = S.resolveAddressOfOnlyViableOverloadCandidate(Arg, DAP)) return GetTypeOfFunction(S, R, Viable); d3041 1 a3041 1 d3057 2 a3058 2 // Otherwise, see if we can resolve a function type d3064 1 a3064 1 d3209 1 a3209 1 static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument( d3212 1 a3212 3 SmallVectorImpl &Deduced, SmallVectorImpl &OriginalCallArgs, bool DecomposedParam, unsigned ArgIdx, unsigned TDF); d3216 29 a3244 16 static Sema::TemplateDeductionResult DeduceFromInitializerList( Sema &S, TemplateParameterList *TemplateParams, QualType AdjustedParamType, InitListExpr *ILE, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, SmallVectorImpl &OriginalCallArgs, unsigned ArgIdx, unsigned TDF) { // C++ [temp.deduct.call]p1: (CWG 1591) // If removing references and cv-qualifiers from P gives // std::initializer_list or P0[N] for some P0 and N and the argument is // a non-empty initializer list, then deduction is performed instead for // each element of the initializer list, taking P0 as a function template // parameter type and the initializer element as its argument // // We've already removed references and cv-qualifiers here. if (!ILE->getNumInits()) return Sema::TDK_Success; d3246 6 a3251 8 QualType ElTy; auto *ArrTy = S.Context.getAsArrayType(AdjustedParamType); if (ArrTy) ElTy = ArrTy->getElementType(); else if (!S.isStdInitializerList(AdjustedParamType, &ElTy)) { // Otherwise, an initializer list argument causes the parameter to be // considered a non-deduced context return Sema::TDK_Success; a3252 1 d3256 3 a3258 4 if (auto Result = DeduceTemplateArgumentsFromCallArgument( S, TemplateParams, ElTy, E, Info, Deduced, OriginalCallArgs, true, ArgIdx, TDF)) return Result; d3261 3 a3263 4 // in the P0[N] case, if N is a non-type template parameter, N is deduced // from the length of the initializer list. if (auto *DependentArrTy = dyn_cast_or_null(ArrTy)) { d3266 1 a3266 1 getDeducedParameterFromExpr(Info, DependentArrTy->getSizeExpr())) { d3269 2 d3273 4 a3276 4 if (auto Result = DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, llvm::APSInt(Size), NTTP->getType(), /*ArrayBound=*/true, Info, Deduced)) return Result; d3279 1 a3279 2 return Sema::TDK_Success; d3282 19 a3300 10 /// \brief Perform template argument deduction per [temp.deduct.call] for a /// single parameter / argument pair. static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument( Sema &S, TemplateParameterList *TemplateParams, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, SmallVectorImpl &OriginalCallArgs, bool DecomposedParam, unsigned ArgIdx, unsigned TDF) { QualType ArgType = Arg->getType(); QualType OrigParamType = ParamType; d3302 2 a3303 5 // If P is a reference type [...] // If P is a cv-qualified type [...] if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, ArgType, Arg, TDF)) return Sema::TDK_Success; d3305 7 a3311 12 // If [...] the argument is a non-empty initializer list [...] if (InitListExpr *ILE = dyn_cast(Arg)) return DeduceFromInitializerList(S, TemplateParams, ParamType, ILE, Info, Deduced, OriginalCallArgs, ArgIdx, TDF); // [...] the deduction process attempts to find template argument values // that will make the deduced A identical to A // // Keep track of the argument type and corresponding parameter index, // so we can check for compatibility between the deduced A and A. OriginalCallArgs.push_back( Sema::OriginalCallArg(OrigParamType, DecomposedParam, ArgIdx, ArgType)); a3333 6 /// \param CheckNonDependent A callback to invoke to check conversions for /// non-dependent parameters, between deduction and substitution, per DR1391. /// If this returns true, substitution will be skipped and we return /// TDK_NonDependentConversionFailure. The callback is passed the parameter /// types (after substituting explicit template arguments). /// d3339 1 a3339 2 bool PartialOverloading, llvm::function_ref)> CheckNonDependent) { d3350 1 d3358 3 a3360 1 else if (!Proto->isVariadic()) d3370 1 a3370 1 SmallVector ParamTypes; a3389 17 SmallVector OriginalCallArgs; // Deduce an argument of type ParamType from an expression with index ArgIdx. auto DeduceCallArgument = [&](QualType ParamType, unsigned ArgIdx) { // C++ [demp.deduct.call]p1: (DR1391) // Template argument deduction is done by comparing each function template // parameter that contains template-parameters that participate in // template argument deduction ... if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) return Sema::TDK_Success; // ... with the type of the corresponding argument return DeduceTemplateArgumentsFromCallArgument( *this, TemplateParams, ParamType, Args[ArgIdx], Info, Deduced, OriginalCallArgs, /*Decomposed*/false, ArgIdx, /*TDF*/ 0); }; d3392 3 a3394 2 SmallVector ParamTypesForArgChecking; for (unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0; d3396 5 a3400 4 QualType ParamType = ParamTypes[ParamIdx]; const PackExpansionType *ParamExpansion = dyn_cast(ParamType); d3403 1 a3403 1 if (ArgIdx >= Args.size()) d3406 36 a3441 2 ParamTypesForArgChecking.push_back(ParamType); if (auto Result = DeduceCallArgument(ParamType, ArgIdx++)) a3446 4 QualType ParamPattern = ParamExpansion->getPattern(); PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info, ParamPattern); d3453 27 a3479 15 // the function parameter pack. When a function parameter pack appears // in a non-deduced context [not at the end of the list], the type of // that parameter pack is never deduced. // // FIXME: The above rule allows the size of the parameter pack to change // after we skip it (in the non-deduced case). That makes no sense, so // we instead notionally deduce the pack against N arguments, where N is // the length of the explicitly-specified pack if it's expanded by the // parameter pack and 0 otherwise, and we treat each deduction as a // non-deduced context. if (ParamIdx + 1 == NumParamTypes) { for (; ArgIdx < Args.size(); PackScope.nextPackElement(), ++ArgIdx) { ParamTypesForArgChecking.push_back(ParamPattern); if (auto Result = DeduceCallArgument(ParamPattern, ArgIdx)) return Result; d3481 8 a3488 12 } else { // If the parameter type contains an explicitly-specified pack that we // could not expand, skip the number of parameters notionally created // by the expansion. Optional NumExpansions = ParamExpansion->getNumExpansions(); if (NumExpansions && !PackScope.isPartiallyExpanded()) { for (unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size(); ++I, ++ArgIdx) { ParamTypesForArgChecking.push_back(ParamPattern); // FIXME: Should we add OriginalCallArgs for these? What if the // corresponding argument is a list? PackScope.nextPackElement(); d3490 16 d3507 2 d3513 1 a3513 1 if (auto Result = PackScope.finish()) d3515 3 d3520 4 a3523 4 return FinishTemplateArgumentDeduction( FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info, &OriginalCallArgs, PartialOverloading, [&]() { return CheckNonDependent(ParamTypesForArgChecking); }); d3527 1 a3527 2 QualType FunctionType, bool AdjustExceptionSpec) { d3533 2 d3537 2 a3538 23 FunctionProtoType::ExtProtoInfo EPI = ArgFunctionTypeP->getExtProtoInfo(); bool Rebuild = false; CallingConv CC = FunctionTypeP->getCallConv(); if (EPI.ExtInfo.getCC() != CC) { EPI.ExtInfo = EPI.ExtInfo.withCallingConv(CC); Rebuild = true; } bool NoReturn = FunctionTypeP->getNoReturnAttr(); if (EPI.ExtInfo.getNoReturn() != NoReturn) { EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn); Rebuild = true; } if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() || ArgFunctionTypeP->hasExceptionSpec())) { EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec; Rebuild = true; } if (!Rebuild) d3541 5 a3545 2 return Context.getFunctionType(ArgFunctionTypeP->getReturnType(), ArgFunctionTypeP->getParamTypes(), EPI); a3569 5 /// \param IsAddressOfFunction If \c true, we are deducing as part of taking /// the address of a function template per [temp.deduct.funcaddr] and /// [over.over]. If \c false, we are looking up a function template /// specialization based on its signature, per [temp.deduct.decl]. /// d3571 7 a3577 5 Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ArgFunctionType, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool IsAddressOfFunction) { d3585 2 a3586 7 // When taking the address of a function, we require convertibility of // the resulting function type. Otherwise, we allow arbitrary mismatches // of calling convention, noreturn, and noexcept. if (!IsAddressOfFunction) ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType, /*AdjustExceptionSpec*/true); d3611 1 a3611 3 // type so that we treat it as a non-deduced context in what follows. If we // are looking up by signature, the signature type should also have a deduced // return type, which we instead expect to exactly match. d3613 1 a3613 1 if (getLangOpts().CPlusPlus14 && IsAddressOfFunction && d3621 1 a3621 2 if (IsAddressOfFunction) TDF |= TDF_InOverloadResolution; a3642 18 // If the function has a dependent exception specification, resolve it now, // so we can check that the exception specification matches. auto *SpecializationFPT = Specialization->getType()->castAs(); if (getLangOpts().CPlusPlus1z && isUnresolvedExceptionSpec(SpecializationFPT->getExceptionSpecType()) && !ResolveExceptionSpec(Info.getLocation(), SpecializationFPT)) return TDK_MiscellaneousDeductionFailure; // Adjust the exception specification of the argument again to match the // substituted and resolved type we just formed. (Calling convention and // noreturn can't be dependent, so we don't actually need this for them // right now.) QualType SpecializationType = Specialization->getType(); if (!IsAddressOfFunction) ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, SpecializationType, /*AdjustExceptionSpec*/true); d3647 3 a3649 4 if (IsAddressOfFunction && !isSameOrCompatibleFunctionType( Context.getCanonicalType(SpecializationType), Context.getCanonicalType(ArgFunctionType))) d3651 2 a3652 3 if (!IsAddressOfFunction && !Context.hasSameType(SpecializationType, ArgFunctionType)) d3659 2 a3660 2 /// \brief Given a function declaration (e.g. a generic lambda conversion /// function) that contains an 'auto' in its result type, substitute it d3664 2 a3665 2 static inline void SubstAutoWithinFunctionReturnType(FunctionDecl *F, d3669 2 a3670 2 assert(AutoResultType->getContainedAutoType()); QualType DeducedResultType = S.SubstAutoType(AutoResultType, d3675 4 a3678 4 /// \brief Given a specialized conversion operator of a generic lambda /// create the corresponding specializations of the call operator and /// the static-invoker. If the return type of the call operator is auto, /// deduce its return type and check if that matches the d3681 1 a3681 1 static inline Sema::TemplateDeductionResult d3688 1 a3688 1 d3690 2 a3691 2 assert(LambdaClass && LambdaClass->isGenericLambda()); d3694 1 a3694 1 const bool GenericLambdaCallOperatorHasDeducedReturnType = d3696 2 a3697 2 FunctionTemplateDecl *CallOpTemplate = d3701 1 a3701 1 // Use the deduced arguments of the conversion function, to specialize our d3704 2 a3705 2 = S.FinishTemplateArgumentDeduction(CallOpTemplate, DeducedArguments, d3708 1 a3708 1 d3712 1 a3712 1 S.DeduceReturnType(CallOpSpecialized, d3715 1 a3715 1 d3722 1 a3722 1 // ptr-to-functions (now including return type), and have successfully d3733 1 a3733 1 S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0, d3735 1 a3735 1 assert(Result == Sema::TDK_Success && d3742 1 a3742 1 // the full result type of the call op specialization d3754 1 a3754 1 SubstAutoWithinFunctionReturnType(ConversionSpecialized, d3757 1 a3757 1 d3759 1 a3759 1 // FIXME: When creating the InvokerTemplate in SemaLambda.cpp d3761 1 a3761 1 // the const qualifier to leak through. d3873 1 a3873 1 = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0, d3882 1 a3882 1 d3884 1 a3884 1 // to. This is necessary for matching the lambda call operator's return d3886 1 a3886 1 assert(A->isPointerType() && d3888 1 a3888 1 const FunctionType *ToFunType = d3892 3 a3894 3 // Create the corresponding specializations of the call operator and // the static-invoker; and if the return type is auto, // deduce the return type and check if it matches the d3902 1 a3902 1 Specialization, Deduced, DestFunctionPtrReturnType, a3923 7 /// \param IsAddressOfFunction If \c true, we are deducing as part of taking /// the address of a function template in a context where we do not have a /// target type, per [over.over]. If \c false, we are looking up a function /// template specialization based on its signature, which only happens when /// deducing a function parameter type from an argument that is a template-id /// naming a function template specialization. /// d3925 6 a3930 5 Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool IsAddressOfFunction) { d3933 1 a3933 1 IsAddressOfFunction); a3941 1 bool UseAutoSugar; d3943 1 a3943 2 SubstituteAutoTransform(Sema &SemaRef, QualType Replacement, bool UseAutoSugar = true) d3945 1 a3945 1 Replacement(Replacement), UseAutoSugar(UseAutoSugar) {} d3955 1 a3955 3 if (!UseAutoSugar) { assert(isa(Replacement) && "unexpected unsugared replacement kind"); d3962 6 a3967 2 QualType Result = SemaRef.Context.getAutoType( Replacement, TL.getTypePtr()->getKeyword(), Replacement.isNull()); d3990 2 a3991 4 Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result, Optional DependentDeductionDepth) { return DeduceAutoType(Type->getTypeLoc(), Init, Result, DependentDeductionDepth); a3995 4 /// Note that this is done even if the initializer is dependent. (This is /// necessary to support partial ordering of templates using 'auto'.) /// A dependent type will be produced when deducing from a dependent type. /// a3999 4 /// \param DependentDeductionDepth Set if we should permit deduction in /// dependent cases. This is necessary for template partial ordering with /// 'auto' template parameters. The value specified is the template /// parameter depth at which we should perform 'auto' deduction. d4001 1 a4001 2 Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result, Optional DependentDeductionDepth) { d4009 2 a4010 3 if (!DependentDeductionDepth && (Type.getType()->isDependentType() || Init->isTypeDependent())) { Result = SubstituteAutoTransform(*this, QualType()).Apply(Type); a4014 3 // Find the depth of template parameter to synthesize. unsigned Depth = DependentDeductionDepth.getValueOr(0); d4047 3 a4049 2 TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create( Context, nullptr, SourceLocation(), Loc, Depth, 0, nullptr, false, false); d4052 2 a4053 2 FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt( Loc, Loc, TemplParamPtr, Loc, nullptr); d4055 1 a4055 3 QualType FuncParam = SubstituteAutoTransform(*this, TemplArg, /*UseAutoSugar*/false) .Apply(Type); d4062 2 d4065 1 a4065 14 TemplateDeductionInfo Info(Loc, Depth); // If deduction failed, don't diagnose if the initializer is dependent; it // might acquire a matching type in the instantiation. auto DeductionFailed = [&]() -> DeduceAutoResult { if (Init->isTypeDependent()) { Result = SubstituteAutoTransform(*this, QualType()).Apply(Type); assert(!Result.isNull() && "substituting DependentTy can't fail"); return DAR_Succeeded; } return DAR_Failed; }; SmallVector OriginalCallArgs; a4068 6 // Notionally, we substitute std::initializer_list for 'auto' and deduce // against that. Such deduction only succeeds if removing cv-qualifiers and // references results in std::initializer_list. if (!Type.getType().getNonReferenceType()->getAs()) return DAR_Failed; d4070 4 a4073 5 if (DeduceTemplateArgumentsFromCallArgument( *this, TemplateParamsSt.get(), TemplArg, InitList->getInit(i), Info, Deduced, OriginalCallArgs, /*Decomposed*/ true, /*ArgIdx*/ 0, /*TDF*/ 0)) return DeductionFailed(); d4081 8 a4088 4 if (DeduceTemplateArgumentsFromCallArgument( *this, TemplateParamsSt.get(), FuncParam, Init, Info, Deduced, OriginalCallArgs, /*Decomposed*/ false, /*ArgIdx*/ 0, /*TDF*/ 0)) return DeductionFailed(); a4090 1 // Could be null if somehow 'auto' appears in a non-deduced context. d4092 1 a4092 1 return DeductionFailed(); d4104 1 a4104 1 return DAR_FailedAlreadyDiagnosed; d4108 6 a4113 8 QualType DeducedA = InitList ? Deduced[0].getAsType() : Result; for (const OriginalCallArg &OriginalArg : OriginalCallArgs) { assert((bool)InitList == OriginalArg.DecomposedParam && "decomposed non-init-list in auto deduction?"); if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) { Result = QualType(); return DeductionFailed(); } d4119 1 a4119 1 QualType Sema::SubstAutoType(QualType TypeWithAuto, d4121 2 a4122 4 if (TypeToReplaceAuto->isDependentType()) TypeToReplaceAuto = QualType(); return SubstituteAutoTransform(*this, TypeToReplaceAuto) .TransformType(TypeWithAuto); d4125 1 a4125 1 TypeSourceInfo* Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, d4127 2 a4128 4 if (TypeToReplaceAuto->isDependentType()) TypeToReplaceAuto = QualType(); return SubstituteAutoTransform(*this, TypeToReplaceAuto) .TransformType(TypeWithAuto); d4162 6 a4299 4 // FIXME: We fail to implement [temp.deduct.type]p1 along this path. We need // to substitute the deduced arguments back into the template and check that // we get the right type. d4503 3 a4505 4 const auto *FD = cast(*I); PD << FD << getTemplateArgumentBindingsText( FD->getPrimaryTemplate()->getTemplateParameters(), *FD->getTemplateSpecializationArgs()); d4507 2 a4508 1 HandleFunctionTypeMismatch(PD, FD->getType(), TargetType); d4516 5 a4520 2 /// Determine whether one partial specialization, P1, is at least as /// specialized than another, P2. d4522 9 a4530 8 /// \tparam TemplateLikeDecl The kind of P2, which must be a /// TemplateDecl or {Class,Var}TemplatePartialSpecializationDecl. /// \param T1 The injected-class-name of P1 (faked for a variable template). /// \param T2 The injected-class-name of P2 (faked for a variable template). template static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P2, TemplateDeductionInfo &Info) { d4556 1 a4557 37 // Determine whether P1 is at least as specialized as P2. Deduced.resize(P2->getTemplateParameters()->size()); if (DeduceTemplateArgumentsByTypeMatch(S, P2->getTemplateParameters(), T2, T1, Info, Deduced, TDF_None, /*PartialOrdering=*/true)) return false; SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); Sema::InstantiatingTemplate Inst(S, Info.getLocation(), P2, DeducedArgs, Info); auto *TST1 = T1->castAs(); if (FinishTemplateArgumentDeduction( S, P2, /*PartialOrdering=*/true, TemplateArgumentList(TemplateArgumentList::OnStack, TST1->template_arguments()), Deduced, Info)) return false; return true; } /// \brief Returns the more specialized class template partial specialization /// according to the rules of partial ordering of class template partial /// specializations (C++ [temp.class.order]). /// /// \param PS1 the first class template partial specialization /// /// \param PS2 the second class template partial specialization /// /// \returns the more specialized class template partial specialization. If /// neither partial specialization is more specialized, returns NULL. ClassTemplatePartialSpecializationDecl * Sema::getMoreSpecializedPartialSpecialization( ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { d4561 26 a4586 3 TemplateDeductionInfo Info(Loc); bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info); bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info); d4594 5 a4598 14 bool Sema::isMoreSpecializedThanPrimary( ClassTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) { ClassTemplateDecl *Primary = Spec->getSpecializedTemplate(); QualType PrimaryT = Primary->getInjectedClassNameSpecialization(); QualType PartialT = Spec->getInjectedSpecializationType(); if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info)) return false; if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) { Info.clearSFINAEDiagnostic(); return false; } return true; } d4603 3 a4605 2 // Pretend the variable template specializations are class template // specializations and form a fake injected class name type for comparison. d4612 2 a4613 1 CanonTemplate, PS1->getTemplateArgs().asArray()); d4615 2 a4616 5 CanonTemplate, PS2->getTemplateArgs().asArray()); TemplateDeductionInfo Info(Loc); bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info); bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info); d4618 12 a4629 26 if (Better1 == Better2) return nullptr; return Better1 ? PS1 : PS2; } bool Sema::isMoreSpecializedThanPrimary( VarTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) { TemplateDecl *Primary = Spec->getSpecializedTemplate(); // FIXME: Cache the injected template arguments rather than recomputing // them for each partial specialization. SmallVector PrimaryArgs; Context.getInjectedTemplateArgs(Primary->getTemplateParameters(), PrimaryArgs); TemplateName CanonTemplate = Context.getCanonicalTemplateName(TemplateName(Primary)); QualType PrimaryT = Context.getTemplateSpecializationType( CanonTemplate, PrimaryArgs); QualType PartialT = Context.getTemplateSpecializationType( CanonTemplate, Spec->getTemplateArgs().asArray()); if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info)) return false; if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) { Info.clearSFINAEDiagnostic(); return false; a4630 2 return true; } d4632 13 a4644 51 bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs( TemplateParameterList *P, TemplateDecl *AArg, SourceLocation Loc) { // C++1z [temp.arg.template]p4: (DR 150) // A template template-parameter P is at least as specialized as a // template template-argument A if, given the following rewrite to two // function templates... // Rather than synthesize function templates, we merely perform the // equivalent partial ordering by performing deduction directly on // the template parameter lists of the template template parameters. // // Given an invented class template X with the template parameter list of // A (including default arguments): TemplateName X = Context.getCanonicalTemplateName(TemplateName(AArg)); TemplateParameterList *A = AArg->getTemplateParameters(); // - Each function template has a single function parameter whose type is // a specialization of X with template arguments corresponding to the // template parameters from the respective function template SmallVector AArgs; Context.getInjectedTemplateArgs(A, AArgs); // Check P's arguments against A's parameter list. This will fill in default // template arguments as needed. AArgs are already correct by construction. // We can't just use CheckTemplateIdType because that will expand alias // templates. SmallVector PArgs; { SFINAETrap Trap(*this); Context.getInjectedTemplateArgs(P, PArgs); TemplateArgumentListInfo PArgList(P->getLAngleLoc(), P->getRAngleLoc()); for (unsigned I = 0, N = P->size(); I != N; ++I) { // Unwrap packs that getInjectedTemplateArgs wrapped around pack // expansions, to form an "as written" argument list. TemplateArgument Arg = PArgs[I]; if (Arg.getKind() == TemplateArgument::Pack) { assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion()); Arg = *Arg.pack_begin(); } PArgList.addArgument(getTrivialTemplateArgumentLoc( Arg, QualType(), P->getParam(I)->getLocation())); } PArgs.clear(); // C++1z [temp.arg.template]p3: // If the rewrite produces an invalid type, then P is not at least as // specialized as A. if (CheckTemplateArgumentList(AArg, Loc, PArgList, false, PArgs) || Trap.hasErrorOccurred()) return false; d4647 2 a4648 2 QualType AType = Context.getTemplateSpecializationType(X, AArgs); QualType PType = Context.getTemplateSpecializationType(X, PArgs); d4650 1 a4650 5 // ... the function template corresponding to P is at least as specialized // as the function template corresponding to A according to the partial // ordering rules for function templates. TemplateDeductionInfo Info(Loc, A->getDepth()); return isAtLeastAsSpecializedAs(*this, PType, AType, AArg, Info); a4696 5 // In C++1z mode, additional arguments may be deduced from the type of a // non-type argument. if (Ctx.getLangOpts().CPlusPlus1z) MarkUsedTemplateParameters(Ctx, NTTP->getType(), OnlyDeduced, Depth, Used); d4864 1 a4864 1 hasPackExpansionBeforeEnd(Spec->template_arguments())) d4943 1 a4943 1 cast(T)->getUnderlyingType(), d5039 1 a5039 1 hasPackExpansionBeforeEnd(TemplateArgs.asArray())) d5072 1 a5072 1 ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), @ 1.1.1.11 log @Import clang r309604 from branches/release_50 @ text @d59 2 a60 6 /// terms of noreturn and default calling convention adjustments, or /// similarly matching a declared template specialization against a /// possible template, per C++ [temp.deduct.decl]. In either case, permit /// deduction where the parameter is a function type that can be converted /// to the argument type. TDF_AllowCompatibleFunctionType = 0x20, a114 9 static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used); static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Level, llvm::SmallBitVector &Deduced); a336 12 if (NTTP->isExpandedParameterPack()) // FIXME: We may still need to deduce parts of the type here! But we // don't have any way to find which slice of the type to use, and the // type stored on the NTTP itself is nonsense. Perhaps the type of an // expanded NTTP should be a pack expansion type? return Sema::TDK_Success; // Get the type of the parameter for deduction. QualType ParamType = NTTP->getType(); if (auto *Expansion = dyn_cast(ParamType)) ParamType = Expansion->getPattern(); d342 1 a342 1 S, TemplateParams, ParamType.getNonReferenceType(), a619 9 // Dig out the partially-substituted pack, if there is one. const TemplateArgument *PartialPackArgs = nullptr; unsigned NumPartialPackArgs = 0; std::pair PartialPackDepthIndex(-1u, -1u); if (auto *Scope = S.CurrentInstantiationScope) if (auto *Partial = Scope->getPartiallySubstitutedPack( &PartialPackArgs, &NumPartialPackArgs)) PartialPackDepthIndex = getDepthAndIndex(Partial); a623 16 auto AddPack = [&](unsigned Index) { if (SawIndices[Index]) return; SawIndices[Index] = true; // Save the deduced template argument for the parameter pack expanded // by this pack expansion, then clear out the deduction. DeducedPack Pack(Index); Pack.Saved = Deduced[Index]; Deduced[Index] = TemplateArgument(); Packs.push_back(Pack); }; // First look for unexpanded packs in the pattern. d629 11 a639 2 if (Depth == Info.getDeducedDepth()) AddPack(Index); a640 24 assert(!Packs.empty() && "Pack expansion without unexpanded packs?"); // This pack expansion will have been partially expanded iff the only // unexpanded parameter pack within it is the partially-substituted pack. IsPartiallyExpanded = Packs.size() == 1 && PartialPackDepthIndex == std::make_pair(Info.getDeducedDepth(), Packs.front().Index); // Skip over the pack elements that were expanded into separate arguments. if (IsPartiallyExpanded) PackElements += NumPartialPackArgs; // We can also have deduced template parameters that do not actually // appear in the pattern, but can be deduced by it (the type of a non-type // template parameter pack, in particular). These won't have prevented us // from partially expanding the pack. llvm::SmallBitVector Used(TemplateParams->size()); MarkUsedTemplateParameters(S.Context, Pattern, /*OnlyDeduced*/true, Info.getDeducedDepth(), Used); for (int Index = Used.find_first(); Index != -1; Index = Used.find_next(Index)) if (TemplateParams->getParam(Index)->isParameterPack()) AddPack(Index); d642 1 d651 12 a662 13 if (PartialPackDepthIndex == std::make_pair(Info.getDeducedDepth(), Pack.Index)) { Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs); // We pre-populate the deduced value of the partially-substituted // pack with the specified value. This is not entirely correct: the // value is supposed to have been substituted, not deduced, but the // cases where this is observable require an exact type match anyway. // // FIXME: If we could represent a "depth i, index j, pack elem k" // parameter, we could substitute the partially-substituted pack // everywhere and avoid this. if (Pack.New.size() > PackElements) Deduced[Pack.Index] = Pack.New[PackElements]; d674 10 a683 1 bool isPartiallyExpanded() { return IsPartiallyExpanded; } d695 2 a696 7 if (Pack.New.size() == PackElements) Pack.New.push_back(DeducedArg); else Pack.New[PackElements] = DeducedArg; DeducedArg = Pack.New.size() > PackElements + 1 ? Pack.New[PackElements + 1] : DeducedTemplateArgument(); a732 5 // FIXME: This is wrong, it's possible that some pack elements are // deduced from an array bound and others are not: // template void g(const T (&...p)[V]); // g({1, 2, 3}, {{}, {}}); // ... should deduce T = {int, size_t (from array bound)}. a781 1 bool IsPartiallyExpanded = false; a965 26 /// Get the index of the first template parameter that was originally from the /// innermost template-parameter-list. This is 0 except when we concatenate /// the template parameter lists of a class template and a constructor template /// when forming an implicit deduction guide. static unsigned getFirstInnerIndex(FunctionTemplateDecl *FTD) { auto *Guide = dyn_cast(FTD->getTemplatedDecl()); if (!Guide || !Guide->isImplicit()) return 0; return Guide->getDeducedTemplate()->getTemplateParameters()->size(); } /// Determine whether a type denotes a forwarding reference. static bool isForwardingReference(QualType Param, unsigned FirstInnerIndex) { // C++1z [temp.deduct.call]p3: // A forwarding reference is an rvalue reference to a cv-unqualified // template parameter that does not represent a template parameter of a // class template. if (auto *ParamRef = Param->getAs()) { if (ParamRef->getPointeeType().getQualifiers()) return false; auto *TypeParm = ParamRef->getPointeeType()->getAs(); return TypeParm && TypeParm->getIndex() >= FirstInnerIndex; } return false; } d1086 2 a1087 2 // respectively, Pi is adjusted if it is a forwarding reference and Ai // is an lvalue reference, in d1093 8 a1100 2 if (isForwardingReference(Param, 0) && Arg->isLValueReferenceType()) Param = Param->getPointeeType(); d1226 3 a1228 4 bool NonDeduced = (TDF & TDF_AllowCompatibleFunctionType) ? !S.isSameOrCompatibleFunctionType(CanParam, CanArg) : Param != Arg; d1238 4 a1241 4 bool Success = (TDF & TDF_AllowCompatibleFunctionType) ? S.isSameOrCompatibleFunctionType(ParamUnqualType, ArgUnqualType) : ParamUnqualType == ArgUnqualType; d1444 4 a1447 3 if (auto Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, FunctionProtoParam->getReturnType(), FunctionProtoArg->getReturnType(), Info, Deduced, 0)) d1450 5 a1454 45 // Check parameter types. if (auto Result = DeduceTemplateArguments( S, TemplateParams, FunctionProtoParam->param_type_begin(), FunctionProtoParam->getNumParams(), FunctionProtoArg->param_type_begin(), FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF)) return Result; if (TDF & TDF_AllowCompatibleFunctionType) return Sema::TDK_Success; // FIXME: Per core-2016/10/1019 (no corresponding core issue yet), permit // deducing through the noexcept-specifier if it's part of the canonical // type. libstdc++ relies on this. Expr *NoexceptExpr = FunctionProtoParam->getNoexceptExpr(); if (NonTypeTemplateParmDecl *NTTP = NoexceptExpr ? getDeducedParameterFromExpr(Info, NoexceptExpr) : nullptr) { assert(NTTP->getDepth() == Info.getDeducedDepth() && "saw non-type template parameter with wrong depth"); llvm::APSInt Noexcept(1); switch (FunctionProtoArg->canThrow(S.Context)) { case CT_Cannot: Noexcept = 1; LLVM_FALLTHROUGH; case CT_Can: // We give E in noexcept(E) the "deduced from array bound" treatment. // FIXME: Should we? return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, Noexcept, S.Context.BoolTy, /*ArrayBound*/true, Info, Deduced); case CT_Dependent: if (Expr *ArgNoexceptExpr = FunctionProtoArg->getNoexceptExpr()) return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced); // Can't deduce anything from throw(T...). break; } } // FIXME: Detect non-deduced exception specification mismatches? return Sema::TDK_Success; d1464 1 a1464 1 LLVM_FALLTHROUGH; a1725 1 case Type::DeducedTemplateSpecialization: d2302 1 a2302 2 assert(isa(Template) || isa(Template)); d2338 1 a2338 1 static DeclContext *getAsDeclContextOrEnclosing(Decl *D) { d2366 1 a2366 2 EnterExpressionEvaluationContext Unevaluated( S, Sema::ExpressionEvaluationContext::Unevaluated); d2438 1 a2438 1 static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( d2444 1 a2444 2 EnterExpressionEvaluationContext Unevaluated( S, Sema::ExpressionEvaluationContext::Unevaluated); d2494 1 a2494 2 EnterExpressionEvaluationContext Unevaluated( *this, Sema::ExpressionEvaluationContext::Unevaluated); d2536 1 a2536 2 EnterExpressionEvaluationContext Unevaluated( *this, Sema::ExpressionEvaluationContext::Unevaluated); d2568 6 d2622 1 a2622 2 EnterExpressionEvaluationContext Unevaluated( *this, Sema::ExpressionEvaluationContext::Unevaluated); d2636 4 a2639 3 InstantiatingTemplate Inst( *this, Info.getLocation(), FunctionTemplate, DeducedArgs, CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info); d2643 5 a2647 3 if (CheckTemplateArgumentList(FunctionTemplate, SourceLocation(), ExplicitTemplateArgs, true, Builder, false) || Trap.hasErrorOccurred()) { a2741 11 // In C++1z onwards, exception specifications are part of the function type, // so substitution into the type must also substitute into the exception // specification. SmallVector ExceptionStorage; if (getLangOpts().CPlusPlus1z && SubstExceptionSpec( Function->getLocation(), EPI.ExceptionSpec, ExceptionStorage, MultiLevelTemplateArgumentList(*ExplicitArgumentList))) return TDK_SubstitutionFailure; d2923 1 a2923 2 EnterExpressionEvaluationContext Unevaluated( *this, Sema::ExpressionEvaluationContext::Unevaluated); d2929 4 a2932 3 InstantiatingTemplate Inst( *this, Info.getLocation(), FunctionTemplate, DeducedArgs, CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info); d3189 6 a3194 3 static bool AdjustFunctionParmAndArgTypesForDeduction( Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex, QualType &ParamType, QualType &ArgType, Expr *Arg, unsigned &TDF) { d3225 7 a3231 4 // C++1z [temp.deduct.call]p3: // If P is a forwarding reference and the argument is an lvalue, the type // "lvalue reference to A" is used in place of A for type deduction. if (isForwardingReference(QualType(ParamRefType, 0), FirstInnerIndex) && d3290 2 a3291 2 Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, d3329 1 a3329 1 S, TemplateParams, 0, ElTy, E, Info, Deduced, OriginalCallArgs, true, d3343 2 a3344 4 // C++ [temp.deduct.type]p13: // The type of N in the type T[N] is std::size_t. QualType T = S.Context.getSizeType(); llvm::APInt Size(S.Context.getIntWidth(T), ILE->getNumInits()); d3346 1 a3346 1 S, TemplateParams, NTTP, llvm::APSInt(Size), T, d3358 2 a3359 2 Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, d3368 2 a3369 2 if (AdjustFunctionParmAndArgTypesForDeduction( S, TemplateParams, FirstInnerIndex, ParamType, ArgType, Arg, TDF)) a3424 2 unsigned FirstInnerIndex = getFirstInnerIndex(FunctionTemplate); d3479 1 a3479 1 *this, TemplateParams, FirstInnerIndex, ParamType, Args[ArgIdx], Info, Deduced, d3638 7 a3660 7 // When taking the address of a function, we require convertibility of // the resulting function type. Otherwise, we allow arbitrary mismatches // of calling convention and noreturn. if (!IsAddressOfFunction) ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType, /*AdjustExceptionSpec*/false); d3662 1 a3662 2 EnterExpressionEvaluationContext Unevaluated( *this, Sema::ExpressionEvaluationContext::Unevaluated); d3679 3 a3681 2 unsigned TDF = TDF_TopLevelParameterTypeList | TDF_AllowCompatibleFunctionType; d3712 1 a3712 1 // Adjust the exception specification of the argument to match the d3910 1 a3910 2 EnterExpressionEvaluationContext Unevaluated( *this, Sema::ExpressionEvaluationContext::Unevaluated); d4023 4 a4026 4 /// Substitute the 'auto' specifier or deduced template specialization type /// specifier within a type for a given replacement type. class SubstituteDeducedTypeTransform : public TreeTransform { d4028 1 a4028 1 bool UseTypeSugar; d4030 4 a4033 13 SubstituteDeducedTypeTransform(Sema &SemaRef, QualType Replacement, bool UseTypeSugar = true) : TreeTransform(SemaRef), Replacement(Replacement), UseTypeSugar(UseTypeSugar) {} QualType TransformDesugared(TypeLocBuilder &TLB, DeducedTypeLoc TL) { assert(isa(Replacement) && "unexpected unsugared replacement kind"); QualType Result = Replacement; TemplateTypeParmTypeLoc NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } d4043 15 a4057 23 // // FIXME: Is this still necessary? if (!UseTypeSugar) return TransformDesugared(TLB, TL); QualType Result = SemaRef.Context.getAutoType( Replacement, TL.getTypePtr()->getKeyword(), Replacement.isNull()); auto NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } QualType TransformDeducedTemplateSpecializationType( TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) { if (!UseTypeSugar) return TransformDesugared(TLB, TL); QualType Result = SemaRef.Context.getDeducedTemplateSpecializationType( TL.getTypePtr()->getTemplateName(), Replacement, Replacement.isNull()); auto NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; d4108 1 a4108 1 Result = SubstituteDeducedTypeTransform(*this, QualType()).Apply(Type); d4131 1 a4131 1 Result = SubstituteDeducedTypeTransform(*this, Deduced).Apply(Type); d4156 1 a4156 1 SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/false) d4171 1 a4171 1 Result = SubstituteDeducedTypeTransform(*this, QualType()).Apply(Type); d4190 1 a4190 1 *this, TemplateParamsSt.get(), 0, TemplArg, InitList->getInit(i), d4202 1 a4202 1 *this, TemplateParamsSt.get(), 0, FuncParam, Init, Info, Deduced, d4219 1 a4219 1 Result = SubstituteDeducedTypeTransform(*this, DeducedType).Apply(Type); d4242 1 a4242 1 return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto) d4246 2 a4247 2 TypeSourceInfo *Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType TypeToReplaceAuto) { d4250 1 a4250 8 return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto) .TransformType(TypeWithAuto); } QualType Sema::ReplaceAutoType(QualType TypeWithAuto, QualType TypeToReplaceAuto) { return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto, /*UseTypeSugar*/ false) d4851 7 a4998 1 LLVM_FALLTHROUGH; a5030 2 if (auto *E = Proto->getNoexceptExpr()) MarkUsedTemplateParameters(Ctx, E, OnlyDeduced, Depth, Used); a5156 1 case Type::DeducedTemplateSpecialization: d5158 1 a5158 1 cast(T)->getDeducedType(), @ 1.1.1.11.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- SemaTemplateDeduction.cpp - Template Argument Deduction ------------===// d7 1 d9 1 a9 1 //===----------------------------------------------------------------------===// d11 1 a11 3 // This file implements C++ template argument deduction. // //===----------------------------------------------------------------------===// a14 1 #include "TypeLocBuilder.h" d17 1 a17 4 #include "clang/AST/Decl.h" #include "clang/AST/DeclAccessPair.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" a18 1 #include "clang/AST/DeclarationName.h" d21 3 a23 14 #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/TemplateBase.h" #include "clang/AST/TemplateName.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/AST/UnresolvedSet.h" #include "clang/Basic/AddressSpaces.h" #include "clang/Basic/ExceptionSpecificationType.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" #include "clang/Sema/Ownership.h" a25 6 #include "llvm/ADT/APInt.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/Optional.h" a26 5 #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" a27 3 #include #include #include d30 2 a31 2 /// Various flags that control template argument deduction. d35 1 a35 1 /// No template argument deduction flags, which indicates the d39 1 a39 2 /// Within template argument deduction from a function call, we are d43 1 a43 2 /// Within template argument deduction from a function call, we d46 1 a46 2 /// Within template argument deduction from a function call, d50 1 a50 2 /// Allow non-dependent types to differ, e.g., when performing d54 1 a54 2 /// Whether we are performing template argument deduction for d57 1 a57 2 /// Within template argument deduction from overload resolution per a64 5 /// Within template argument deduction for a conversion function, we are /// matching with an argument type for which the original argument was /// a reference. TDF_ArgWithReferenceType = 0x40, a68 1 using namespace sema; d70 1 a70 1 /// Compare two APSInts, extending and switching the sign as d128 1 a128 1 /// If the given expression is of a form that permits the deduction d135 1 a135 1 while (true) { d153 1 a153 1 /// Determine whether two declaration pointers refer to the same d164 1 a164 1 /// Verify that the given, deduced template arguments are compatible. d273 1 a273 1 // If we deduced two declarations, make sure that they refer to the d300 1 a300 1 case TemplateArgument::Pack: { a321 1 } d326 1 a326 1 /// Deduce the value of the given non-type template parameter d347 1 a347 1 if (!S.getLangOpts().CPlusPlus17) d357 2 a358 3 // Get the type of the parameter for deduction. If it's a (dependent) array // or function type, we will not have decayed it yet, so do that now. QualType ParamType = S.Context.getAdjustedParameterType(NTTP->getType()); d373 1 a373 1 /// Deduce the value of the given non-type template parameter d387 1 a387 1 /// Deduce the value of the given non-type template parameter d404 1 a404 1 /// Deduce the value of the given non-type template parameter d417 1 a417 1 /// Deduce the value of the given non-type template parameter d477 1 a477 1 /// Deduce the template arguments by comparing the template parameter a503 4 // Treat an injected-class-name as its underlying template-id. if (auto *Injected = dyn_cast(Arg)) Arg = Injected->getInjectedSpecializationType(); d558 1 a558 1 /// Determines whether the given type is an opaque type that d582 1 a582 1 /// Retrieve the depth and index of a template parameter. d595 1 a595 1 /// Retrieve the depth and index of an unexpanded parameter pack. d605 1 a605 1 /// Helper function to build a TemplateParameter when we don't d618 2 d634 1 a634 3 DeducedPack *Outer = nullptr; DeducedPack(unsigned Index) : Index(Index) {} a637 1 d763 1 a763 1 /// Finish template argument deduction for a set of argument packs, a851 1 d854 1 a854 1 /// Deduce the template arguments by comparing the list of parameter d893 6 d935 7 d952 7 a958 8 if (ParamIdx + 1 == NumParams) { for (; ArgIdx < NumArgs; ++ArgIdx) { // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced, TDF, PartialOrdering)) return Result; d960 1 a960 26 PackScope.nextPackElement(); } } else { // C++0x [temp.deduct.type]p5: // The non-deduced contexts are: // - A function parameter pack that does not occur at the end of the // parameter-declaration-clause. // // FIXME: There is no wording to say what we should do in this case. We // choose to resolve this by applying the same rule that is applied for a // function call: that is, deduce all contained packs to their // explicitly-specified values (or to <> if there is no such value). // // This is seemingly-arbitrarily different from the case of a template-id // with a non-trailing pack-expansion in its arguments, which renders the // entire template-argument-list a non-deduced context. // If the parameter type contains an explicitly-specified pack that we // could not expand, skip the number of parameters notionally created // by the expansion. Optional NumExpansions = Expansion->getNumExpansions(); if (NumExpansions && !PackScope.isPartiallyExpanded()) { for (unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs; ++I, ++ArgIdx) PackScope.nextPackElement(); } d976 2 a977 4 /// Determine whether the parameter has qualifiers that the argument /// lacks. Put another way, determine whether there is no way to add /// a deduced set of qualifiers to the ParamType that would result in /// its qualifiers matching those of the ArgType. d1001 4 a1004 2 // CVR qualifiers inconsistent or a superset. return (ParamQs.getCVRQualifiers() & ~ArgQs.getCVRQualifiers()) != 0; d1007 1 a1007 1 /// Compare types for equality with respect to possibly compatible d1059 1 a1059 1 /// Deduce the template arguments by comparing the parameter type and a1229 6 // Do not match a function type with a cv-qualified type. // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1584 if (Arg->isFunctionType() && Param.hasQualifiers()) { return Sema::TDK_NonDeducedMismatch; } a1304 12 } else if (TDF & TDF_ArgWithReferenceType) { // C++ [temp.deduct.conv]p4: // If the original A is a reference type, A can be more cv-qualified // than the deduced A if (!Arg.getQualifiers().compatiblyIncludes(Param.getQualifiers())) return Sema::TDK_NonDeducedMismatch; // Strip out all extra qualifiers from the argument to figure out the // type we're converting to, prior to the qualification conversion. Qualifiers Quals; Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); Arg = S.Context.getQualifiedType(Arg, Param.getQualifiers()); d1355 1 a1355 1 case Type::ObjCObjectPointer: d1365 1 d1559 1 a1559 1 switch (FunctionProtoArg->canThrow()) { a1579 3 // // Careful about [temp.deduct.call] and [temp.deduct.conv], which allow // top-level differences in noexcept-specifications. d1584 1 a1584 1 case Type::InjectedClassName: d1592 1 a1789 48 case Type::DependentVector: { const auto *VectorParam = cast(Param); if (const auto *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); ArgSize = VectorArg->getNumElements(); // Note that we use the "array bound" rules here; just like in that // case, we don't have any particular type for the vector size, but // we can provide one if necessary. return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize, S.Context.UnsignedIntTy, true, Info, Deduced); } if (const auto *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, VectorArg->getSizeExpr(), Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } a1845 53 // (clang extension) // // T __attribute__(((address_space(N)))) case Type::DependentAddressSpace: { const DependentAddressSpaceType *AddressSpaceParam = cast(Param); if (const DependentAddressSpaceType *AddressSpaceArg = dyn_cast(Arg)) { // Perform deduction on the pointer type. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, AddressSpaceParam->getPointeeType(), AddressSpaceArg->getPointeeType(), Info, Deduced, TDF)) return Result; // Perform deduction on the address space, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, AddressSpaceParam->getAddrSpaceExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, AddressSpaceArg->getAddrSpaceExpr(), Info, Deduced); } if (isTargetAddressSpace(Arg.getAddressSpace())) { llvm::APSInt ArgAddressSpace(S.Context.getTypeSize(S.Context.IntTy), false); ArgAddressSpace = toTargetAddressSpace(Arg.getAddressSpace()); // Perform deduction on the pointer types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, AddressSpaceParam->getPointeeType(), S.Context.removeAddrSpaceQualType(Arg), Info, Deduced, TDF)) return Result; // Perform deduction on the address space, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, AddressSpaceParam->getAddrSpaceExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgAddressSpace, S.Context.IntTy, true, Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } d1941 1 a1941 1 case TemplateArgument::Expression: d1970 1 a1970 1 d1978 1 a1978 1 /// Determine whether there is a template argument to be used for d2001 1 a2001 1 /// Determine whether the given set of template arguments has a pack d2075 4 d2116 1 a2116 1 /// Determine whether two template arguments are the same. d2177 1 a2177 1 /// Allocate a TemplateArgumentLoc where all locations have d2252 2 a2253 1 /// Convert the given deduced template argument and add it to the set of d2608 1 a2608 1 /// Perform template argument deduction to determine whether d2651 1 a2651 1 /// Perform template argument deduction to determine whether d2692 1 a2692 1 /// Determine whether the given type T is a simple-template-id type. a2697 11 // C++17 [temp.local]p2: // the injected-class-name [...] is equivalent to the template-name followed // by the template-arguments of the class template specialization or partial // specialization enclosed in <> // ... which means it's equivalent to a simple-template-id. // // This only arises during class template argument deduction for a copy // deduction candidate, where it permits slicing. if (T->getAs()) return true; d2701 1 a2701 1 /// Substitute the explicitly-provided template arguments into the d2872 1 a2872 1 if (getLangOpts().CPlusPlus17 && d2908 1 a2908 1 /// Check whether the deduced argument type for a call to a function d2910 2 a2911 3 static Sema::TemplateDeductionResult CheckOriginalCallArgDeduction(Sema &S, TemplateDeductionInfo &Info, Sema::OriginalCallArg OriginalArg, a2914 8 auto Failed = [&]() -> Sema::TemplateDeductionResult { Info.FirstArg = TemplateArgument(DeducedA); Info.SecondArg = TemplateArgument(OriginalArg.OriginalArgType); Info.CallArgIndex = OriginalArg.ArgIdx; return OriginalArg.DecomposedParam ? Sema::TDK_DeducedMismatchNested : Sema::TDK_DeducedMismatch; }; d2920 1 a2920 1 return Sema::TDK_Success; d2944 1 a2944 1 return Sema::TDK_Success; d2964 1 a2964 1 return Failed(); d2985 1 a2985 1 return Sema::TDK_Success; d3006 1 a3006 1 return Sema::TDK_Success; d3009 2 a3010 2 S.IsDerivedFrom(Info.getLocation(), A, DeducedA)) return Sema::TDK_Success; d3012 1 a3012 1 return Failed(); d3045 1 a3045 1 /// Finish template argument deduction for a function template, d3168 7 a3174 3 if (auto TDK = CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA)) return TDK; d3200 1 a3200 1 return {}; d3206 1 a3206 2 if (!R.HasFormOfMemberPointer) return {}; d3255 1 a3255 1 return {}; d3272 1 a3272 1 return {}; d3312 1 a3312 2 if (!Match.isNull()) return {}; d3319 1 a3319 1 /// Perform the adjustments to the parameter and argument types d3426 1 a3426 1 /// Attempt template argument deduction from an initializer list d3487 1 a3487 1 /// Perform template argument deduction per [temp.deduct.call] for a d3520 1 a3520 1 /// Perform template argument deduction from a function call a3685 4 // Capture the context in which the function call is made. This is the context // that is needed when the accessibility of template arguments is checked. DeclContext *CallingCtx = CurContext; d3688 2 a3689 4 &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() { ContextRAII SavedContext(*this, CallingCtx); return CheckNonDependent(ParamTypesForArgChecking); }); d3731 1 a3731 1 /// Deduce template arguments when taking the address of a function d3841 1 a3841 1 if (getLangOpts().CPlusPlus17 && d3873 112 a3984 1 /// Deduce template arguments for a templated conversion d4013 2 a4014 10 if (const ReferenceType *ARef = A->getAs()) { A = ARef->getPointeeType(); // We work around a defect in the standard here: cv-qualifiers are also // removed from P and A in this case, unless P was a reference type. This // seems to mostly match what other compilers are doing. if (!FromType->getAs()) { A = A.getUnqualifiedType(); P = P.getUnqualifiedType(); } d4018 1 a4018 1 } else { d4067 1 a4067 1 TDF |= TDF_ArgWithReferenceType; d4091 29 d4123 1 a4123 1 /// Deduce template arguments for a function template when there is a4157 1 a4163 1 d4225 1 a4225 2 } // namespace d4234 1 a4234 26 /// Attempt to produce an informative diagostic explaining why auto deduction /// failed. /// \return \c true if diagnosed, \c false if not. static bool diagnoseAutoDeductionFailure(Sema &S, Sema::TemplateDeductionResult TDK, TemplateDeductionInfo &Info, ArrayRef Ranges) { switch (TDK) { case Sema::TDK_Inconsistent: { // Inconsistent deduction means we were deducing from an initializer list. auto D = S.Diag(Info.getLocation(), diag::err_auto_inconsistent_deduction); D << Info.FirstArg << Info.SecondArg; for (auto R : Ranges) D << R; return true; } // FIXME: Are there other cases for which a custom diagnostic is more useful // than the basic "types don't match" diagnostic? default: return false; } } /// Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) d4321 1 a4321 2 auto DeductionFailed = [&](TemplateDeductionResult TDK, ArrayRef Ranges) -> DeduceAutoResult { a4326 2 if (diagnoseAutoDeductionFailure(*this, TDK, Info, Ranges)) return DAR_FailedAlreadyDiagnosed; a4339 1 SourceRange DeducedFromInitRange; d4341 2 a4342 4 Expr *Init = InitList->getInit(i); if (auto TDK = DeduceTemplateArgumentsFromCallArgument( *this, TemplateParamsSt.get(), 0, TemplArg, Init, d4345 1 a4345 6 return DeductionFailed(TDK, {DeducedFromInitRange, Init->getSourceRange()}); if (DeducedFromInitRange.isInvalid() && Deduced[0].getKind() != TemplateArgument::Null) DeducedFromInitRange = Init->getSourceRange(); d4353 1 a4353 1 if (auto TDK = DeduceTemplateArgumentsFromCallArgument( d4356 1 a4356 1 return DeductionFailed(TDK, {}); d4361 1 a4361 1 return DeductionFailed(TDK_Incomplete, {}); d4381 1 a4381 2 if (auto TDK = CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA)) { d4383 1 a4383 1 return DeductionFailed(TDK, {}); a4431 37 // For a lambda's conversion operator, deduce any 'auto' or 'decltype(auto)' // within the return type from the call operator's type. if (isLambdaConversionOperator(FD)) { CXXRecordDecl *Lambda = cast(FD)->getParent(); FunctionDecl *CallOp = Lambda->getLambdaCallOperator(); // For a generic lambda, instantiate the call operator if needed. if (auto *Args = FD->getTemplateSpecializationArgs()) { CallOp = InstantiateFunctionDeclaration( CallOp->getDescribedFunctionTemplate(), Args, Loc); if (!CallOp || CallOp->isInvalidDecl()) return true; // We might need to deduce the return type by instantiating the definition // of the operator() function. if (CallOp->getReturnType()->isUndeducedType()) InstantiateFunctionDefinition(Loc, CallOp); } if (CallOp->isInvalidDecl()) return true; assert(!CallOp->getReturnType()->isUndeducedType() && "failed to deduce lambda return type"); // Build the new return type from scratch. QualType RetType = getLambdaConversionFunctionResultType( CallOp->getType()->castAs()); if (FD->getReturnType()->getAs()) RetType = Context.getPointerType(RetType); else { assert(FD->getReturnType()->getAs()); RetType = Context.getBlockPointerType(RetType); } Context.adjustDeducedFunctionResultType(FD, RetType); return false; } d4444 1 a4444 1 /// If this is a non-static member function, d4466 1 a4466 1 /// Determine whether the function template \p FT1 is at least as d4617 1 a4617 1 /// Determine whether this a function template whose parameter-type-list d4638 1 a4638 1 /// Returns the more specialized function template according d4685 1 a4685 1 /// Determine if the two templates are equivalent. d4696 1 a4696 1 /// Retrieve the most specialized of the given function template d4855 1 a4855 1 /// Returns the more specialized class template partial specialization d5010 1 a5010 1 /// Mark the template parameters that are used by the given d5024 1 a5024 1 while (true) { d5048 1 a5048 1 // In C++17 mode, additional arguments may be deduced from the type of a d5050 1 a5050 1 if (Ctx.getLangOpts().CPlusPlus17) d5054 1 a5054 1 /// Mark the template parameters that are used by the given d5071 1 a5071 1 /// Mark the template parameters that are used by the given d5096 1 a5096 1 /// Mark the template parameters that are used by the given a5166 8 case Type::DependentVector: { const auto *VecType = cast(T); MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, Depth, Used); break; } a5176 11 case Type::DependentAddressSpace: { const DependentAddressSpaceType *DependentASType = cast(T); MarkUsedTemplateParameters(Ctx, DependentASType->getPointeeType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, DependentASType->getAddrSpaceExpr(), OnlyDeduced, Depth, Used); break; } d5181 3 a5183 18 for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) { // C++17 [temp.deduct.type]p5: // The non-deduced contexts are: [...] // -- A function parameter pack that does not occur at the end of the // parameter-declaration-list. if (!OnlyDeduced || I + 1 == N || !Proto->getParamType(I)->getAs()) { MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced, Depth, Used); } else { // FIXME: C++17 [temp.deduct.call]p1: // When a function parameter pack appears in a non-deduced context, // the type of that pack is never deduced. // // We should also track a set of "never deduced" parameters, and // subtract that from the list of deduced parameters after marking. } } d5209 1 a5209 1 LLVM_FALLTHROUGH; a5315 1 break; d5337 1 a5337 1 /// Mark the template parameters that are used by this d5380 1 a5380 1 /// Mark which template parameters can be deduced from a given d5406 1 a5406 1 /// Marks all of the template parameters that will be deduced by a @ 1.1.1.11.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.11.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- SemaTemplateDeduction.cpp - Template Argument Deduction ------------===// d7 1 d9 1 a9 1 //===----------------------------------------------------------------------===// d11 1 a11 3 // This file implements C++ template argument deduction. // //===----------------------------------------------------------------------===// a14 1 #include "TypeLocBuilder.h" d17 1 a17 4 #include "clang/AST/Decl.h" #include "clang/AST/DeclAccessPair.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" a18 1 #include "clang/AST/DeclarationName.h" d21 3 a23 14 #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/TemplateBase.h" #include "clang/AST/TemplateName.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/AST/UnresolvedSet.h" #include "clang/Basic/AddressSpaces.h" #include "clang/Basic/ExceptionSpecificationType.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" #include "clang/Sema/Ownership.h" a25 6 #include "llvm/ADT/APInt.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/Optional.h" a26 5 #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" a27 3 #include #include #include d30 2 a31 2 /// Various flags that control template argument deduction. d35 1 a35 1 /// No template argument deduction flags, which indicates the d39 1 a39 2 /// Within template argument deduction from a function call, we are d43 1 a43 2 /// Within template argument deduction from a function call, we d46 1 a46 2 /// Within template argument deduction from a function call, d50 1 a50 2 /// Allow non-dependent types to differ, e.g., when performing d54 1 a54 2 /// Whether we are performing template argument deduction for d57 1 a57 2 /// Within template argument deduction from overload resolution per a64 5 /// Within template argument deduction for a conversion function, we are /// matching with an argument type for which the original argument was /// a reference. TDF_ArgWithReferenceType = 0x40, a68 1 using namespace sema; d70 1 a70 1 /// Compare two APSInts, extending and switching the sign as d128 1 a128 1 /// If the given expression is of a form that permits the deduction d135 1 a135 1 while (true) { d153 1 a153 1 /// Determine whether two declaration pointers refer to the same d164 1 a164 1 /// Verify that the given, deduced template arguments are compatible. d273 1 a273 1 // If we deduced two declarations, make sure that they refer to the d300 1 a300 1 case TemplateArgument::Pack: { a321 1 } d326 1 a326 1 /// Deduce the value of the given non-type template parameter d347 1 a347 1 if (!S.getLangOpts().CPlusPlus17) d357 2 a358 3 // Get the type of the parameter for deduction. If it's a (dependent) array // or function type, we will not have decayed it yet, so do that now. QualType ParamType = S.Context.getAdjustedParameterType(NTTP->getType()); d373 1 a373 1 /// Deduce the value of the given non-type template parameter d387 1 a387 1 /// Deduce the value of the given non-type template parameter d404 1 a404 1 /// Deduce the value of the given non-type template parameter d417 1 a417 1 /// Deduce the value of the given non-type template parameter d477 1 a477 1 /// Deduce the template arguments by comparing the template parameter a503 4 // Treat an injected-class-name as its underlying template-id. if (auto *Injected = dyn_cast(Arg)) Arg = Injected->getInjectedSpecializationType(); d558 1 a558 1 /// Determines whether the given type is an opaque type that d582 1 a582 1 /// Retrieve the depth and index of a template parameter. d595 1 a595 1 /// Retrieve the depth and index of an unexpanded parameter pack. d605 1 a605 1 /// Helper function to build a TemplateParameter when we don't d618 2 d634 1 a634 3 DeducedPack *Outer = nullptr; DeducedPack(unsigned Index) : Index(Index) {} a637 1 d763 1 a763 1 /// Finish template argument deduction for a set of argument packs, a851 1 d854 1 a854 1 /// Deduce the template arguments by comparing the list of parameter d893 6 d935 7 d952 7 a958 8 if (ParamIdx + 1 == NumParams) { for (; ArgIdx < NumArgs; ++ArgIdx) { // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced, TDF, PartialOrdering)) return Result; d960 1 a960 26 PackScope.nextPackElement(); } } else { // C++0x [temp.deduct.type]p5: // The non-deduced contexts are: // - A function parameter pack that does not occur at the end of the // parameter-declaration-clause. // // FIXME: There is no wording to say what we should do in this case. We // choose to resolve this by applying the same rule that is applied for a // function call: that is, deduce all contained packs to their // explicitly-specified values (or to <> if there is no such value). // // This is seemingly-arbitrarily different from the case of a template-id // with a non-trailing pack-expansion in its arguments, which renders the // entire template-argument-list a non-deduced context. // If the parameter type contains an explicitly-specified pack that we // could not expand, skip the number of parameters notionally created // by the expansion. Optional NumExpansions = Expansion->getNumExpansions(); if (NumExpansions && !PackScope.isPartiallyExpanded()) { for (unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs; ++I, ++ArgIdx) PackScope.nextPackElement(); } d976 2 a977 4 /// Determine whether the parameter has qualifiers that the argument /// lacks. Put another way, determine whether there is no way to add /// a deduced set of qualifiers to the ParamType that would result in /// its qualifiers matching those of the ArgType. d1001 4 a1004 2 // CVR qualifiers inconsistent or a superset. return (ParamQs.getCVRQualifiers() & ~ArgQs.getCVRQualifiers()) != 0; d1007 1 a1007 1 /// Compare types for equality with respect to possibly compatible d1059 1 a1059 1 /// Deduce the template arguments by comparing the parameter type and a1229 6 // Do not match a function type with a cv-qualified type. // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1584 if (Arg->isFunctionType() && Param.hasQualifiers()) { return Sema::TDK_NonDeducedMismatch; } a1304 12 } else if (TDF & TDF_ArgWithReferenceType) { // C++ [temp.deduct.conv]p4: // If the original A is a reference type, A can be more cv-qualified // than the deduced A if (!Arg.getQualifiers().compatiblyIncludes(Param.getQualifiers())) return Sema::TDK_NonDeducedMismatch; // Strip out all extra qualifiers from the argument to figure out the // type we're converting to, prior to the qualification conversion. Qualifiers Quals; Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); Arg = S.Context.getQualifiedType(Arg, Param.getQualifiers()); d1355 1 a1355 1 case Type::ObjCObjectPointer: d1365 1 d1559 1 a1559 1 switch (FunctionProtoArg->canThrow()) { a1579 3 // // Careful about [temp.deduct.call] and [temp.deduct.conv], which allow // top-level differences in noexcept-specifications. d1584 1 a1584 1 case Type::InjectedClassName: d1592 1 a1789 48 case Type::DependentVector: { const auto *VectorParam = cast(Param); if (const auto *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); ArgSize = VectorArg->getNumElements(); // Note that we use the "array bound" rules here; just like in that // case, we don't have any particular type for the vector size, but // we can provide one if necessary. return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize, S.Context.UnsignedIntTy, true, Info, Deduced); } if (const auto *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, VectorArg->getSizeExpr(), Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } a1845 53 // (clang extension) // // T __attribute__(((address_space(N)))) case Type::DependentAddressSpace: { const DependentAddressSpaceType *AddressSpaceParam = cast(Param); if (const DependentAddressSpaceType *AddressSpaceArg = dyn_cast(Arg)) { // Perform deduction on the pointer type. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, AddressSpaceParam->getPointeeType(), AddressSpaceArg->getPointeeType(), Info, Deduced, TDF)) return Result; // Perform deduction on the address space, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, AddressSpaceParam->getAddrSpaceExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, AddressSpaceArg->getAddrSpaceExpr(), Info, Deduced); } if (isTargetAddressSpace(Arg.getAddressSpace())) { llvm::APSInt ArgAddressSpace(S.Context.getTypeSize(S.Context.IntTy), false); ArgAddressSpace = toTargetAddressSpace(Arg.getAddressSpace()); // Perform deduction on the pointer types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, AddressSpaceParam->getPointeeType(), S.Context.removeAddrSpaceQualType(Arg), Info, Deduced, TDF)) return Result; // Perform deduction on the address space, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, AddressSpaceParam->getAddrSpaceExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgAddressSpace, S.Context.IntTy, true, Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } d1941 1 a1941 1 case TemplateArgument::Expression: d1970 1 a1970 1 d1978 1 a1978 1 /// Determine whether there is a template argument to be used for d2001 1 a2001 1 /// Determine whether the given set of template arguments has a pack d2075 4 d2116 1 a2116 1 /// Determine whether two template arguments are the same. d2177 1 a2177 1 /// Allocate a TemplateArgumentLoc where all locations have d2252 2 a2253 1 /// Convert the given deduced template argument and add it to the set of d2608 1 a2608 1 /// Perform template argument deduction to determine whether d2651 1 a2651 1 /// Perform template argument deduction to determine whether d2692 1 a2692 1 /// Determine whether the given type T is a simple-template-id type. a2697 11 // C++17 [temp.local]p2: // the injected-class-name [...] is equivalent to the template-name followed // by the template-arguments of the class template specialization or partial // specialization enclosed in <> // ... which means it's equivalent to a simple-template-id. // // This only arises during class template argument deduction for a copy // deduction candidate, where it permits slicing. if (T->getAs()) return true; d2701 1 a2701 1 /// Substitute the explicitly-provided template arguments into the d2872 1 a2872 1 if (getLangOpts().CPlusPlus17 && d2908 1 a2908 1 /// Check whether the deduced argument type for a call to a function d2910 2 a2911 3 static Sema::TemplateDeductionResult CheckOriginalCallArgDeduction(Sema &S, TemplateDeductionInfo &Info, Sema::OriginalCallArg OriginalArg, a2914 8 auto Failed = [&]() -> Sema::TemplateDeductionResult { Info.FirstArg = TemplateArgument(DeducedA); Info.SecondArg = TemplateArgument(OriginalArg.OriginalArgType); Info.CallArgIndex = OriginalArg.ArgIdx; return OriginalArg.DecomposedParam ? Sema::TDK_DeducedMismatchNested : Sema::TDK_DeducedMismatch; }; d2920 1 a2920 1 return Sema::TDK_Success; d2944 1 a2944 1 return Sema::TDK_Success; d2964 1 a2964 1 return Failed(); d2985 1 a2985 1 return Sema::TDK_Success; d3006 1 a3006 1 return Sema::TDK_Success; d3009 2 a3010 2 S.IsDerivedFrom(Info.getLocation(), A, DeducedA)) return Sema::TDK_Success; d3012 1 a3012 1 return Failed(); d3045 1 a3045 1 /// Finish template argument deduction for a function template, d3168 7 a3174 3 if (auto TDK = CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA)) return TDK; d3200 1 a3200 1 return {}; d3206 1 a3206 2 if (!R.HasFormOfMemberPointer) return {}; d3255 1 a3255 1 return {}; d3272 1 a3272 1 return {}; d3312 1 a3312 2 if (!Match.isNull()) return {}; d3319 1 a3319 1 /// Perform the adjustments to the parameter and argument types d3426 1 a3426 1 /// Attempt template argument deduction from an initializer list d3487 1 a3487 1 /// Perform template argument deduction per [temp.deduct.call] for a d3520 1 a3520 1 /// Perform template argument deduction from a function call a3685 4 // Capture the context in which the function call is made. This is the context // that is needed when the accessibility of template arguments is checked. DeclContext *CallingCtx = CurContext; d3688 2 a3689 4 &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() { ContextRAII SavedContext(*this, CallingCtx); return CheckNonDependent(ParamTypesForArgChecking); }); d3731 1 a3731 1 /// Deduce template arguments when taking the address of a function d3841 1 a3841 1 if (getLangOpts().CPlusPlus17 && d3873 112 a3984 1 /// Deduce template arguments for a templated conversion d4013 2 a4014 10 if (const ReferenceType *ARef = A->getAs()) { A = ARef->getPointeeType(); // We work around a defect in the standard here: cv-qualifiers are also // removed from P and A in this case, unless P was a reference type. This // seems to mostly match what other compilers are doing. if (!FromType->getAs()) { A = A.getUnqualifiedType(); P = P.getUnqualifiedType(); } d4018 1 a4018 1 } else { d4067 1 a4067 1 TDF |= TDF_ArgWithReferenceType; d4091 29 d4123 1 a4123 1 /// Deduce template arguments for a function template when there is a4157 1 a4163 1 d4225 1 a4225 2 } // namespace d4234 1 a4234 26 /// Attempt to produce an informative diagostic explaining why auto deduction /// failed. /// \return \c true if diagnosed, \c false if not. static bool diagnoseAutoDeductionFailure(Sema &S, Sema::TemplateDeductionResult TDK, TemplateDeductionInfo &Info, ArrayRef Ranges) { switch (TDK) { case Sema::TDK_Inconsistent: { // Inconsistent deduction means we were deducing from an initializer list. auto D = S.Diag(Info.getLocation(), diag::err_auto_inconsistent_deduction); D << Info.FirstArg << Info.SecondArg; for (auto R : Ranges) D << R; return true; } // FIXME: Are there other cases for which a custom diagnostic is more useful // than the basic "types don't match" diagnostic? default: return false; } } /// Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) d4321 1 a4321 2 auto DeductionFailed = [&](TemplateDeductionResult TDK, ArrayRef Ranges) -> DeduceAutoResult { a4326 2 if (diagnoseAutoDeductionFailure(*this, TDK, Info, Ranges)) return DAR_FailedAlreadyDiagnosed; a4339 1 SourceRange DeducedFromInitRange; d4341 2 a4342 4 Expr *Init = InitList->getInit(i); if (auto TDK = DeduceTemplateArgumentsFromCallArgument( *this, TemplateParamsSt.get(), 0, TemplArg, Init, d4345 1 a4345 6 return DeductionFailed(TDK, {DeducedFromInitRange, Init->getSourceRange()}); if (DeducedFromInitRange.isInvalid() && Deduced[0].getKind() != TemplateArgument::Null) DeducedFromInitRange = Init->getSourceRange(); d4353 1 a4353 1 if (auto TDK = DeduceTemplateArgumentsFromCallArgument( d4356 1 a4356 1 return DeductionFailed(TDK, {}); d4361 1 a4361 1 return DeductionFailed(TDK_Incomplete, {}); d4381 1 a4381 2 if (auto TDK = CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA)) { d4383 1 a4383 1 return DeductionFailed(TDK, {}); a4431 37 // For a lambda's conversion operator, deduce any 'auto' or 'decltype(auto)' // within the return type from the call operator's type. if (isLambdaConversionOperator(FD)) { CXXRecordDecl *Lambda = cast(FD)->getParent(); FunctionDecl *CallOp = Lambda->getLambdaCallOperator(); // For a generic lambda, instantiate the call operator if needed. if (auto *Args = FD->getTemplateSpecializationArgs()) { CallOp = InstantiateFunctionDeclaration( CallOp->getDescribedFunctionTemplate(), Args, Loc); if (!CallOp || CallOp->isInvalidDecl()) return true; // We might need to deduce the return type by instantiating the definition // of the operator() function. if (CallOp->getReturnType()->isUndeducedType()) InstantiateFunctionDefinition(Loc, CallOp); } if (CallOp->isInvalidDecl()) return true; assert(!CallOp->getReturnType()->isUndeducedType() && "failed to deduce lambda return type"); // Build the new return type from scratch. QualType RetType = getLambdaConversionFunctionResultType( CallOp->getType()->castAs()); if (FD->getReturnType()->getAs()) RetType = Context.getPointerType(RetType); else { assert(FD->getReturnType()->getAs()); RetType = Context.getBlockPointerType(RetType); } Context.adjustDeducedFunctionResultType(FD, RetType); return false; } d4444 1 a4444 1 /// If this is a non-static member function, d4466 1 a4466 1 /// Determine whether the function template \p FT1 is at least as d4617 1 a4617 1 /// Determine whether this a function template whose parameter-type-list d4638 1 a4638 1 /// Returns the more specialized function template according d4685 1 a4685 1 /// Determine if the two templates are equivalent. d4696 1 a4696 1 /// Retrieve the most specialized of the given function template d4855 1 a4855 1 /// Returns the more specialized class template partial specialization d5010 1 a5010 1 /// Mark the template parameters that are used by the given d5024 1 a5024 1 while (true) { d5048 1 a5048 1 // In C++17 mode, additional arguments may be deduced from the type of a d5050 1 a5050 1 if (Ctx.getLangOpts().CPlusPlus17) d5054 1 a5054 1 /// Mark the template parameters that are used by the given d5071 1 a5071 1 /// Mark the template parameters that are used by the given d5096 1 a5096 1 /// Mark the template parameters that are used by the given a5166 8 case Type::DependentVector: { const auto *VecType = cast(T); MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, Depth, Used); break; } a5176 11 case Type::DependentAddressSpace: { const DependentAddressSpaceType *DependentASType = cast(T); MarkUsedTemplateParameters(Ctx, DependentASType->getPointeeType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, DependentASType->getAddrSpaceExpr(), OnlyDeduced, Depth, Used); break; } d5181 3 a5183 18 for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) { // C++17 [temp.deduct.type]p5: // The non-deduced contexts are: [...] // -- A function parameter pack that does not occur at the end of the // parameter-declaration-list. if (!OnlyDeduced || I + 1 == N || !Proto->getParamType(I)->getAs()) { MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced, Depth, Used); } else { // FIXME: C++17 [temp.deduct.call]p1: // When a function parameter pack appears in a non-deduced context, // the type of that pack is never deduced. // // We should also track a set of "never deduced" parameters, and // subtract that from the list of deduced parameters after marking. } } d5209 1 a5209 1 LLVM_FALLTHROUGH; a5315 1 break; d5337 1 a5337 1 /// Mark the template parameters that are used by this d5380 1 a5380 1 /// Mark which template parameters can be deduced from a given d5406 1 a5406 1 /// Marks all of the template parameters that will be deduced by a @ 1.1.1.12 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- SemaTemplateDeduction.cpp - Template Argument Deduction ------------===// d7 1 d9 1 a9 1 //===----------------------------------------------------------------------===// d11 1 a11 3 // This file implements C++ template argument deduction. // //===----------------------------------------------------------------------===// a14 1 #include "TypeLocBuilder.h" d17 1 a17 4 #include "clang/AST/Decl.h" #include "clang/AST/DeclAccessPair.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" a18 1 #include "clang/AST/DeclarationName.h" d21 3 a23 14 #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/TemplateBase.h" #include "clang/AST/TemplateName.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/AST/UnresolvedSet.h" #include "clang/Basic/AddressSpaces.h" #include "clang/Basic/ExceptionSpecificationType.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" #include "clang/Sema/Ownership.h" a25 6 #include "llvm/ADT/APInt.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/Optional.h" a26 5 #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" a27 3 #include #include #include d30 2 a31 2 /// Various flags that control template argument deduction. d35 1 a35 1 /// No template argument deduction flags, which indicates the d39 1 a39 2 /// Within template argument deduction from a function call, we are d43 1 a43 2 /// Within template argument deduction from a function call, we d46 1 a46 2 /// Within template argument deduction from a function call, d50 1 a50 2 /// Allow non-dependent types to differ, e.g., when performing d54 1 a54 2 /// Whether we are performing template argument deduction for d57 1 a57 2 /// Within template argument deduction from overload resolution per a64 5 /// Within template argument deduction for a conversion function, we are /// matching with an argument type for which the original argument was /// a reference. TDF_ArgWithReferenceType = 0x40, a68 1 using namespace sema; d70 1 a70 1 /// Compare two APSInts, extending and switching the sign as d128 1 a128 1 /// If the given expression is of a form that permits the deduction d135 1 a135 1 while (true) { d153 1 a153 1 /// Determine whether two declaration pointers refer to the same d164 1 a164 1 /// Verify that the given, deduced template arguments are compatible. d273 1 a273 1 // If we deduced two declarations, make sure that they refer to the d300 1 a300 1 case TemplateArgument::Pack: { a321 1 } d326 1 a326 1 /// Deduce the value of the given non-type template parameter d347 1 a347 1 if (!S.getLangOpts().CPlusPlus17) d357 2 a358 3 // Get the type of the parameter for deduction. If it's a (dependent) array // or function type, we will not have decayed it yet, so do that now. QualType ParamType = S.Context.getAdjustedParameterType(NTTP->getType()); d373 1 a373 1 /// Deduce the value of the given non-type template parameter d387 1 a387 1 /// Deduce the value of the given non-type template parameter d404 1 a404 1 /// Deduce the value of the given non-type template parameter d417 1 a417 1 /// Deduce the value of the given non-type template parameter d477 1 a477 1 /// Deduce the template arguments by comparing the template parameter a503 4 // Treat an injected-class-name as its underlying template-id. if (auto *Injected = dyn_cast(Arg)) Arg = Injected->getInjectedSpecializationType(); d558 1 a558 1 /// Determines whether the given type is an opaque type that d582 1 a582 1 /// Retrieve the depth and index of a template parameter. d595 1 a595 1 /// Retrieve the depth and index of an unexpanded parameter pack. d605 1 a605 1 /// Helper function to build a TemplateParameter when we don't d618 2 d634 1 a634 3 DeducedPack *Outer = nullptr; DeducedPack(unsigned Index) : Index(Index) {} a637 1 d763 1 a763 1 /// Finish template argument deduction for a set of argument packs, a851 1 d854 1 a854 1 /// Deduce the template arguments by comparing the list of parameter d893 6 d935 7 d952 7 a958 8 if (ParamIdx + 1 == NumParams) { for (; ArgIdx < NumArgs; ++ArgIdx) { // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced, TDF, PartialOrdering)) return Result; d960 1 a960 26 PackScope.nextPackElement(); } } else { // C++0x [temp.deduct.type]p5: // The non-deduced contexts are: // - A function parameter pack that does not occur at the end of the // parameter-declaration-clause. // // FIXME: There is no wording to say what we should do in this case. We // choose to resolve this by applying the same rule that is applied for a // function call: that is, deduce all contained packs to their // explicitly-specified values (or to <> if there is no such value). // // This is seemingly-arbitrarily different from the case of a template-id // with a non-trailing pack-expansion in its arguments, which renders the // entire template-argument-list a non-deduced context. // If the parameter type contains an explicitly-specified pack that we // could not expand, skip the number of parameters notionally created // by the expansion. Optional NumExpansions = Expansion->getNumExpansions(); if (NumExpansions && !PackScope.isPartiallyExpanded()) { for (unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs; ++I, ++ArgIdx) PackScope.nextPackElement(); } d976 2 a977 4 /// Determine whether the parameter has qualifiers that the argument /// lacks. Put another way, determine whether there is no way to add /// a deduced set of qualifiers to the ParamType that would result in /// its qualifiers matching those of the ArgType. d1001 4 a1004 2 // CVR qualifiers inconsistent or a superset. return (ParamQs.getCVRQualifiers() & ~ArgQs.getCVRQualifiers()) != 0; d1007 1 a1007 1 /// Compare types for equality with respect to possibly compatible d1059 1 a1059 1 /// Deduce the template arguments by comparing the parameter type and a1229 6 // Do not match a function type with a cv-qualified type. // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1584 if (Arg->isFunctionType() && Param.hasQualifiers()) { return Sema::TDK_NonDeducedMismatch; } a1304 12 } else if (TDF & TDF_ArgWithReferenceType) { // C++ [temp.deduct.conv]p4: // If the original A is a reference type, A can be more cv-qualified // than the deduced A if (!Arg.getQualifiers().compatiblyIncludes(Param.getQualifiers())) return Sema::TDK_NonDeducedMismatch; // Strip out all extra qualifiers from the argument to figure out the // type we're converting to, prior to the qualification conversion. Qualifiers Quals; Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); Arg = S.Context.getQualifiedType(Arg, Param.getQualifiers()); d1355 1 a1355 1 case Type::ObjCObjectPointer: d1365 1 d1559 1 a1559 1 switch (FunctionProtoArg->canThrow()) { a1579 3 // // Careful about [temp.deduct.call] and [temp.deduct.conv], which allow // top-level differences in noexcept-specifications. d1584 1 a1584 1 case Type::InjectedClassName: d1592 1 a1789 48 case Type::DependentVector: { const auto *VectorParam = cast(Param); if (const auto *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); ArgSize = VectorArg->getNumElements(); // Note that we use the "array bound" rules here; just like in that // case, we don't have any particular type for the vector size, but // we can provide one if necessary. return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize, S.Context.UnsignedIntTy, true, Info, Deduced); } if (const auto *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, VectorArg->getSizeExpr(), Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } a1845 53 // (clang extension) // // T __attribute__(((address_space(N)))) case Type::DependentAddressSpace: { const DependentAddressSpaceType *AddressSpaceParam = cast(Param); if (const DependentAddressSpaceType *AddressSpaceArg = dyn_cast(Arg)) { // Perform deduction on the pointer type. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, AddressSpaceParam->getPointeeType(), AddressSpaceArg->getPointeeType(), Info, Deduced, TDF)) return Result; // Perform deduction on the address space, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, AddressSpaceParam->getAddrSpaceExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, AddressSpaceArg->getAddrSpaceExpr(), Info, Deduced); } if (isTargetAddressSpace(Arg.getAddressSpace())) { llvm::APSInt ArgAddressSpace(S.Context.getTypeSize(S.Context.IntTy), false); ArgAddressSpace = toTargetAddressSpace(Arg.getAddressSpace()); // Perform deduction on the pointer types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, AddressSpaceParam->getPointeeType(), S.Context.removeAddrSpaceQualType(Arg), Info, Deduced, TDF)) return Result; // Perform deduction on the address space, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( Info, AddressSpaceParam->getAddrSpaceExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgAddressSpace, S.Context.IntTy, true, Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } d1941 1 a1941 1 case TemplateArgument::Expression: d1970 1 a1970 1 d1978 1 a1978 1 /// Determine whether there is a template argument to be used for d2001 1 a2001 1 /// Determine whether the given set of template arguments has a pack d2075 4 d2116 1 a2116 1 /// Determine whether two template arguments are the same. d2177 1 a2177 1 /// Allocate a TemplateArgumentLoc where all locations have d2252 2 a2253 1 /// Convert the given deduced template argument and add it to the set of d2608 1 a2608 1 /// Perform template argument deduction to determine whether d2651 1 a2651 1 /// Perform template argument deduction to determine whether d2692 1 a2692 1 /// Determine whether the given type T is a simple-template-id type. a2697 11 // C++17 [temp.local]p2: // the injected-class-name [...] is equivalent to the template-name followed // by the template-arguments of the class template specialization or partial // specialization enclosed in <> // ... which means it's equivalent to a simple-template-id. // // This only arises during class template argument deduction for a copy // deduction candidate, where it permits slicing. if (T->getAs()) return true; d2701 1 a2701 1 /// Substitute the explicitly-provided template arguments into the d2872 1 a2872 1 if (getLangOpts().CPlusPlus17 && d2908 1 a2908 1 /// Check whether the deduced argument type for a call to a function d2910 2 a2911 3 static Sema::TemplateDeductionResult CheckOriginalCallArgDeduction(Sema &S, TemplateDeductionInfo &Info, Sema::OriginalCallArg OriginalArg, a2914 8 auto Failed = [&]() -> Sema::TemplateDeductionResult { Info.FirstArg = TemplateArgument(DeducedA); Info.SecondArg = TemplateArgument(OriginalArg.OriginalArgType); Info.CallArgIndex = OriginalArg.ArgIdx; return OriginalArg.DecomposedParam ? Sema::TDK_DeducedMismatchNested : Sema::TDK_DeducedMismatch; }; d2920 1 a2920 1 return Sema::TDK_Success; d2944 1 a2944 1 return Sema::TDK_Success; d2964 1 a2964 1 return Failed(); d2985 1 a2985 1 return Sema::TDK_Success; d3006 1 a3006 1 return Sema::TDK_Success; d3009 2 a3010 2 S.IsDerivedFrom(Info.getLocation(), A, DeducedA)) return Sema::TDK_Success; d3012 1 a3012 1 return Failed(); d3045 1 a3045 1 /// Finish template argument deduction for a function template, d3168 7 a3174 3 if (auto TDK = CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA)) return TDK; d3200 1 a3200 1 return {}; d3206 1 a3206 2 if (!R.HasFormOfMemberPointer) return {}; d3255 1 a3255 1 return {}; d3272 1 a3272 1 return {}; d3312 1 a3312 2 if (!Match.isNull()) return {}; d3319 1 a3319 1 /// Perform the adjustments to the parameter and argument types d3426 1 a3426 1 /// Attempt template argument deduction from an initializer list d3487 1 a3487 1 /// Perform template argument deduction per [temp.deduct.call] for a d3520 1 a3520 1 /// Perform template argument deduction from a function call a3685 4 // Capture the context in which the function call is made. This is the context // that is needed when the accessibility of template arguments is checked. DeclContext *CallingCtx = CurContext; d3688 2 a3689 4 &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() { ContextRAII SavedContext(*this, CallingCtx); return CheckNonDependent(ParamTypesForArgChecking); }); d3731 1 a3731 1 /// Deduce template arguments when taking the address of a function d3841 1 a3841 1 if (getLangOpts().CPlusPlus17 && d3873 112 a3984 1 /// Deduce template arguments for a templated conversion d4013 2 a4014 10 if (const ReferenceType *ARef = A->getAs()) { A = ARef->getPointeeType(); // We work around a defect in the standard here: cv-qualifiers are also // removed from P and A in this case, unless P was a reference type. This // seems to mostly match what other compilers are doing. if (!FromType->getAs()) { A = A.getUnqualifiedType(); P = P.getUnqualifiedType(); } d4018 1 a4018 1 } else { d4067 1 a4067 1 TDF |= TDF_ArgWithReferenceType; d4091 29 d4123 1 a4123 1 /// Deduce template arguments for a function template when there is a4157 1 a4163 1 d4225 1 a4225 2 } // namespace d4234 1 a4234 26 /// Attempt to produce an informative diagostic explaining why auto deduction /// failed. /// \return \c true if diagnosed, \c false if not. static bool diagnoseAutoDeductionFailure(Sema &S, Sema::TemplateDeductionResult TDK, TemplateDeductionInfo &Info, ArrayRef Ranges) { switch (TDK) { case Sema::TDK_Inconsistent: { // Inconsistent deduction means we were deducing from an initializer list. auto D = S.Diag(Info.getLocation(), diag::err_auto_inconsistent_deduction); D << Info.FirstArg << Info.SecondArg; for (auto R : Ranges) D << R; return true; } // FIXME: Are there other cases for which a custom diagnostic is more useful // than the basic "types don't match" diagnostic? default: return false; } } /// Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) d4321 1 a4321 2 auto DeductionFailed = [&](TemplateDeductionResult TDK, ArrayRef Ranges) -> DeduceAutoResult { a4326 2 if (diagnoseAutoDeductionFailure(*this, TDK, Info, Ranges)) return DAR_FailedAlreadyDiagnosed; a4339 1 SourceRange DeducedFromInitRange; d4341 2 a4342 4 Expr *Init = InitList->getInit(i); if (auto TDK = DeduceTemplateArgumentsFromCallArgument( *this, TemplateParamsSt.get(), 0, TemplArg, Init, d4345 1 a4345 6 return DeductionFailed(TDK, {DeducedFromInitRange, Init->getSourceRange()}); if (DeducedFromInitRange.isInvalid() && Deduced[0].getKind() != TemplateArgument::Null) DeducedFromInitRange = Init->getSourceRange(); d4353 1 a4353 1 if (auto TDK = DeduceTemplateArgumentsFromCallArgument( d4356 1 a4356 1 return DeductionFailed(TDK, {}); d4361 1 a4361 1 return DeductionFailed(TDK_Incomplete, {}); d4381 1 a4381 2 if (auto TDK = CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA)) { d4383 1 a4383 1 return DeductionFailed(TDK, {}); a4431 37 // For a lambda's conversion operator, deduce any 'auto' or 'decltype(auto)' // within the return type from the call operator's type. if (isLambdaConversionOperator(FD)) { CXXRecordDecl *Lambda = cast(FD)->getParent(); FunctionDecl *CallOp = Lambda->getLambdaCallOperator(); // For a generic lambda, instantiate the call operator if needed. if (auto *Args = FD->getTemplateSpecializationArgs()) { CallOp = InstantiateFunctionDeclaration( CallOp->getDescribedFunctionTemplate(), Args, Loc); if (!CallOp || CallOp->isInvalidDecl()) return true; // We might need to deduce the return type by instantiating the definition // of the operator() function. if (CallOp->getReturnType()->isUndeducedType()) InstantiateFunctionDefinition(Loc, CallOp); } if (CallOp->isInvalidDecl()) return true; assert(!CallOp->getReturnType()->isUndeducedType() && "failed to deduce lambda return type"); // Build the new return type from scratch. QualType RetType = getLambdaConversionFunctionResultType( CallOp->getType()->castAs()); if (FD->getReturnType()->getAs()) RetType = Context.getPointerType(RetType); else { assert(FD->getReturnType()->getAs()); RetType = Context.getBlockPointerType(RetType); } Context.adjustDeducedFunctionResultType(FD, RetType); return false; } d4444 1 a4444 1 /// If this is a non-static member function, d4466 1 a4466 1 /// Determine whether the function template \p FT1 is at least as d4617 1 a4617 1 /// Determine whether this a function template whose parameter-type-list d4638 1 a4638 1 /// Returns the more specialized function template according d4685 1 a4685 1 /// Determine if the two templates are equivalent. d4696 1 a4696 1 /// Retrieve the most specialized of the given function template d4855 1 a4855 1 /// Returns the more specialized class template partial specialization d5010 1 a5010 1 /// Mark the template parameters that are used by the given d5024 1 a5024 1 while (true) { d5048 1 a5048 1 // In C++17 mode, additional arguments may be deduced from the type of a d5050 1 a5050 1 if (Ctx.getLangOpts().CPlusPlus17) d5054 1 a5054 1 /// Mark the template parameters that are used by the given d5071 1 a5071 1 /// Mark the template parameters that are used by the given d5096 1 a5096 1 /// Mark the template parameters that are used by the given a5166 8 case Type::DependentVector: { const auto *VecType = cast(T); MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, Depth, Used); break; } a5176 11 case Type::DependentAddressSpace: { const DependentAddressSpaceType *DependentASType = cast(T); MarkUsedTemplateParameters(Ctx, DependentASType->getPointeeType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, DependentASType->getAddrSpaceExpr(), OnlyDeduced, Depth, Used); break; } d5181 3 a5183 18 for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) { // C++17 [temp.deduct.type]p5: // The non-deduced contexts are: [...] // -- A function parameter pack that does not occur at the end of the // parameter-declaration-list. if (!OnlyDeduced || I + 1 == N || !Proto->getParamType(I)->getAs()) { MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced, Depth, Used); } else { // FIXME: C++17 [temp.deduct.call]p1: // When a function parameter pack appears in a non-deduced context, // the type of that pack is never deduced. // // We should also track a set of "never deduced" parameters, and // subtract that from the list of deduced parameters after marking. } } d5209 1 a5209 1 LLVM_FALLTHROUGH; a5315 1 break; d5337 1 a5337 1 /// Mark the template parameters that are used by this d5380 1 a5380 1 /// Mark which template parameters can be deduced from a given d5406 1 a5406 1 /// Marks all of the template parameters that will be deduced by a @ 1.1.1.13 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file SemaTemplateDeduction.cpp was added on branch tls-maxphys on 2014-08-19 23:47:30 +0000 @ text @d1 5103 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 5103 //===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/ // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. //===----------------------------------------------------------------------===/ // // This file implements C++ template argument deduction. // //===----------------------------------------------------------------------===/ #include "clang/Sema/TemplateDeduction.h" #include "TreeTransform.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTLambda.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/StmtVisitor.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/Sema.h" #include "clang/Sema/Template.h" #include "llvm/ADT/SmallBitVector.h" #include namespace clang { using namespace sema; /// \brief Various flags that control template argument deduction. /// /// These flags can be bitwise-OR'd together. enum TemplateDeductionFlags { /// \brief No template argument deduction flags, which indicates the /// strictest results for template argument deduction (as used for, e.g., /// matching class template partial specializations). TDF_None = 0, /// \brief Within template argument deduction from a function call, we are /// matching with a parameter type for which the original parameter was /// a reference. TDF_ParamWithReferenceType = 0x1, /// \brief Within template argument deduction from a function call, we /// are matching in a case where we ignore cv-qualifiers. TDF_IgnoreQualifiers = 0x02, /// \brief Within template argument deduction from a function call, /// we are matching in a case where we can perform template argument /// deduction from a template-id of a derived class of the argument type. TDF_DerivedClass = 0x04, /// \brief Allow non-dependent types to differ, e.g., when performing /// template argument deduction from a function call where conversions /// may apply. TDF_SkipNonDependent = 0x08, /// \brief Whether we are performing template argument deduction for /// parameters and arguments in a top-level template argument TDF_TopLevelParameterTypeList = 0x10, /// \brief Within template argument deduction from overload resolution per /// C++ [over.over] allow matching function types that are compatible in /// terms of noreturn and default calling convention adjustments. TDF_InOverloadResolution = 0x20 }; } using namespace clang; /// \brief Compare two APSInts, extending and switching the sign as /// necessary to compare their values regardless of underlying type. static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { if (Y.getBitWidth() > X.getBitWidth()) X = X.extend(Y.getBitWidth()); else if (Y.getBitWidth() < X.getBitWidth()) Y = Y.extend(X.getBitWidth()); // If there is a signedness mismatch, correct it. if (X.isSigned() != Y.isSigned()) { // If the signed value is negative, then the values cannot be the same. if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) return false; Y.setIsSigned(true); X.setIsSigned(true); } return X == Y; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced); /// \brief Whether template argument deduction for two reference parameters /// resulted in the argument type, parameter type, or neither type being more /// qualified than the other. enum DeductionQualifierComparison { NeitherMoreQualified = 0, ParamMoreQualified, ArgMoreQualified }; /// \brief Stores the result of comparing two reference parameters while /// performing template argument deduction for partial ordering of function /// templates. struct RefParamPartialOrderingComparison { /// \brief Whether the parameter type is an rvalue reference type. bool ParamIsRvalueRef; /// \brief Whether the argument type is an rvalue reference type. bool ArgIsRvalueRef; /// \brief Whether the parameter or argument (or neither) is more qualified. DeductionQualifierComparison Qualifiers; }; static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl & Deduced, unsigned TDF, bool PartialOrdering = false, SmallVectorImpl * RefParamComparisons = nullptr); static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument *Params, unsigned NumParams, const TemplateArgument *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced); /// \brief If the given expression is of a form that permits the deduction /// of a non-type template parameter, return the declaration of that /// non-type template parameter. static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { // If we are within an alias template, the expression may have undergone // any number of parameter substitutions already. while (1) { if (ImplicitCastExpr *IC = dyn_cast(E)) E = IC->getSubExpr(); else if (SubstNonTypeTemplateParmExpr *Subst = dyn_cast(E)) E = Subst->getReplacement(); else break; } if (DeclRefExpr *DRE = dyn_cast(E)) return dyn_cast(DRE->getDecl()); return nullptr; } /// \brief Determine whether two declaration pointers refer to the same /// declaration. static bool isSameDeclaration(Decl *X, Decl *Y) { if (NamedDecl *NX = dyn_cast(X)) X = NX->getUnderlyingDecl(); if (NamedDecl *NY = dyn_cast(Y)) Y = NY->getUnderlyingDecl(); return X->getCanonicalDecl() == Y->getCanonicalDecl(); } /// \brief Verify that the given, deduced template arguments are compatible. /// /// \returns The deduced template argument, or a NULL template argument if /// the deduced template arguments were incompatible. static DeducedTemplateArgument checkDeducedTemplateArguments(ASTContext &Context, const DeducedTemplateArgument &X, const DeducedTemplateArgument &Y) { // We have no deduction for one or both of the arguments; they're compatible. if (X.isNull()) return Y; if (Y.isNull()) return X; switch (X.getKind()) { case TemplateArgument::Null: llvm_unreachable("Non-deduced template arguments handled above"); case TemplateArgument::Type: // If two template type arguments have the same type, they're compatible. if (Y.getKind() == TemplateArgument::Type && Context.hasSameType(X.getAsType(), Y.getAsType())) return X; return DeducedTemplateArgument(); case TemplateArgument::Integral: // If we deduced a constant in one case and either a dependent expression or // declaration in another case, keep the integral constant. // If both are integral constants with the same value, keep that value. if (Y.getKind() == TemplateArgument::Expression || Y.getKind() == TemplateArgument::Declaration || (Y.getKind() == TemplateArgument::Integral && hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()))) return DeducedTemplateArgument(X, X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Template: if (Y.getKind() == TemplateArgument::Template && Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::TemplateExpansion: if (Y.getKind() == TemplateArgument::TemplateExpansion && Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), Y.getAsTemplateOrTemplatePattern())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Expression: // If we deduced a dependent expression in one case and either an integral // constant or a declaration in another case, keep the integral constant // or declaration. if (Y.getKind() == TemplateArgument::Integral || Y.getKind() == TemplateArgument::Declaration) return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); if (Y.getKind() == TemplateArgument::Expression) { // Compare the expressions for equality llvm::FoldingSetNodeID ID1, ID2; X.getAsExpr()->Profile(ID1, Context, true); Y.getAsExpr()->Profile(ID2, Context, true); if (ID1 == ID2) return X; } // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Declaration: // If we deduced a declaration and a dependent expression, keep the // declaration. if (Y.getKind() == TemplateArgument::Expression) return X; // If we deduced a declaration and an integral constant, keep the // integral constant. if (Y.getKind() == TemplateArgument::Integral) return Y; // If we deduced two declarations, make sure they they refer to the // same declaration. if (Y.getKind() == TemplateArgument::Declaration && isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && X.isDeclForReferenceParam() == Y.isDeclForReferenceParam()) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::NullPtr: // If we deduced a null pointer and a dependent expression, keep the // null pointer. if (Y.getKind() == TemplateArgument::Expression) return X; // If we deduced a null pointer and an integral constant, keep the // integral constant. if (Y.getKind() == TemplateArgument::Integral) return Y; // If we deduced two null pointers, make sure they have the same type. if (Y.getKind() == TemplateArgument::NullPtr && Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Pack: if (Y.getKind() != TemplateArgument::Pack || X.pack_size() != Y.pack_size()) return DeducedTemplateArgument(); for (TemplateArgument::pack_iterator XA = X.pack_begin(), XAEnd = X.pack_end(), YA = Y.pack_begin(); XA != XAEnd; ++XA, ++YA) { // FIXME: Do we need to merge the results together here? if (checkDeducedTemplateArguments(Context, DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) .isNull()) return DeducedTemplateArgument(); } return X; } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Deduce the value of the given non-type template parameter /// from the given constant. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, llvm::APSInt Value, QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType, DeducedFromArrayBound); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } /// \brief Deduce the value of the given non-type template parameter /// from the given type- or value-dependent expression. /// /// \returns true if deduction succeeded, false otherwise. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, Expr *Value, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); assert((Value->isTypeDependent() || Value->isValueDependent()) && "Expression template argument must be type- or value-dependent."); DeducedTemplateArgument NewDeduced(Value); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } /// \brief Deduce the value of the given non-type template parameter /// from the given declaration. /// /// \returns true if deduction succeeded, false otherwise. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, ValueDecl *D, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); D = D ? cast(D->getCanonicalDecl()) : nullptr; TemplateArgument New(D, NTTP->getType()->isReferenceType()); DeducedTemplateArgument NewDeduced(New); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, TemplateName Param, TemplateName Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); if (!ParamDecl) { // The parameter type is dependent and is not a template template parameter, // so there is nothing that we can deduce. return Sema::TDK_Success; } if (TemplateTemplateParmDecl *TempParam = dyn_cast(ParamDecl)) { DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[TempParam->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = TempParam; Info.FirstArg = Deduced[TempParam->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[TempParam->getIndex()] = Result; return Sema::TDK_Success; } // Verify that the two template names are equivalent. if (S.Context.hasSameTemplateName(Param, Arg)) return Sema::TDK_Success; // Mismatch of non-dependent template parameter to argument. Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } /// \brief Deduce the template arguments by comparing the template parameter /// type (which is a template-id) with the template argument type. /// /// \param S the Sema /// /// \param TemplateParams the template parameters that we are deducing /// /// \param Param the parameter type /// /// \param Arg the argument type /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateSpecializationType *Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(Arg.isCanonical() && "Argument type must be canonical"); // Check whether the template argument is a dependent template-id. if (const TemplateSpecializationType *SpecArg = dyn_cast(Arg)) { // Perform template argument deduction for the template name. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Param->getTemplateName(), SpecArg->getTemplateName(), Info, Deduced)) return Result; // Perform template argument deduction on each template // argument. Ignore any missing/extra arguments, since they could be // filled in by default arguments. return DeduceTemplateArguments(S, TemplateParams, Param->getArgs(), Param->getNumArgs(), SpecArg->getArgs(), SpecArg->getNumArgs(), Info, Deduced); } // If the argument type is a class template specialization, we // perform template argument deduction using its template // arguments. const RecordType *RecordArg = dyn_cast(Arg); if (!RecordArg) { Info.FirstArg = TemplateArgument(QualType(Param, 0)); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } ClassTemplateSpecializationDecl *SpecArg = dyn_cast(RecordArg->getDecl()); if (!SpecArg) { Info.FirstArg = TemplateArgument(QualType(Param, 0)); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } // Perform template argument deduction for the template name. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Param->getTemplateName(), TemplateName(SpecArg->getSpecializedTemplate()), Info, Deduced)) return Result; // Perform template argument deduction for the template arguments. return DeduceTemplateArguments(S, TemplateParams, Param->getArgs(), Param->getNumArgs(), SpecArg->getTemplateArgs().data(), SpecArg->getTemplateArgs().size(), Info, Deduced); } /// \brief Determines whether the given type is an opaque type that /// might be more qualified when instantiated. static bool IsPossiblyOpaquelyQualifiedType(QualType T) { switch (T->getTypeClass()) { case Type::TypeOfExpr: case Type::TypeOf: case Type::DependentName: case Type::Decltype: case Type::UnresolvedUsing: case Type::TemplateTypeParm: return true; case Type::ConstantArray: case Type::IncompleteArray: case Type::VariableArray: case Type::DependentSizedArray: return IsPossiblyOpaquelyQualifiedType( cast(T)->getElementType()); default: return false; } } /// \brief Retrieve the depth and index of a template parameter. static std::pair getDepthAndIndex(NamedDecl *ND) { if (TemplateTypeParmDecl *TTP = dyn_cast(ND)) return std::make_pair(TTP->getDepth(), TTP->getIndex()); if (NonTypeTemplateParmDecl *NTTP = dyn_cast(ND)) return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); TemplateTemplateParmDecl *TTP = cast(ND); return std::make_pair(TTP->getDepth(), TTP->getIndex()); } /// \brief Retrieve the depth and index of an unexpanded parameter pack. static std::pair getDepthAndIndex(UnexpandedParameterPack UPP) { if (const TemplateTypeParmType *TTP = UPP.first.dyn_cast()) return std::make_pair(TTP->getDepth(), TTP->getIndex()); return getDepthAndIndex(UPP.first.get()); } /// \brief Helper function to build a TemplateParameter when we don't /// know its type statically. static TemplateParameter makeTemplateParameter(Decl *D) { if (TemplateTypeParmDecl *TTP = dyn_cast(D)) return TemplateParameter(TTP); if (NonTypeTemplateParmDecl *NTTP = dyn_cast(D)) return TemplateParameter(NTTP); return TemplateParameter(cast(D)); } /// A pack that we're currently deducing. struct clang::DeducedPack { DeducedPack(unsigned Index) : Index(Index), Outer(nullptr) {} // The index of the pack. unsigned Index; // The old value of the pack before we started deducing it. DeducedTemplateArgument Saved; // A deferred value of this pack from an inner deduction, that couldn't be // deduced because this deduction hadn't happened yet. DeducedTemplateArgument DeferredDeduction; // The new value of the pack. SmallVector New; // The outer deduction for this pack, if any. DeducedPack *Outer; }; /// A scope in which we're performing pack deduction. class PackDeductionScope { public: PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info, TemplateArgument Pattern) : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) { // Compute the set of template parameter indices that correspond to // parameter packs expanded by the pack expansion. { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; S.collectUnexpandedParameterPacks(Pattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; std::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; // Save the deduced template argument for the parameter pack expanded // by this pack expansion, then clear out the deduction. DeducedPack Pack(Index); Pack.Saved = Deduced[Index]; Deduced[Index] = TemplateArgument(); Packs.push_back(Pack); } } } assert(!Packs.empty() && "Pack expansion without unexpanded packs?"); for (auto &Pack : Packs) { if (Info.PendingDeducedPacks.size() > Pack.Index) Pack.Outer = Info.PendingDeducedPacks[Pack.Index]; else Info.PendingDeducedPacks.resize(Pack.Index + 1); Info.PendingDeducedPacks[Pack.Index] = &Pack; if (S.CurrentInstantiationScope) { // If the template argument pack was explicitly specified, add that to // the set of deduced arguments. const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; NamedDecl *PartiallySubstitutedPack = S.CurrentInstantiationScope->getPartiallySubstitutedPack( &ExplicitArgs, &NumExplicitArgs); if (PartiallySubstitutedPack && getDepthAndIndex(PartiallySubstitutedPack).second == Pack.Index) Pack.New.append(ExplicitArgs, ExplicitArgs + NumExplicitArgs); } } } ~PackDeductionScope() { for (auto &Pack : Packs) Info.PendingDeducedPacks[Pack.Index] = Pack.Outer; } /// Move to deducing the next element in each pack that is being deduced. void nextPackElement() { // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (auto &Pack : Packs) { DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index]; if (!DeducedArg.isNull()) { Pack.New.push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } } } /// \brief Finish template argument deduction for a set of argument packs, /// producing the argument packs and checking for consistency with prior /// deductions. Sema::TemplateDeductionResult finish(bool HasAnyArguments) { // Build argument packs for each of the parameter packs expanded by this // pack expansion. for (auto &Pack : Packs) { // Put back the old value for this pack. Deduced[Pack.Index] = Pack.Saved; // Build or find a new value for this pack. DeducedTemplateArgument NewPack; if (HasAnyArguments && Pack.New.empty()) { if (Pack.DeferredDeduction.isNull()) { // We were not able to deduce anything for this parameter pack // (because it only appeared in non-deduced contexts), so just // restore the saved argument pack. continue; } NewPack = Pack.DeferredDeduction; Pack.DeferredDeduction = TemplateArgument(); } else if (Pack.New.empty()) { // If we deduced an empty argument pack, create it now. NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); } else { TemplateArgument *ArgumentPack = new (S.Context) TemplateArgument[Pack.New.size()]; std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack); NewPack = DeducedTemplateArgument( TemplateArgument(ArgumentPack, Pack.New.size()), Pack.New[0].wasDeducedFromArrayBound()); } // Pick where we're going to put the merged pack. DeducedTemplateArgument *Loc; if (Pack.Outer) { if (Pack.Outer->DeferredDeduction.isNull()) { // Defer checking this pack until we have a complete pack to compare // it against. Pack.Outer->DeferredDeduction = NewPack; continue; } Loc = &Pack.Outer->DeferredDeduction; } else { Loc = &Deduced[Pack.Index]; } // Check the new pack matches any previous value. DeducedTemplateArgument OldPack = *Loc; DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack); // If we deferred a deduction of this pack, check that one now too. if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) { OldPack = Result; NewPack = Pack.DeferredDeduction; Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack); } if (Result.isNull()) { Info.Param = makeTemplateParameter(TemplateParams->getParam(Pack.Index)); Info.FirstArg = OldPack; Info.SecondArg = NewPack; return Sema::TDK_Inconsistent; } *Loc = Result; } return Sema::TDK_Success; } private: Sema &S; TemplateParameterList *TemplateParams; SmallVectorImpl &Deduced; TemplateDeductionInfo &Info; SmallVector Packs; }; /// \brief Deduce the template arguments by comparing the list of parameter /// types to the list of argument types, as in the parameter-type-lists of /// function types (C++ [temp.deduct.type]p10). /// /// \param S The semantic analysis object within which we are deducing /// /// \param TemplateParams The template parameters that we are deducing /// /// \param Params The list of parameter types /// /// \param NumParams The number of types in \c Params /// /// \param Args The list of argument types /// /// \param NumArgs The number of types in \c Args /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe /// how template argument deduction is performed. /// /// \param PartialOrdering If true, we are performing template argument /// deduction for during partial ordering for a call /// (C++0x [temp.deduct.partial]). /// /// \param RefParamComparisons If we're performing template argument deduction /// in the context of partial ordering, the set of qualifier comparisons. /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const QualType *Params, unsigned NumParams, const QualType *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF, bool PartialOrdering = false, SmallVectorImpl * RefParamComparisons = nullptr) { // Fast-path check to see if we have too many/too few arguments. if (NumParams != NumArgs && !(NumParams && isa(Params[NumParams - 1])) && !(NumArgs && isa(Args[NumArgs - 1]))) return Sema::TDK_MiscellaneousDeductionFailure; // C++0x [temp.deduct.type]p10: // Similarly, if P has a form that contains (T), then each parameter type // Pi of the respective parameter-type- list of P is compared with the // corresponding parameter type Ai of the corresponding parameter-type-list // of A. [...] unsigned ArgIdx = 0, ParamIdx = 0; for (; ParamIdx != NumParams; ++ParamIdx) { // Check argument types. const PackExpansionType *Expansion = dyn_cast(Params[ParamIdx]); if (!Expansion) { // Simple case: compare the parameter and argument types at this point. // Make sure we have an argument. if (ArgIdx >= NumArgs) return Sema::TDK_MiscellaneousDeductionFailure; if (isa(Args[ArgIdx])) { // C++0x [temp.deduct.type]p22: // If the original function parameter associated with A is a function // parameter pack and the function parameter associated with P is not // a function parameter pack, then template argument deduction fails. return Sema::TDK_MiscellaneousDeductionFailure; } if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Params[ParamIdx], Args[ArgIdx], Info, Deduced, TDF, PartialOrdering, RefParamComparisons)) return Result; ++ArgIdx; continue; } // C++0x [temp.deduct.type]p5: // The non-deduced contexts are: // - A function parameter pack that does not occur at the end of the // parameter-declaration-clause. if (ParamIdx + 1 < NumParams) return Sema::TDK_Success; // C++0x [temp.deduct.type]p10: // If the parameter-declaration corresponding to Pi is a function // parameter pack, then the type of its declarator- id is compared with // each remaining parameter type in the parameter-type-list of A. Each // comparison deduces template arguments for subsequent positions in the // template parameter packs expanded by the function parameter pack. QualType Pattern = Expansion->getPattern(); PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); bool HasAnyArguments = false; for (; ArgIdx < NumArgs; ++ArgIdx) { HasAnyArguments = true; // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced, TDF, PartialOrdering, RefParamComparisons)) return Result; PackScope.nextPackElement(); } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (auto Result = PackScope.finish(HasAnyArguments)) return Result; } // Make sure we don't have any extra arguments. if (ArgIdx < NumArgs) return Sema::TDK_MiscellaneousDeductionFailure; return Sema::TDK_Success; } /// \brief Determine whether the parameter has qualifiers that are either /// inconsistent with or a superset of the argument's qualifiers. static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, QualType ArgType) { Qualifiers ParamQs = ParamType.getQualifiers(); Qualifiers ArgQs = ArgType.getQualifiers(); if (ParamQs == ArgQs) return false; // Mismatched (but not missing) Objective-C GC attributes. if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && ParamQs.hasObjCGCAttr()) return true; // Mismatched (but not missing) address spaces. if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() && ParamQs.hasAddressSpace()) return true; // Mismatched (but not missing) Objective-C lifetime qualifiers. if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() && ParamQs.hasObjCLifetime()) return true; // CVR qualifier superset. return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) && ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers()) == ParamQs.getCVRQualifiers()); } /// \brief Compare types for equality with respect to possibly compatible /// function types (noreturn adjustment, implicit calling conventions). If any /// of parameter and argument is not a function, just perform type comparison. /// /// \param Param the template parameter type. /// /// \param Arg the argument type. bool Sema::isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg) { const FunctionType *ParamFunction = Param->getAs(), *ArgFunction = Arg->getAs(); // Just compare if not functions. if (!ParamFunction || !ArgFunction) return Param == Arg; // Noreturn adjustment. QualType AdjustedParam; if (IsNoReturnConversion(Param, Arg, AdjustedParam)) return Arg == Context.getCanonicalType(AdjustedParam); // FIXME: Compatible calling conventions. return Param == Arg; } /// \brief Deduce the template arguments by comparing the parameter type and /// the argument type (C++ [temp.deduct.type]). /// /// \param S the semantic analysis object within which we are deducing /// /// \param TemplateParams the template parameters that we are deducing /// /// \param ParamIn the parameter type /// /// \param ArgIn the argument type /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe /// how template argument deduction is performed. /// /// \param PartialOrdering Whether we're performing template argument deduction /// in the context of partial ordering (C++0x [temp.deduct.partial]). /// /// \param RefParamComparisons If we're performing template argument deduction /// in the context of partial ordering, the set of qualifier comparisons. /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType ParamIn, QualType ArgIn, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF, bool PartialOrdering, SmallVectorImpl * RefParamComparisons) { // We only want to look at the canonical types, since typedefs and // sugar are not part of template argument deduction. QualType Param = S.Context.getCanonicalType(ParamIn); QualType Arg = S.Context.getCanonicalType(ArgIn); // If the argument type is a pack expansion, look at its pattern. // This isn't explicitly called out if (const PackExpansionType *ArgExpansion = dyn_cast(Arg)) Arg = ArgExpansion->getPattern(); if (PartialOrdering) { // C++0x [temp.deduct.partial]p5: // Before the partial ordering is done, certain transformations are // performed on the types used for partial ordering: // - If P is a reference type, P is replaced by the type referred to. const ReferenceType *ParamRef = Param->getAs(); if (ParamRef) Param = ParamRef->getPointeeType(); // - If A is a reference type, A is replaced by the type referred to. const ReferenceType *ArgRef = Arg->getAs(); if (ArgRef) Arg = ArgRef->getPointeeType(); if (RefParamComparisons && ParamRef && ArgRef) { // C++0x [temp.deduct.partial]p6: // If both P and A were reference types (before being replaced with the // type referred to above), determine which of the two types (if any) is // more cv-qualified than the other; otherwise the types are considered // to be equally cv-qualified for partial ordering purposes. The result // of this determination will be used below. // // We save this information for later, using it only when deduction // succeeds in both directions. RefParamPartialOrderingComparison Comparison; Comparison.ParamIsRvalueRef = ParamRef->getAs(); Comparison.ArgIsRvalueRef = ArgRef->getAs(); Comparison.Qualifiers = NeitherMoreQualified; Qualifiers ParamQuals = Param.getQualifiers(); Qualifiers ArgQuals = Arg.getQualifiers(); if (ParamQuals.isStrictSupersetOf(ArgQuals)) Comparison.Qualifiers = ParamMoreQualified; else if (ArgQuals.isStrictSupersetOf(ParamQuals)) Comparison.Qualifiers = ArgMoreQualified; else if (ArgQuals.getObjCLifetime() != ParamQuals.getObjCLifetime() && ArgQuals.withoutObjCLifetime() == ParamQuals.withoutObjCLifetime()) { // Prefer binding to non-__unsafe_autoretained parameters. if (ArgQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && ParamQuals.getObjCLifetime()) Comparison.Qualifiers = ParamMoreQualified; else if (ParamQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && ArgQuals.getObjCLifetime()) Comparison.Qualifiers = ArgMoreQualified; } RefParamComparisons->push_back(Comparison); } // C++0x [temp.deduct.partial]p7: // Remove any top-level cv-qualifiers: // - If P is a cv-qualified type, P is replaced by the cv-unqualified // version of P. Param = Param.getUnqualifiedType(); // - If A is a cv-qualified type, A is replaced by the cv-unqualified // version of A. Arg = Arg.getUnqualifiedType(); } else { // C++0x [temp.deduct.call]p4 bullet 1: // - If the original P is a reference type, the deduced A (i.e., the type // referred to by the reference) can be more cv-qualified than the // transformed A. if (TDF & TDF_ParamWithReferenceType) { Qualifiers Quals; QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); Quals.setCVRQualifiers(Quals.getCVRQualifiers() & Arg.getCVRQualifiers()); Param = S.Context.getQualifiedType(UnqualParam, Quals); } if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) { // C++0x [temp.deduct.type]p10: // If P and A are function types that originated from deduction when // taking the address of a function template (14.8.2.2) or when deducing // template arguments from a function declaration (14.8.2.6) and Pi and // Ai are parameters of the top-level parameter-type-list of P and A, // respectively, Pi is adjusted if it is an rvalue reference to a // cv-unqualified template parameter and Ai is an lvalue reference, in // which case the type of Pi is changed to be the template parameter // type (i.e., T&& is changed to simply T). [ Note: As a result, when // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be // deduced as X&. - end note ] TDF &= ~TDF_TopLevelParameterTypeList; if (const RValueReferenceType *ParamRef = Param->getAs()) { if (isa(ParamRef->getPointeeType()) && !ParamRef->getPointeeType().getQualifiers()) if (Arg->isLValueReferenceType()) Param = ParamRef->getPointeeType(); } } } // C++ [temp.deduct.type]p9: // A template type argument T, a template template argument TT or a // template non-type argument i can be deduced if P and A have one of // the following forms: // // T // cv-list T if (const TemplateTypeParmType *TemplateTypeParm = Param->getAs()) { // Just skip any attempts to deduce from a placeholder type. if (Arg->isPlaceholderType()) return Sema::TDK_Success; unsigned Index = TemplateTypeParm->getIndex(); bool RecanonicalizeArg = false; // If the argument type is an array type, move the qualifiers up to the // top level, so they can be matched with the qualifiers on the parameter. if (isa(Arg)) { Qualifiers Quals; Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); if (Quals) { Arg = S.Context.getQualifiedType(Arg, Quals); RecanonicalizeArg = true; } } // The argument type can not be less qualified than the parameter // type. if (!(TDF & TDF_IgnoreQualifiers) && hasInconsistentOrSupersetQualifiersOf(Param, Arg)) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_Underqualified; } assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function"); QualType DeducedType = Arg; // Remove any qualifiers on the parameter from the deduced type. // We checked the qualifiers for consistency above. Qualifiers DeducedQs = DeducedType.getQualifiers(); Qualifiers ParamQs = Param.getQualifiers(); DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers()); if (ParamQs.hasObjCGCAttr()) DeducedQs.removeObjCGCAttr(); if (ParamQs.hasAddressSpace()) DeducedQs.removeAddressSpace(); if (ParamQs.hasObjCLifetime()) DeducedQs.removeObjCLifetime(); // Objective-C ARC: // If template deduction would produce a lifetime qualifier on a type // that is not a lifetime type, template argument deduction fails. if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() && !DeducedType->isDependentType()) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_Underqualified; } // Objective-C ARC: // If template deduction would produce an argument type with lifetime type // but no lifetime qualifier, the __strong lifetime qualifier is inferred. if (S.getLangOpts().ObjCAutoRefCount && DeducedType->isObjCLifetimeType() && !DeducedQs.hasObjCLifetime()) DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong); DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(), DeducedQs); if (RecanonicalizeArg) DeducedType = S.Context.getCanonicalType(DeducedType); DeducedTemplateArgument NewDeduced(DeducedType); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[Index], NewDeduced); if (Result.isNull()) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = Deduced[Index]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[Index] = Result; return Sema::TDK_Success; } // Set up the template argument deduction information for a failure. Info.FirstArg = TemplateArgument(ParamIn); Info.SecondArg = TemplateArgument(ArgIn); // If the parameter is an already-substituted template parameter // pack, do nothing: we don't know which of its arguments to look // at, so we have to wait until all of the parameter packs in this // expansion have arguments. if (isa(Param)) return Sema::TDK_Success; // Check the cv-qualifiers on the parameter and argument types. CanQualType CanParam = S.Context.getCanonicalType(Param); CanQualType CanArg = S.Context.getCanonicalType(Arg); if (!(TDF & TDF_IgnoreQualifiers)) { if (TDF & TDF_ParamWithReferenceType) { if (hasInconsistentOrSupersetQualifiersOf(Param, Arg)) return Sema::TDK_NonDeducedMismatch; } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) return Sema::TDK_NonDeducedMismatch; } // If the parameter type is not dependent, there is nothing to deduce. if (!Param->isDependentType()) { if (!(TDF & TDF_SkipNonDependent)) { bool NonDeduced = (TDF & TDF_InOverloadResolution)? !S.isSameOrCompatibleFunctionType(CanParam, CanArg) : Param != Arg; if (NonDeduced) { return Sema::TDK_NonDeducedMismatch; } } return Sema::TDK_Success; } } else if (!Param->isDependentType()) { CanQualType ParamUnqualType = CanParam.getUnqualifiedType(), ArgUnqualType = CanArg.getUnqualifiedType(); bool Success = (TDF & TDF_InOverloadResolution)? S.isSameOrCompatibleFunctionType(ParamUnqualType, ArgUnqualType) : ParamUnqualType == ArgUnqualType; if (Success) return Sema::TDK_Success; } switch (Param->getTypeClass()) { // Non-canonical types cannot appear here. #define NON_CANONICAL_TYPE(Class, Base) \ case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class); #define TYPE(Class, Base) #include "clang/AST/TypeNodes.def" case Type::TemplateTypeParm: case Type::SubstTemplateTypeParmPack: llvm_unreachable("Type nodes handled above"); // These types cannot be dependent, so simply check whether the types are // the same. case Type::Builtin: case Type::VariableArray: case Type::Vector: case Type::FunctionNoProto: case Type::Record: case Type::Enum: case Type::ObjCObject: case Type::ObjCInterface: case Type::ObjCObjectPointer: { if (TDF & TDF_SkipNonDependent) return Sema::TDK_Success; if (TDF & TDF_IgnoreQualifiers) { Param = Param.getUnqualifiedType(); Arg = Arg.getUnqualifiedType(); } return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch; } // _Complex T [placeholder extension] case Type::Complex: if (const ComplexType *ComplexArg = Arg->getAs()) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getElementType(), ComplexArg->getElementType(), Info, Deduced, TDF); return Sema::TDK_NonDeducedMismatch; // _Atomic T [extension] case Type::Atomic: if (const AtomicType *AtomicArg = Arg->getAs()) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getValueType(), AtomicArg->getValueType(), Info, Deduced, TDF); return Sema::TDK_NonDeducedMismatch; // T * case Type::Pointer: { QualType PointeeType; if (const PointerType *PointerArg = Arg->getAs()) { PointeeType = PointerArg->getPointeeType(); } else if (const ObjCObjectPointerType *PointerArg = Arg->getAs()) { PointeeType = PointerArg->getPointeeType(); } else { return Sema::TDK_NonDeducedMismatch; } unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), PointeeType, Info, Deduced, SubTDF); } // T & case Type::LValueReference: { const LValueReferenceType *ReferenceArg = Arg->getAs(); if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), ReferenceArg->getPointeeType(), Info, Deduced, 0); } // T && [C++0x] case Type::RValueReference: { const RValueReferenceType *ReferenceArg = Arg->getAs(); if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), ReferenceArg->getPointeeType(), Info, Deduced, 0); } // T [] (implied, but not stated explicitly) case Type::IncompleteArray: { const IncompleteArrayType *IncompleteArrayArg = S.Context.getAsIncompleteArrayType(Arg); if (!IncompleteArrayArg) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, S.Context.getAsIncompleteArrayType(Param)->getElementType(), IncompleteArrayArg->getElementType(), Info, Deduced, SubTDF); } // T [integer-constant] case Type::ConstantArray: { const ConstantArrayType *ConstantArrayArg = S.Context.getAsConstantArrayType(Arg); if (!ConstantArrayArg) return Sema::TDK_NonDeducedMismatch; const ConstantArrayType *ConstantArrayParm = S.Context.getAsConstantArrayType(Param); if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ConstantArrayParm->getElementType(), ConstantArrayArg->getElementType(), Info, Deduced, SubTDF); } // type [i] case Type::DependentSizedArray: { const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); if (!ArrayArg) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; // Check the element type of the arrays const DependentSizedArrayType *DependentArrayParm = S.Context.getAsDependentSizedArrayType(Param); if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, DependentArrayParm->getElementType(), ArrayArg->getElementType(), Info, Deduced, SubTDF)) return Result; // Determine the array bound is something we can deduce. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; // We can perform template argument deduction for the given non-type // template parameter. assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument at depth > 0"); if (const ConstantArrayType *ConstantArrayArg = dyn_cast(ArrayArg)) { llvm::APSInt Size(ConstantArrayArg->getSize()); return DeduceNonTypeTemplateArgument(S, NTTP, Size, S.Context.getSizeType(), /*ArrayBound=*/true, Info, Deduced); } if (const DependentSizedArrayType *DependentArrayArg = dyn_cast(ArrayArg)) if (DependentArrayArg->getSizeExpr()) return DeduceNonTypeTemplateArgument(S, NTTP, DependentArrayArg->getSizeExpr(), Info, Deduced); // Incomplete type does not match a dependently-sized array type return Sema::TDK_NonDeducedMismatch; } // type(*)(T) // T(*)() // T(*)(T) case Type::FunctionProto: { unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList; const FunctionProtoType *FunctionProtoArg = dyn_cast(Arg); if (!FunctionProtoArg) return Sema::TDK_NonDeducedMismatch; const FunctionProtoType *FunctionProtoParam = cast(Param); if (FunctionProtoParam->getTypeQuals() != FunctionProtoArg->getTypeQuals() || FunctionProtoParam->getRefQualifier() != FunctionProtoArg->getRefQualifier() || FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) return Sema::TDK_NonDeducedMismatch; // Check return types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, FunctionProtoParam->getReturnType(), FunctionProtoArg->getReturnType(), Info, Deduced, 0)) return Result; return DeduceTemplateArguments( S, TemplateParams, FunctionProtoParam->param_type_begin(), FunctionProtoParam->getNumParams(), FunctionProtoArg->param_type_begin(), FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF); } case Type::InjectedClassName: { // Treat a template's injected-class-name as if the template // specialization type had been used. Param = cast(Param) ->getInjectedSpecializationType(); assert(isa(Param) && "injected class name is not a template specialization type"); // fall through } // template-name (where template-name refers to a class template) // template-name // TT // TT // TT<> case Type::TemplateSpecialization: { const TemplateSpecializationType *SpecParam = cast(Param); // Try to deduce template arguments from the template-id. Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info, Deduced); if (Result && (TDF & TDF_DerivedClass)) { // C++ [temp.deduct.call]p3b3: // If P is a class, and P has the form template-id, then A can be a // derived class of the deduced A. Likewise, if P is a pointer to a // class of the form template-id, A can be a pointer to a derived // class pointed to by the deduced A. // // More importantly: // These alternatives are considered only if type deduction would // otherwise fail. if (const RecordType *RecordT = Arg->getAs()) { // We cannot inspect base classes as part of deduction when the type // is incomplete, so either instantiate any templates necessary to // complete the type, or skip over it if it cannot be completed. if (S.RequireCompleteType(Info.getLocation(), Arg, 0)) return Result; // Use data recursion to crawl through the list of base classes. // Visited contains the set of nodes we have already visited, while // ToVisit is our stack of records that we still need to visit. llvm::SmallPtrSet Visited; SmallVector ToVisit; ToVisit.push_back(RecordT); bool Successful = false; SmallVector DeducedOrig(Deduced.begin(), Deduced.end()); while (!ToVisit.empty()) { // Retrieve the next class in the inheritance hierarchy. const RecordType *NextT = ToVisit.pop_back_val(); // If we have already seen this type, skip it. if (!Visited.insert(NextT)) continue; // If this is a base class, try to perform template argument // deduction from it. if (NextT != RecordT) { TemplateDeductionInfo BaseInfo(Info.getLocation()); Sema::TemplateDeductionResult BaseResult = DeduceTemplateArguments(S, TemplateParams, SpecParam, QualType(NextT, 0), BaseInfo, Deduced); // If template argument deduction for this base was successful, // note that we had some success. Otherwise, ignore any deductions // from this base class. if (BaseResult == Sema::TDK_Success) { Successful = true; DeducedOrig.clear(); DeducedOrig.append(Deduced.begin(), Deduced.end()); Info.Param = BaseInfo.Param; Info.FirstArg = BaseInfo.FirstArg; Info.SecondArg = BaseInfo.SecondArg; } else Deduced = DeducedOrig; } // Visit base classes CXXRecordDecl *Next = cast(NextT->getDecl()); for (const auto &Base : Next->bases()) { assert(Base.getType()->isRecordType() && "Base class that isn't a record?"); ToVisit.push_back(Base.getType()->getAs()); } } if (Successful) return Sema::TDK_Success; } } return Result; } // T type::* // T T::* // T (type::*)() // type (T::*)() // type (type::*)(T) // type (T::*)(T) // T (type::*)(T) // T (T::*)() // T (T::*)(T) case Type::MemberPointer: { const MemberPointerType *MemPtrParam = cast(Param); const MemberPointerType *MemPtrArg = dyn_cast(Arg); if (!MemPtrArg) return Sema::TDK_NonDeducedMismatch; if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, MemPtrParam->getPointeeType(), MemPtrArg->getPointeeType(), Info, Deduced, TDF & TDF_IgnoreQualifiers)) return Result; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, QualType(MemPtrParam->getClass(), 0), QualType(MemPtrArg->getClass(), 0), Info, Deduced, TDF & TDF_IgnoreQualifiers); } // (clang extension) // // type(^)(T) // T(^)() // T(^)(T) case Type::BlockPointer: { const BlockPointerType *BlockPtrParam = cast(Param); const BlockPointerType *BlockPtrArg = dyn_cast(Arg); if (!BlockPtrArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, BlockPtrParam->getPointeeType(), BlockPtrArg->getPointeeType(), Info, Deduced, 0); } // (clang extension) // // T __attribute__(((ext_vector_type()))) case Type::ExtVector: { const ExtVectorType *VectorParam = cast(Param); if (const ExtVectorType *VectorArg = dyn_cast(Arg)) { // Make sure that the vectors have the same number of elements. if (VectorParam->getNumElements() != VectorArg->getNumElements()) return Sema::TDK_NonDeducedMismatch; // Perform deduction on the element types. return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF); } if (const DependentSizedExtVectorType *VectorArg = dyn_cast(Arg)) { // We can't check the number of elements, since the argument has a // dependent number of elements. This can only occur during partial // ordering. // Perform deduction on the element types. return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF); } return Sema::TDK_NonDeducedMismatch; } // (clang extension) // // T __attribute__(((ext_vector_type(N)))) case Type::DependentSizedExtVector: { const DependentSizedExtVectorType *VectorParam = cast(Param); if (const ExtVectorType *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); ArgSize = VectorArg->getNumElements(); return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy, false, Info, Deduced); } if (const DependentSizedExtVectorType *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(), Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } case Type::TypeOfExpr: case Type::TypeOf: case Type::DependentName: case Type::UnresolvedUsing: case Type::Decltype: case Type::UnaryTransform: case Type::Auto: case Type::DependentTemplateSpecialization: case Type::PackExpansion: // No template argument deduction for these types return Sema::TDK_Success; } llvm_unreachable("Invalid Type Class!"); } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { // If the template argument is a pack expansion, perform template argument // deduction against the pattern of that expansion. This only occurs during // partial ordering. if (Arg.isPackExpansion()) Arg = Arg.getPackExpansionPattern(); switch (Param.getKind()) { case TemplateArgument::Null: llvm_unreachable("Null template argument in parameter list"); case TemplateArgument::Type: if (Arg.getKind() == TemplateArgument::Type) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Param.getAsType(), Arg.getAsType(), Info, Deduced, 0); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Template: if (Arg.getKind() == TemplateArgument::Template) return DeduceTemplateArguments(S, TemplateParams, Param.getAsTemplate(), Arg.getAsTemplate(), Info, Deduced); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::TemplateExpansion: llvm_unreachable("caller should handle pack expansions"); case TemplateArgument::Declaration: if (Arg.getKind() == TemplateArgument::Declaration && isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) && Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam()) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::NullPtr: if (Arg.getKind() == TemplateArgument::NullPtr && S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType())) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Integral: if (Arg.getKind() == TemplateArgument::Integral) { if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral())) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } if (Arg.getKind() == TemplateArgument::Expression) { Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Expression: { if (NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(Param.getAsExpr())) { if (Arg.getKind() == TemplateArgument::Integral) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsIntegral(), Arg.getIntegralType(), /*ArrayBound=*/false, Info, Deduced); if (Arg.getKind() == TemplateArgument::Expression) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(), Info, Deduced); if (Arg.getKind() == TemplateArgument::Declaration) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(), Info, Deduced); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } // Can't deduce anything, but that's okay. return Sema::TDK_Success; } case TemplateArgument::Pack: llvm_unreachable("Argument packs should be expanded by the caller!"); } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Determine whether there is a template argument to be used for /// deduction. /// /// This routine "expands" argument packs in-place, overriding its input /// parameters so that \c Args[ArgIdx] will be the available template argument. /// /// \returns true if there is another template argument (which will be at /// \c Args[ArgIdx]), false otherwise. static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args, unsigned &ArgIdx, unsigned &NumArgs) { if (ArgIdx == NumArgs) return false; const TemplateArgument &Arg = Args[ArgIdx]; if (Arg.getKind() != TemplateArgument::Pack) return true; assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?"); Args = Arg.pack_begin(); NumArgs = Arg.pack_size(); ArgIdx = 0; return ArgIdx < NumArgs; } /// \brief Determine whether the given set of template arguments has a pack /// expansion that is not the last template argument. static bool hasPackExpansionBeforeEnd(const TemplateArgument *Args, unsigned NumArgs) { unsigned ArgIdx = 0; while (ArgIdx < NumArgs) { const TemplateArgument &Arg = Args[ArgIdx]; // Unwrap argument packs. if (Args[ArgIdx].getKind() == TemplateArgument::Pack) { Args = Arg.pack_begin(); NumArgs = Arg.pack_size(); ArgIdx = 0; continue; } ++ArgIdx; if (ArgIdx == NumArgs) return false; if (Arg.isPackExpansion()) return true; } return false; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument *Params, unsigned NumParams, const TemplateArgument *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (hasPackExpansionBeforeEnd(Params, NumParams)) return Sema::TDK_Success; // C++0x [temp.deduct.type]p9: // If P has a form that contains or , then each argument Pi of the // respective template argument list P is compared with the corresponding // argument Ai of the corresponding template argument list of A. unsigned ArgIdx = 0, ParamIdx = 0; for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); ++ParamIdx) { if (!Params[ParamIdx].isPackExpansion()) { // The simple case: deduce template arguments by matching Pi and Ai. // Check whether we have enough arguments. if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) return Sema::TDK_Success; if (Args[ArgIdx].isPackExpansion()) { // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here, // but applied to pack expansions that are template arguments. return Sema::TDK_MiscellaneousDeductionFailure; } // Perform deduction for this Pi/Ai pair. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Params[ParamIdx], Args[ArgIdx], Info, Deduced)) return Result; // Move to the next argument. ++ArgIdx; continue; } // The parameter is a pack expansion. // C++0x [temp.deduct.type]p9: // If Pi is a pack expansion, then the pattern of Pi is compared with // each remaining argument in the template argument list of A. Each // comparison deduces template arguments for subsequent positions in the // template parameter packs expanded by Pi. TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); // FIXME: If there are no remaining arguments, we can bail out early // and set any deduced parameter packs to an empty argument pack. // The latter part of this is a (minor) correctness issue. // Prepare to deduce the packs within the pattern. PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); // Keep track of the deduced template arguments for each parameter pack // expanded by this pack expansion (the outer index) and for each // template argument (the inner SmallVectors). bool HasAnyArguments = false; for (; hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs); ++ArgIdx) { HasAnyArguments = true; // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced)) return Result; PackScope.nextPackElement(); } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (auto Result = PackScope.finish(HasAnyArguments)) return Result; } return Sema::TDK_Success; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgumentList &ParamList, const TemplateArgumentList &ArgList, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { return DeduceTemplateArguments(S, TemplateParams, ParamList.data(), ParamList.size(), ArgList.data(), ArgList.size(), Info, Deduced); } /// \brief Determine whether two template arguments are the same. static bool isSameTemplateArg(ASTContext &Context, const TemplateArgument &X, const TemplateArgument &Y) { if (X.getKind() != Y.getKind()) return false; switch (X.getKind()) { case TemplateArgument::Null: llvm_unreachable("Comparing NULL template argument"); case TemplateArgument::Type: return Context.getCanonicalType(X.getAsType()) == Context.getCanonicalType(Y.getAsType()); case TemplateArgument::Declaration: return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && X.isDeclForReferenceParam() == Y.isDeclForReferenceParam(); case TemplateArgument::NullPtr: return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()); case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: return Context.getCanonicalTemplateName( X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == Context.getCanonicalTemplateName( Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); case TemplateArgument::Integral: return X.getAsIntegral() == Y.getAsIntegral(); case TemplateArgument::Expression: { llvm::FoldingSetNodeID XID, YID; X.getAsExpr()->Profile(XID, Context, true); Y.getAsExpr()->Profile(YID, Context, true); return XID == YID; } case TemplateArgument::Pack: if (X.pack_size() != Y.pack_size()) return false; for (TemplateArgument::pack_iterator XP = X.pack_begin(), XPEnd = X.pack_end(), YP = Y.pack_begin(); XP != XPEnd; ++XP, ++YP) if (!isSameTemplateArg(Context, *XP, *YP)) return false; return true; } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Allocate a TemplateArgumentLoc where all locations have /// been initialized to the given location. /// /// \param S The semantic analysis object. /// /// \param Arg The template argument we are producing template argument /// location information for. /// /// \param NTTPType For a declaration template argument, the type of /// the non-type template parameter that corresponds to this template /// argument. /// /// \param Loc The source location to use for the resulting template /// argument. static TemplateArgumentLoc getTrivialTemplateArgumentLoc(Sema &S, const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc) { switch (Arg.getKind()) { case TemplateArgument::Null: llvm_unreachable("Can't get a NULL template argument here"); case TemplateArgument::Type: return TemplateArgumentLoc(Arg, S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); case TemplateArgument::Declaration: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .getAs(); return TemplateArgumentLoc(TemplateArgument(E), E); } case TemplateArgument::NullPtr: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .getAs(); return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true), E); } case TemplateArgument::Integral: { Expr *E = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs(); return TemplateArgumentLoc(TemplateArgument(E), E); } case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: { NestedNameSpecifierLocBuilder Builder; TemplateName Template = Arg.getAsTemplate(); if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc); else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc); if (Arg.getKind() == TemplateArgument::Template) return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), Loc); return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), Loc, Loc); } case TemplateArgument::Expression: return TemplateArgumentLoc(Arg, Arg.getAsExpr()); case TemplateArgument::Pack: return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Convert the given deduced template argument and add it to the set of /// fully-converted template arguments. static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, DeducedTemplateArgument Arg, NamedDecl *Template, QualType NTTPType, unsigned ArgumentPackIndex, TemplateDeductionInfo &Info, bool InFunctionTemplate, SmallVectorImpl &Output) { if (Arg.getKind() == TemplateArgument::Pack) { // This is a template argument pack, so check each of its arguments against // the template parameter. SmallVector PackedArgsBuilder; for (const auto &P : Arg.pack_elements()) { // When converting the deduced template argument, append it to the // general output list. We need to do this so that the template argument // checking logic has all of the prior template arguments available. DeducedTemplateArgument InnerArg(P); InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, NTTPType, PackedArgsBuilder.size(), Info, InFunctionTemplate, Output)) return true; // Move the converted template argument into our argument pack. PackedArgsBuilder.push_back(Output.pop_back_val()); } // Create the resulting argument pack. Output.push_back(TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder.data(), PackedArgsBuilder.size())); return false; } // Convert the deduced template argument into a template // argument that we can check, almost as if the user had written // the template argument explicitly. TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType, Info.getLocation()); // Check the template argument, converting it as necessary. return S.CheckTemplateArgument(Param, ArgLoc, Template, Template->getLocation(), Template->getSourceRange().getEnd(), ArgumentPackIndex, Output, InFunctionTemplate ? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound : Sema::CTAK_Deduced) : Sema::CTAK_Specified); } /// Complete template argument deduction for a class template partial /// specialization. static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(Sema &S, ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); Sema::ContextRAII SavedContext(S, Partial); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; TemplateParameterList *PartialParams = Partial->getTemplateParameters(); for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { NamedDecl *Param = PartialParams->getParam(I); if (Deduced[I].isNull()) { Info.Param = makeTemplateParameter(Param); return Sema::TDK_Incomplete; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType, 0, Info, false, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the template // arguments of the class template partial specialization, and // verify that the instantiated template arguments are both valid // and are equivalent to the template arguments originally provided // to the class template. LocalInstantiationScope InstScope(S); ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); const ASTTemplateArgumentListInfo *PartialTemplArgInfo = Partial->getTemplateArgsAsWritten(); const TemplateArgumentLoc *PartialTemplateArgs = PartialTemplArgInfo->getTemplateArgs(); TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc, PartialTemplArgInfo->RAngleLoc); if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs, InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; if (ParamIdx >= Partial->getTemplateParameters()->size()) ParamIdx = Partial->getTemplateParameters()->size() - 1; Decl *Param = const_cast( Partial->getTemplateParameters()->getParam(ParamIdx)); Info.Param = makeTemplateParameter(Param); Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); return Sema::TDK_SubstitutionFailure; } SmallVector ConvertedInstArgs; if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(), InstArgs, false, ConvertedInstArgs)) return Sema::TDK_SubstitutionFailure; TemplateParameterList *TemplateParams = ClassTemplate->getTemplateParameters(); for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { TemplateArgument InstArg = ConvertedInstArgs.data()[I]; if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); Info.FirstArg = TemplateArgs[I]; Info.SecondArg = InstArg; return Sema::TDK_NonDeducedMismatch; } } if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return Sema::TDK_Success; } /// \brief Perform template argument deduction to determine whether /// the given template arguments match the given class template /// partial specialization per C++ [temp.class.spec.match]. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, TemplateDeductionInfo &Info) { if (Partial->isInvalidDecl()) return TDK_Invalid; // C++ [temp.class.spec.match]p2: // A partial specialization matches a given actual template // argument list if the template arguments of the partial // specialization can be deduced from the actual template argument // list (14.8.2). // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); SmallVector Deduced; Deduced.resize(Partial->getTemplateParameters()->size()); if (TemplateDeductionResult Result = ::DeduceTemplateArguments(*this, Partial->getTemplateParameters(), Partial->getTemplateArgs(), TemplateArgs, Info, Deduced)) return Result; SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, Deduced, Info); } /// Complete template argument deduction for a variable template partial /// specialization. /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( Sema &S, VarTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; TemplateParameterList *PartialParams = Partial->getTemplateParameters(); for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { NamedDecl *Param = PartialParams->getParam(I); if (Deduced[I].isNull()) { Info.Param = makeTemplateParameter(Param); return Sema::TDK_Incomplete; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType, 0, Info, false, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy( S.Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the template // arguments of the class template partial specialization, and // verify that the instantiated template arguments are both valid // and are equivalent to the template arguments originally provided // to the class template. LocalInstantiationScope InstScope(S); VarTemplateDecl *VarTemplate = Partial->getSpecializedTemplate(); const ASTTemplateArgumentListInfo *PartialTemplArgInfo = Partial->getTemplateArgsAsWritten(); const TemplateArgumentLoc *PartialTemplateArgs = PartialTemplArgInfo->getTemplateArgs(); TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc, PartialTemplArgInfo->RAngleLoc); if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs, InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; if (ParamIdx >= Partial->getTemplateParameters()->size()) ParamIdx = Partial->getTemplateParameters()->size() - 1; Decl *Param = const_cast( Partial->getTemplateParameters()->getParam(ParamIdx)); Info.Param = makeTemplateParameter(Param); Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); return Sema::TDK_SubstitutionFailure; } SmallVector ConvertedInstArgs; if (S.CheckTemplateArgumentList(VarTemplate, Partial->getLocation(), InstArgs, false, ConvertedInstArgs)) return Sema::TDK_SubstitutionFailure; TemplateParameterList *TemplateParams = VarTemplate->getTemplateParameters(); for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { TemplateArgument InstArg = ConvertedInstArgs.data()[I]; if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); Info.FirstArg = TemplateArgs[I]; Info.SecondArg = InstArg; return Sema::TDK_NonDeducedMismatch; } } if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return Sema::TDK_Success; } /// \brief Perform template argument deduction to determine whether /// the given template arguments match the given variable template /// partial specialization per C++ [temp.class.spec.match]. /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, TemplateDeductionInfo &Info) { if (Partial->isInvalidDecl()) return TDK_Invalid; // C++ [temp.class.spec.match]p2: // A partial specialization matches a given actual template // argument list if the template arguments of the partial // specialization can be deduced from the actual template argument // list (14.8.2). // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); SmallVector Deduced; Deduced.resize(Partial->getTemplateParameters()->size()); if (TemplateDeductionResult Result = ::DeduceTemplateArguments( *this, Partial->getTemplateParameters(), Partial->getTemplateArgs(), TemplateArgs, Info, Deduced)) return Result; SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, Deduced, Info); } /// \brief Determine whether the given type T is a simple-template-id type. static bool isSimpleTemplateIdType(QualType T) { if (const TemplateSpecializationType *Spec = T->getAs()) return Spec->getTemplateName().getAsTemplateDecl() != nullptr; return false; } /// \brief Substitute the explicitly-provided template arguments into the /// given function template according to C++ [temp.arg.explicit]. /// /// \param FunctionTemplate the function template into which the explicit /// template arguments will be substituted. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param Deduced the deduced template arguments, which will be populated /// with the converted and checked explicit template arguments. /// /// \param ParamTypes will be populated with the instantiated function /// parameters. /// /// \param FunctionType if non-NULL, the result type of the function template /// will also be instantiated and the pointed-to value will be updated with /// the instantiated function type. /// /// \param Info if substitution fails for any reason, this object will be /// populated with more information about the failure. /// /// \returns TDK_Success if substitution was successful, or some failure /// condition. Sema::TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo &ExplicitTemplateArgs, SmallVectorImpl &Deduced, SmallVectorImpl &ParamTypes, QualType *FunctionType, TemplateDeductionInfo &Info) { FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); if (ExplicitTemplateArgs.size() == 0) { // No arguments to substitute; just copy over the parameter types and // fill in the function type. for (auto P : Function->params()) ParamTypes.push_back(P->getType()); if (FunctionType) *FunctionType = Function->getType(); return TDK_Success; } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // C++ [temp.arg.explicit]p3: // Template arguments that are present shall be specified in the // declaration order of their corresponding template-parameters. The // template argument list shall not specify more template-arguments than // there are corresponding template-parameters. SmallVector Builder; // Enter a new template instantiation context where we check the // explicitly-specified template arguments against this function template, // and then substitute them into the function parameter types. SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate, DeducedArgs, ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (CheckTemplateArgumentList(FunctionTemplate, SourceLocation(), ExplicitTemplateArgs, true, Builder) || Trap.hasErrorOccurred()) { unsigned Index = Builder.size(); if (Index >= TemplateParams->size()) Index = TemplateParams->size() - 1; Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); return TDK_InvalidExplicitArguments; } // Form the template argument list from the explicitly-specified // template arguments. TemplateArgumentList *ExplicitArgumentList = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); Info.reset(ExplicitArgumentList); // Template argument deduction and the final substitution should be // done in the context of the templated declaration. Explicit // argument substitution, on the other hand, needs to happen in the // calling context. ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); // If we deduced template arguments for a template parameter pack, // note that the template argument pack is partially substituted and record // the explicit template arguments. They'll be used as part of deduction // for this template parameter pack. for (unsigned I = 0, N = Builder.size(); I != N; ++I) { const TemplateArgument &Arg = Builder[I]; if (Arg.getKind() == TemplateArgument::Pack) { CurrentInstantiationScope->SetPartiallySubstitutedPack( TemplateParams->getParam(I), Arg.pack_begin(), Arg.pack_size()); break; } } const FunctionProtoType *Proto = Function->getType()->getAs(); assert(Proto && "Function template does not have a prototype?"); // Instantiate the types of each of the function parameters given the // explicitly-specified template arguments. If the function has a trailing // return type, substitute it after the arguments to ensure we substitute // in lexical order. if (Proto->hasTrailingReturn()) { if (SubstParmTypes(Function->getLocation(), Function->param_begin(), Function->getNumParams(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), ParamTypes)) return TDK_SubstitutionFailure; } // Instantiate the return type. QualType ResultType; { // C++11 [expr.prim.general]p3: // If a declaration declares a member function or member function // template of a class X, the expression this is a prvalue of type // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq // and the end of the function-definition, member-declarator, or // declarator. unsigned ThisTypeQuals = 0; CXXRecordDecl *ThisContext = nullptr; if (CXXMethodDecl *Method = dyn_cast(Function)) { ThisContext = Method->getParent(); ThisTypeQuals = Method->getTypeQualifiers(); } CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals, getLangOpts().CPlusPlus11); ResultType = SubstType(Proto->getReturnType(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), Function->getTypeSpecStartLoc(), Function->getDeclName()); if (ResultType.isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; } // Instantiate the types of each of the function parameters given the // explicitly-specified template arguments if we didn't do so earlier. if (!Proto->hasTrailingReturn() && SubstParmTypes(Function->getLocation(), Function->param_begin(), Function->getNumParams(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), ParamTypes)) return TDK_SubstitutionFailure; if (FunctionType) { *FunctionType = BuildFunctionType(ResultType, ParamTypes, Function->getLocation(), Function->getDeclName(), Proto->getExtProtoInfo()); if (FunctionType->isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; } // C++ [temp.arg.explicit]p2: // Trailing template arguments that can be deduced (14.8.2) may be // omitted from the list of explicit template-arguments. If all of the // template arguments can be deduced, they may all be omitted; in this // case, the empty template argument list <> itself may also be omitted. // // Take all of the explicitly-specified arguments and put them into // the set of deduced template arguments. Explicitly-specified // parameter packs, however, will be set to NULL since the deduction // mechanisms handle explicitly-specified argument packs directly. Deduced.reserve(TemplateParams->size()); for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) { const TemplateArgument &Arg = ExplicitArgumentList->get(I); if (Arg.getKind() == TemplateArgument::Pack) Deduced.push_back(DeducedTemplateArgument()); else Deduced.push_back(Arg); } return TDK_Success; } /// \brief Check whether the deduced argument type for a call to a function /// template matches the actual argument type per C++ [temp.deduct.call]p4. static bool CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg, QualType DeducedA) { ASTContext &Context = S.Context; QualType A = OriginalArg.OriginalArgType; QualType OriginalParamType = OriginalArg.OriginalParamType; // Check for type equality (top-level cv-qualifiers are ignored). if (Context.hasSameUnqualifiedType(A, DeducedA)) return false; // Strip off references on the argument types; they aren't needed for // the following checks. if (const ReferenceType *DeducedARef = DeducedA->getAs()) DeducedA = DeducedARef->getPointeeType(); if (const ReferenceType *ARef = A->getAs()) A = ARef->getPointeeType(); // C++ [temp.deduct.call]p4: // [...] However, there are three cases that allow a difference: // - If the original P is a reference type, the deduced A (i.e., the // type referred to by the reference) can be more cv-qualified than // the transformed A. if (const ReferenceType *OriginalParamRef = OriginalParamType->getAs()) { // We don't want to keep the reference around any more. OriginalParamType = OriginalParamRef->getPointeeType(); Qualifiers AQuals = A.getQualifiers(); Qualifiers DeducedAQuals = DeducedA.getQualifiers(); // Under Objective-C++ ARC, the deduced type may have implicitly // been given strong or (when dealing with a const reference) // unsafe_unretained lifetime. If so, update the original // qualifiers to include this lifetime. if (S.getLangOpts().ObjCAutoRefCount && ((DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong && AQuals.getObjCLifetime() == Qualifiers::OCL_None) || (DeducedAQuals.hasConst() && DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone))) { AQuals.setObjCLifetime(DeducedAQuals.getObjCLifetime()); } if (AQuals == DeducedAQuals) { // Qualifiers match; there's nothing to do. } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) { return true; } else { // Qualifiers are compatible, so have the argument type adopt the // deduced argument type's qualifiers as if we had performed the // qualification conversion. A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals); } } // - The transformed A can be another pointer or pointer to member // type that can be converted to the deduced A via a qualification // conversion. // // Also allow conversions which merely strip [[noreturn]] from function types // (recursively) as an extension. // FIXME: Currently, this doesn't play nicely with qualification conversions. bool ObjCLifetimeConversion = false; QualType ResultTy; if ((A->isAnyPointerType() || A->isMemberPointerType()) && (S.IsQualificationConversion(A, DeducedA, false, ObjCLifetimeConversion) || S.IsNoReturnConversion(A, DeducedA, ResultTy))) return false; // - If P is a class and P has the form simple-template-id, then the // transformed A can be a derived class of the deduced A. [...] // [...] Likewise, if P is a pointer to a class of the form // simple-template-id, the transformed A can be a pointer to a // derived class pointed to by the deduced A. if (const PointerType *OriginalParamPtr = OriginalParamType->getAs()) { if (const PointerType *DeducedAPtr = DeducedA->getAs()) { if (const PointerType *APtr = A->getAs()) { if (A->getPointeeType()->isRecordType()) { OriginalParamType = OriginalParamPtr->getPointeeType(); DeducedA = DeducedAPtr->getPointeeType(); A = APtr->getPointeeType(); } } } } if (Context.hasSameUnqualifiedType(A, DeducedA)) return false; if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) && S.IsDerivedFrom(A, DeducedA)) return false; return true; } /// \brief Finish template argument deduction for a function template, /// checking the deduced template arguments for completeness and forming /// the function template specialization. /// /// \param OriginalCallArgs If non-NULL, the original call arguments against /// which the deduced argument types should be compared. Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl &Deduced, unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, SmallVectorImpl const *OriginalCallArgs) { TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // Enter a new template instantiation context while we instantiate the // actual function declaration. SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate, DeducedArgs, ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { NamedDecl *Param = TemplateParams->getParam(I); if (!Deduced[I].isNull()) { if (I < NumExplicitlySpecified) { // We have already fully type-checked and converted this // argument, because it was explicitly-specified. Just record the // presence of this argument. Builder.push_back(Deduced[I]); // We may have had explicitly-specified template arguments for a // template parameter pack (that may or may not have been extended // via additional deduced arguments). if (Param->isParameterPack() && CurrentInstantiationScope) { if (CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) { // Forget the partially-substituted pack; its substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); } } continue; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I], FunctionTemplate, NTTPType, 0, Info, true, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } continue; } // C++0x [temp.arg.explicit]p3: // A trailing template parameter pack (14.5.3) not otherwise deduced will // be deduced to an empty sequence of template arguments. // FIXME: Where did the word "trailing" come from? if (Param->isTemplateParameterPack()) { // We may have had explicitly-specified template arguments for this // template parameter pack. If so, our empty deduction extends the // explicitly-specified set (C++0x [temp.arg.explicit]p9). const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; if (CurrentInstantiationScope && CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs, &NumExplicitArgs) == Param) { Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs)); // Forget the partially-substituted pack; it's substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); } else { Builder.push_back(TemplateArgument::getEmptyPack()); } continue; } // Substitute into the default template argument, if available. bool HasDefaultArg = false; TemplateArgumentLoc DefArg = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate, FunctionTemplate->getLocation(), FunctionTemplate->getSourceRange().getEnd(), Param, Builder, HasDefaultArg); // If there was no default argument, deduction is incomplete. if (DefArg.getArgument().isNull()) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return HasDefaultArg ? TDK_SubstitutionFailure : TDK_Incomplete; } // Check whether we can actually use the default argument. if (CheckTemplateArgument(Param, DefArg, FunctionTemplate, FunctionTemplate->getLocation(), FunctionTemplate->getSourceRange().getEnd(), 0, Builder, CTAK_Specified)) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } // If we get here, we successfully used the default template argument. } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the function template // declaration to produce the function template specialization. DeclContext *Owner = FunctionTemplate->getDeclContext(); if (FunctionTemplate->getFriendObjectKind()) Owner = FunctionTemplate->getLexicalDeclContext(); Specialization = cast_or_null( SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, MultiLevelTemplateArgumentList(*DeducedArgumentList))); if (!Specialization || Specialization->isInvalidDecl()) return TDK_SubstitutionFailure; assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == FunctionTemplate->getCanonicalDecl()); // If the template argument list is owned by the function template // specialization, release it. if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList && !Trap.hasErrorOccurred()) Info.take(); // There may have been an error that did not prevent us from constructing a // declaration. Mark the declaration invalid and return with a substitution // failure. if (Trap.hasErrorOccurred()) { Specialization->setInvalidDecl(true); return TDK_SubstitutionFailure; } if (OriginalCallArgs) { // C++ [temp.deduct.call]p4: // In general, the deduction process attempts to find template argument // values that will make the deduced A identical to A (after the type A // is transformed as described above). [...] for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) { OriginalCallArg OriginalArg = (*OriginalCallArgs)[I]; unsigned ParamIdx = OriginalArg.ArgIdx; if (ParamIdx >= Specialization->getNumParams()) continue; QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType(); if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) return Sema::TDK_SubstitutionFailure; } } // If we suppressed any diagnostics while performing template argument // deduction, and if we haven't already instantiated this declaration, // keep track of these diagnostics. They'll be emitted if this specialization // is actually used. if (Info.diag_begin() != Info.diag_end()) { SuppressedDiagnosticsMap::iterator Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); if (Pos == SuppressedDiagnostics.end()) SuppressedDiagnostics[Specialization->getCanonicalDecl()] .append(Info.diag_begin(), Info.diag_end()); } return TDK_Success; } /// Gets the type of a function for template-argument-deducton /// purposes when it's considered as part of an overload set. static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R, FunctionDecl *Fn) { // We may need to deduce the return type of the function now. if (S.getLangOpts().CPlusPlus1y && Fn->getReturnType()->isUndeducedType() && S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false)) return QualType(); if (CXXMethodDecl *Method = dyn_cast(Fn)) if (Method->isInstance()) { // An instance method that's referenced in a form that doesn't // look like a member pointer is just invalid. if (!R.HasFormOfMemberPointer) return QualType(); return S.Context.getMemberPointerType(Fn->getType(), S.Context.getTypeDeclType(Method->getParent()).getTypePtr()); } if (!R.IsAddressOfOperand) return Fn->getType(); return S.Context.getPointerType(Fn->getType()); } /// Apply the deduction rules for overload sets. /// /// \return the null type if this argument should be treated as an /// undeduced context static QualType ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, Expr *Arg, QualType ParamType, bool ParamWasReference) { OverloadExpr::FindResult R = OverloadExpr::find(Arg); OverloadExpr *Ovl = R.Expression; // C++0x [temp.deduct.call]p4 unsigned TDF = 0; if (ParamWasReference) TDF |= TDF_ParamWithReferenceType; if (R.IsAddressOfOperand) TDF |= TDF_IgnoreQualifiers; // C++0x [temp.deduct.call]p6: // When P is a function type, pointer to function type, or pointer // to member function type: if (!ParamType->isFunctionType() && !ParamType->isFunctionPointerType() && !ParamType->isMemberFunctionPointerType()) { if (Ovl->hasExplicitTemplateArgs()) { // But we can still look for an explicit specialization. if (FunctionDecl *ExplicitSpec = S.ResolveSingleFunctionTemplateSpecialization(Ovl)) return GetTypeOfFunction(S, R, ExplicitSpec); } return QualType(); } // Gather the explicit template arguments, if any. TemplateArgumentListInfo ExplicitTemplateArgs; if (Ovl->hasExplicitTemplateArgs()) Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs); QualType Match; for (UnresolvedSetIterator I = Ovl->decls_begin(), E = Ovl->decls_end(); I != E; ++I) { NamedDecl *D = (*I)->getUnderlyingDecl(); if (FunctionTemplateDecl *FunTmpl = dyn_cast(D)) { // - If the argument is an overload set containing one or more // function templates, the parameter is treated as a // non-deduced context. if (!Ovl->hasExplicitTemplateArgs()) return QualType(); // Otherwise, see if we can resolve a function type FunctionDecl *Specialization = nullptr; TemplateDeductionInfo Info(Ovl->getNameLoc()); if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs, Specialization, Info)) continue; D = Specialization; } FunctionDecl *Fn = cast(D); QualType ArgType = GetTypeOfFunction(S, R, Fn); if (ArgType.isNull()) continue; // Function-to-pointer conversion. if (!ParamWasReference && ParamType->isPointerType() && ArgType->isFunctionType()) ArgType = S.Context.getPointerType(ArgType); // - If the argument is an overload set (not containing function // templates), trial argument deduction is attempted using each // of the members of the set. If deduction succeeds for only one // of the overload set members, that member is used as the // argument value for the deduction. If deduction succeeds for // more than one member of the overload set the parameter is // treated as a non-deduced context. // We do all of this in a fresh context per C++0x [temp.deduct.type]p2: // Type deduction is done independently for each P/A pair, and // the deduced template argument values are then combined. // So we do not reject deductions which were made elsewhere. SmallVector Deduced(TemplateParams->size()); TemplateDeductionInfo Info(Ovl->getNameLoc()); Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF); if (Result) continue; if (!Match.isNull()) return QualType(); Match = ArgType; } return Match; } /// \brief Perform the adjustments to the parameter and argument types /// described in C++ [temp.deduct.call]. /// /// \returns true if the caller should not attempt to perform any template /// argument deduction based on this P/A pair because the argument is an /// overloaded function set that could not be resolved. static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, TemplateParameterList *TemplateParams, QualType &ParamType, QualType &ArgType, Expr *Arg, unsigned &TDF) { // C++0x [temp.deduct.call]p3: // If P is a cv-qualified type, the top level cv-qualifiers of P's type // are ignored for type deduction. if (ParamType.hasQualifiers()) ParamType = ParamType.getUnqualifiedType(); const ReferenceType *ParamRefType = ParamType->getAs(); if (ParamRefType) { QualType PointeeType = ParamRefType->getPointeeType(); // If the argument has incomplete array type, try to complete its type. if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0)) ArgType = Arg->getType(); // [C++0x] If P is an rvalue reference to a cv-unqualified // template parameter and the argument is an lvalue, the type // "lvalue reference to A" is used in place of A for type // deduction. if (isa(ParamType)) { if (!PointeeType.getQualifiers() && isa(PointeeType) && Arg->Classify(S.Context).isLValue() && Arg->getType() != S.Context.OverloadTy && Arg->getType() != S.Context.BoundMemberTy) ArgType = S.Context.getLValueReferenceType(ArgType); } // [...] If P is a reference type, the type referred to by P is used // for type deduction. ParamType = PointeeType; } // Overload sets usually make this parameter an undeduced // context, but there are sometimes special circumstances. if (ArgType == S.Context.OverloadTy) { ArgType = ResolveOverloadForDeduction(S, TemplateParams, Arg, ParamType, ParamRefType != nullptr); if (ArgType.isNull()) return true; } if (ParamRefType) { // C++0x [temp.deduct.call]p3: // [...] If P is of the form T&&, where T is a template parameter, and // the argument is an lvalue, the type A& is used in place of A for // type deduction. if (ParamRefType->isRValueReferenceType() && ParamRefType->getAs() && Arg->isLValue()) ArgType = S.Context.getLValueReferenceType(ArgType); } else { // C++ [temp.deduct.call]p2: // If P is not a reference type: // - If A is an array type, the pointer type produced by the // array-to-pointer standard conversion (4.2) is used in place of // A for type deduction; otherwise, if (ArgType->isArrayType()) ArgType = S.Context.getArrayDecayedType(ArgType); // - If A is a function type, the pointer type produced by the // function-to-pointer standard conversion (4.3) is used in place // of A for type deduction; otherwise, else if (ArgType->isFunctionType()) ArgType = S.Context.getPointerType(ArgType); else { // - If A is a cv-qualified type, the top level cv-qualifiers of A's // type are ignored for type deduction. ArgType = ArgType.getUnqualifiedType(); } } // C++0x [temp.deduct.call]p4: // In general, the deduction process attempts to find template argument // values that will make the deduced A identical to A (after the type A // is transformed as described above). [...] TDF = TDF_SkipNonDependent; // - If the original P is a reference type, the deduced A (i.e., the // type referred to by the reference) can be more cv-qualified than // the transformed A. if (ParamRefType) TDF |= TDF_ParamWithReferenceType; // - The transformed A can be another pointer or pointer to member // type that can be converted to the deduced A via a qualification // conversion (4.4). if (ArgType->isPointerType() || ArgType->isMemberPointerType() || ArgType->isObjCObjectPointerType()) TDF |= TDF_IgnoreQualifiers; // - If P is a class and P has the form simple-template-id, then the // transformed A can be a derived class of the deduced A. Likewise, // if P is a pointer to a class of the form simple-template-id, the // transformed A can be a pointer to a derived class pointed to by // the deduced A. if (isSimpleTemplateIdType(ParamType) || (isa(ParamType) && isSimpleTemplateIdType( ParamType->getAs()->getPointeeType()))) TDF |= TDF_DerivedClass; return false; } static bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T); /// \brief Perform template argument deduction by matching a parameter type /// against a single expression, where the expression is an element of /// an initializer list that was originally matched against a parameter /// of type \c initializer_list\. static Sema::TemplateDeductionResult DeduceTemplateArgumentByListElement(Sema &S, TemplateParameterList *TemplateParams, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF) { // Handle the case where an init list contains another init list as the // element. if (InitListExpr *ILE = dyn_cast(Arg)) { QualType X; if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X)) return Sema::TDK_Success; // Just ignore this expression. // Recurse down into the init list. for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentByListElement(S, TemplateParams, X, ILE->getInit(i), Info, Deduced, TDF)) return Result; } return Sema::TDK_Success; } // For all other cases, just match by type. QualType ArgType = Arg->getType(); if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, ArgType, Arg, TDF)) { Info.Expression = Arg; return Sema::TDK_FailedOverloadResolution; } return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF); } /// \brief Perform template argument deduction from a function call /// (C++ [temp.deduct.call]). /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicit template arguments provided /// for this call. /// /// \param Args the function call arguments /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef Args, FunctionDecl *&Specialization, TemplateDeductionInfo &Info) { if (FunctionTemplate->isInvalidDecl()) return TDK_Invalid; FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); // C++ [temp.deduct.call]p1: // Template argument deduction is done by comparing each function template // parameter type (call it P) with the type of the corresponding argument // of the call (call it A) as described below. unsigned CheckArgs = Args.size(); if (Args.size() < Function->getMinRequiredArguments()) return TDK_TooFewArguments; else if (Args.size() > Function->getNumParams()) { const FunctionProtoType *Proto = Function->getType()->getAs(); if (Proto->isTemplateVariadic()) /* Do nothing */; else if (Proto->isVariadic()) CheckArgs = Function->getNumParams(); else return TDK_TooManyArguments; } // The types of the parameters from which we will perform template argument // deduction. LocalInstantiationScope InstScope(*this); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); SmallVector Deduced; SmallVector ParamTypes; unsigned NumExplicitlySpecified = 0; if (ExplicitTemplateArgs) { TemplateDeductionResult Result = SubstituteExplicitTemplateArguments(FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, nullptr, Info); if (Result) return Result; NumExplicitlySpecified = Deduced.size(); } else { // Just fill in the parameter types from the function declaration. for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) ParamTypes.push_back(Function->getParamDecl(I)->getType()); } // Deduce template arguments from the function parameters. Deduced.resize(TemplateParams->size()); unsigned ArgIdx = 0; SmallVector OriginalCallArgs; for (unsigned ParamIdx = 0, NumParams = ParamTypes.size(); ParamIdx != NumParams; ++ParamIdx) { QualType OrigParamType = ParamTypes[ParamIdx]; QualType ParamType = OrigParamType; const PackExpansionType *ParamExpansion = dyn_cast(ParamType); if (!ParamExpansion) { // Simple case: matching a function parameter to a function argument. if (ArgIdx >= CheckArgs) break; Expr *Arg = Args[ArgIdx++]; QualType ArgType = Arg->getType(); unsigned TDF = 0; if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, ParamType, ArgType, Arg, TDF)) continue; // If we have nothing to deduce, we're done. if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) continue; // If the argument is an initializer list ... if (InitListExpr *ILE = dyn_cast(Arg)) { // ... then the parameter is an undeduced context, unless the parameter // type is (reference to cv) std::initializer_list, in which case // deduction is done for each element of the initializer list, and the // result is the deduced type if it's the same for all elements. QualType X; // Removing references was already done. if (!isStdInitializerList(ParamType, &X)) continue; for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (TemplateDeductionResult Result = DeduceTemplateArgumentByListElement(*this, TemplateParams, X, ILE->getInit(i), Info, Deduced, TDF)) return Result; } // Don't track the argument type, since an initializer list has none. continue; } // Keep track of the argument type and corresponding parameter index, // so we can check for compatibility between the deduced A and A. OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1, ArgType)); if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, ParamType, ArgType, Info, Deduced, TDF)) return Result; continue; } // C++0x [temp.deduct.call]p1: // For a function parameter pack that occurs at the end of the // parameter-declaration-list, the type A of each remaining argument of // the call is compared with the type P of the declarator-id of the // function parameter pack. Each comparison deduces template arguments // for subsequent positions in the template parameter packs expanded by // the function parameter pack. For a function parameter pack that does // not occur at the end of the parameter-declaration-list, the type of // the parameter pack is a non-deduced context. if (ParamIdx + 1 < NumParams) break; QualType ParamPattern = ParamExpansion->getPattern(); PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info, ParamPattern); bool HasAnyArguments = false; for (; ArgIdx < Args.size(); ++ArgIdx) { HasAnyArguments = true; QualType OrigParamType = ParamPattern; ParamType = OrigParamType; Expr *Arg = Args[ArgIdx]; QualType ArgType = Arg->getType(); unsigned TDF = 0; if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, ParamType, ArgType, Arg, TDF)) { // We can't actually perform any deduction for this argument, so stop // deduction at this point. ++ArgIdx; break; } // As above, initializer lists need special handling. if (InitListExpr *ILE = dyn_cast(Arg)) { QualType X; if (!isStdInitializerList(ParamType, &X)) { ++ArgIdx; break; } for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X, ILE->getInit(i)->getType(), Info, Deduced, TDF)) return Result; } } else { // Keep track of the argument type and corresponding argument index, // so we can check for compatibility between the deduced A and A. if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx, ArgType)); if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, ParamType, ArgType, Info, Deduced, TDF)) return Result; } PackScope.nextPackElement(); } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (auto Result = PackScope.finish(HasAnyArguments)) return Result; // After we've matching against a parameter pack, we're done. break; } return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info, &OriginalCallArgs); } QualType Sema::adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType) { if (ArgFunctionType.isNull()) return ArgFunctionType; const FunctionProtoType *FunctionTypeP = FunctionType->castAs(); CallingConv CC = FunctionTypeP->getCallConv(); bool NoReturn = FunctionTypeP->getNoReturnAttr(); const FunctionProtoType *ArgFunctionTypeP = ArgFunctionType->getAs(); if (ArgFunctionTypeP->getCallConv() == CC && ArgFunctionTypeP->getNoReturnAttr() == NoReturn) return ArgFunctionType; FunctionType::ExtInfo EI = ArgFunctionTypeP->getExtInfo().withCallingConv(CC); EI = EI.withNoReturn(NoReturn); ArgFunctionTypeP = cast(Context.adjustFunctionType(ArgFunctionTypeP, EI)); return QualType(ArgFunctionTypeP, 0); } /// \brief Deduce template arguments when taking the address of a function /// template (C++ [temp.deduct.funcaddr]) or matching a specialization to /// a template. /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param ArgFunctionType the function type that will be used as the /// "argument" type (A) when performing template argument deduction from the /// function template's function type. This type may be NULL, if there is no /// argument type to compare against, in C++0x [temp.arg.explicit]p3. /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ArgFunctionType, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool InOverloadResolution) { if (FunctionTemplate->isInvalidDecl()) return TDK_Invalid; FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); QualType FunctionType = Function->getType(); if (!InOverloadResolution) ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType); // Substitute any explicit template arguments. LocalInstantiationScope InstScope(*this); SmallVector Deduced; unsigned NumExplicitlySpecified = 0; SmallVector ParamTypes; if (ExplicitTemplateArgs) { if (TemplateDeductionResult Result = SubstituteExplicitTemplateArguments(FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, &FunctionType, Info)) return Result; NumExplicitlySpecified = Deduced.size(); } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); Deduced.resize(TemplateParams->size()); // If the function has a deduced return type, substitute it for a dependent // type so that we treat it as a non-deduced context in what follows. bool HasDeducedReturnType = false; if (getLangOpts().CPlusPlus1y && InOverloadResolution && Function->getReturnType()->getContainedAutoType()) { FunctionType = SubstAutoType(FunctionType, Context.DependentTy); HasDeducedReturnType = true; } if (!ArgFunctionType.isNull()) { unsigned TDF = TDF_TopLevelParameterTypeList; if (InOverloadResolution) TDF |= TDF_InOverloadResolution; // Deduce template arguments from the function type. if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, FunctionType, ArgFunctionType, Info, Deduced, TDF)) return Result; } if (TemplateDeductionResult Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info)) return Result; // If the function has a deduced return type, deduce it now, so we can check // that the deduced function type matches the requested type. if (HasDeducedReturnType && Specialization->getReturnType()->isUndeducedType() && DeduceReturnType(Specialization, Info.getLocation(), false)) return TDK_MiscellaneousDeductionFailure; // If the requested function type does not match the actual type of the // specialization with respect to arguments of compatible pointer to function // types, template argument deduction fails. if (!ArgFunctionType.isNull()) { if (InOverloadResolution && !isSameOrCompatibleFunctionType( Context.getCanonicalType(Specialization->getType()), Context.getCanonicalType(ArgFunctionType))) return TDK_MiscellaneousDeductionFailure; else if(!InOverloadResolution && !Context.hasSameType(Specialization->getType(), ArgFunctionType)) return TDK_MiscellaneousDeductionFailure; } return TDK_Success; } /// \brief Given a function declaration (e.g. a generic lambda conversion /// function) that contains an 'auto' in its result type, substitute it /// with TypeToReplaceAutoWith. Be careful to pass in the type you want /// to replace 'auto' with and not the actual result type you want /// to set the function to. static inline void SubstAutoWithinFunctionReturnType(FunctionDecl *F, QualType TypeToReplaceAutoWith, Sema &S) { assert(!TypeToReplaceAutoWith->getContainedAutoType()); QualType AutoResultType = F->getReturnType(); assert(AutoResultType->getContainedAutoType()); QualType DeducedResultType = S.SubstAutoType(AutoResultType, TypeToReplaceAutoWith); S.Context.adjustDeducedFunctionResultType(F, DeducedResultType); } /// \brief Given a specialized conversion operator of a generic lambda /// create the corresponding specializations of the call operator and /// the static-invoker. If the return type of the call operator is auto, /// deduce its return type and check if that matches the /// return type of the destination function ptr. static inline Sema::TemplateDeductionResult SpecializeCorrespondingLambdaCallOperatorAndInvoker( CXXConversionDecl *ConversionSpecialized, SmallVectorImpl &DeducedArguments, QualType ReturnTypeOfDestFunctionPtr, TemplateDeductionInfo &TDInfo, Sema &S) { CXXRecordDecl *LambdaClass = ConversionSpecialized->getParent(); assert(LambdaClass && LambdaClass->isGenericLambda()); CXXMethodDecl *CallOpGeneric = LambdaClass->getLambdaCallOperator(); QualType CallOpResultType = CallOpGeneric->getReturnType(); const bool GenericLambdaCallOperatorHasDeducedReturnType = CallOpResultType->getContainedAutoType(); FunctionTemplateDecl *CallOpTemplate = CallOpGeneric->getDescribedFunctionTemplate(); FunctionDecl *CallOpSpecialized = nullptr; // Use the deduced arguments of the conversion function, to specialize our // generic lambda's call operator. if (Sema::TemplateDeductionResult Result = S.FinishTemplateArgumentDeduction(CallOpTemplate, DeducedArguments, 0, CallOpSpecialized, TDInfo)) return Result; // If we need to deduce the return type, do so (instantiates the callop). if (GenericLambdaCallOperatorHasDeducedReturnType && CallOpSpecialized->getReturnType()->isUndeducedType()) S.DeduceReturnType(CallOpSpecialized, CallOpSpecialized->getPointOfInstantiation(), /*Diagnose*/ true); // Check to see if the return type of the destination ptr-to-function // matches the return type of the call operator. if (!S.Context.hasSameType(CallOpSpecialized->getReturnType(), ReturnTypeOfDestFunctionPtr)) return Sema::TDK_NonDeducedMismatch; // Since we have succeeded in matching the source and destination // ptr-to-functions (now including return type), and have successfully // specialized our corresponding call operator, we are ready to // specialize the static invoker with the deduced arguments of our // ptr-to-function. FunctionDecl *InvokerSpecialized = nullptr; FunctionTemplateDecl *InvokerTemplate = LambdaClass-> getLambdaStaticInvoker()->getDescribedFunctionTemplate(); Sema::TemplateDeductionResult LLVM_ATTRIBUTE_UNUSED Result = S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0, InvokerSpecialized, TDInfo); assert(Result == Sema::TDK_Success && "If the call operator succeeded so should the invoker!"); // Set the result type to match the corresponding call operator // specialization's result type. if (GenericLambdaCallOperatorHasDeducedReturnType && InvokerSpecialized->getReturnType()->isUndeducedType()) { // Be sure to get the type to replace 'auto' with and not // the full result type of the call op specialization // to substitute into the 'auto' of the invoker and conversion // function. // For e.g. // int* (*fp)(int*) = [](auto* a) -> auto* { return a; }; // We don't want to subst 'int*' into 'auto' to get int**. QualType TypeToReplaceAutoWith = CallOpSpecialized->getReturnType() ->getContainedAutoType() ->getDeducedType(); SubstAutoWithinFunctionReturnType(InvokerSpecialized, TypeToReplaceAutoWith, S); SubstAutoWithinFunctionReturnType(ConversionSpecialized, TypeToReplaceAutoWith, S); } // Ensure that static invoker doesn't have a const qualifier. // FIXME: When creating the InvokerTemplate in SemaLambda.cpp // do not use the CallOperator's TypeSourceInfo which allows // the const qualifier to leak through. const FunctionProtoType *InvokerFPT = InvokerSpecialized-> getType().getTypePtr()->castAs(); FunctionProtoType::ExtProtoInfo EPI = InvokerFPT->getExtProtoInfo(); EPI.TypeQuals = 0; InvokerSpecialized->setType(S.Context.getFunctionType( InvokerFPT->getReturnType(), InvokerFPT->getParamTypes(), EPI)); return Sema::TDK_Success; } /// \brief Deduce template arguments for a templated conversion /// function (C++ [temp.deduct.conv]) and, if successful, produce a /// conversion function template specialization. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate, QualType ToType, CXXConversionDecl *&Specialization, TemplateDeductionInfo &Info) { if (ConversionTemplate->isInvalidDecl()) return TDK_Invalid; CXXConversionDecl *ConversionGeneric = cast(ConversionTemplate->getTemplatedDecl()); QualType FromType = ConversionGeneric->getConversionType(); // Canonicalize the types for deduction. QualType P = Context.getCanonicalType(FromType); QualType A = Context.getCanonicalType(ToType); // C++0x [temp.deduct.conv]p2: // If P is a reference type, the type referred to by P is used for // type deduction. if (const ReferenceType *PRef = P->getAs()) P = PRef->getPointeeType(); // C++0x [temp.deduct.conv]p4: // [...] If A is a reference type, the type referred to by A is used // for type deduction. if (const ReferenceType *ARef = A->getAs()) A = ARef->getPointeeType().getUnqualifiedType(); // C++ [temp.deduct.conv]p3: // // If A is not a reference type: else { assert(!A->isReferenceType() && "Reference types were handled above"); // - If P is an array type, the pointer type produced by the // array-to-pointer standard conversion (4.2) is used in place // of P for type deduction; otherwise, if (P->isArrayType()) P = Context.getArrayDecayedType(P); // - If P is a function type, the pointer type produced by the // function-to-pointer standard conversion (4.3) is used in // place of P for type deduction; otherwise, else if (P->isFunctionType()) P = Context.getPointerType(P); // - If P is a cv-qualified type, the top level cv-qualifiers of // P's type are ignored for type deduction. else P = P.getUnqualifiedType(); // C++0x [temp.deduct.conv]p4: // If A is a cv-qualified type, the top level cv-qualifiers of A's // type are ignored for type deduction. If A is a reference type, the type // referred to by A is used for type deduction. A = A.getUnqualifiedType(); } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // C++ [temp.deduct.conv]p1: // Template argument deduction is done by comparing the return // type of the template conversion function (call it P) with the // type that is required as the result of the conversion (call it // A) as described in 14.8.2.4. TemplateParameterList *TemplateParams = ConversionTemplate->getTemplateParameters(); SmallVector Deduced; Deduced.resize(TemplateParams->size()); // C++0x [temp.deduct.conv]p4: // In general, the deduction process attempts to find template // argument values that will make the deduced A identical to // A. However, there are two cases that allow a difference: unsigned TDF = 0; // - If the original A is a reference type, A can be more // cv-qualified than the deduced A (i.e., the type referred to // by the reference) if (ToType->isReferenceType()) TDF |= TDF_ParamWithReferenceType; // - The deduced A can be another pointer or pointer to member // type that can be converted to A via a qualification // conversion. // // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when // both P and A are pointers or member pointers. In this case, we // just ignore cv-qualifiers completely). if ((P->isPointerType() && A->isPointerType()) || (P->isMemberPointerType() && A->isMemberPointerType())) TDF |= TDF_IgnoreQualifiers; if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, P, A, Info, Deduced, TDF)) return Result; // Create an Instantiation Scope for finalizing the operator. LocalInstantiationScope InstScope(*this); // Finish template argument deduction. FunctionDecl *ConversionSpecialized = nullptr; TemplateDeductionResult Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0, ConversionSpecialized, Info); Specialization = cast_or_null(ConversionSpecialized); // If the conversion operator is being invoked on a lambda closure to convert // to a ptr-to-function, use the deduced arguments from the conversion // function to specialize the corresponding call operator. // e.g., int (*fp)(int) = [](auto a) { return a; }; if (Result == TDK_Success && isLambdaConversionOperator(ConversionGeneric)) { // Get the return type of the destination ptr-to-function we are converting // to. This is necessary for matching the lambda call operator's return // type to that of the destination ptr-to-function's return type. assert(A->isPointerType() && "Can only convert from lambda to ptr-to-function"); const FunctionType *ToFunType = A->getPointeeType().getTypePtr()->getAs(); const QualType DestFunctionPtrReturnType = ToFunType->getReturnType(); // Create the corresponding specializations of the call operator and // the static-invoker; and if the return type is auto, // deduce the return type and check if it matches the // DestFunctionPtrReturnType. // For instance: // auto L = [](auto a) { return f(a); }; // int (*fp)(int) = L; // char (*fp2)(int) = L; <-- Not OK. Result = SpecializeCorrespondingLambdaCallOperatorAndInvoker( Specialization, Deduced, DestFunctionPtrReturnType, Info, *this); } return Result; } /// \brief Deduce template arguments for a function template when there is /// nothing to deduce against (C++0x [temp.arg.explicit]p3). /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool InOverloadResolution) { return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, QualType(), Specialization, Info, InOverloadResolution); } namespace { /// Substitute the 'auto' type specifier within a type for a given replacement /// type. class SubstituteAutoTransform : public TreeTransform { QualType Replacement; public: SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) : TreeTransform(SemaRef), Replacement(Replacement) {} QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) { // If we're building the type pattern to deduce against, don't wrap the // substituted type in an AutoType. Certain template deduction rules // apply only when a template type parameter appears directly (and not if // the parameter is found through desugaring). For instance: // auto &&lref = lvalue; // must transform into "rvalue reference to T" not "rvalue reference to // auto type deduced as T" in order for [temp.deduct.call]p3 to apply. if (!Replacement.isNull() && isa(Replacement)) { QualType Result = Replacement; TemplateTypeParmTypeLoc NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } else { bool Dependent = !Replacement.isNull() && Replacement->isDependentType(); QualType Result = SemaRef.Context.getAutoType(Dependent ? QualType() : Replacement, TL.getTypePtr()->isDecltypeAuto(), Dependent); AutoTypeLoc NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } } ExprResult TransformLambdaExpr(LambdaExpr *E) { // Lambdas never need to be transformed. return E; } QualType Apply(TypeLoc TL) { // Create some scratch storage for the transformed type locations. // FIXME: We're just going to throw this information away. Don't build it. TypeLocBuilder TLB; TLB.reserve(TL.getFullDataSize()); return TransformType(TLB, TL); } }; } Sema::DeduceAutoResult Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result) { return DeduceAutoType(Type->getTypeLoc(), Init, Result); } /// \brief Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) /// /// \param Type the type pattern using the auto type-specifier. /// \param Init the initializer for the variable whose type is to be deduced. /// \param Result if type deduction was successful, this will be set to the /// deduced type. Sema::DeduceAutoResult Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) { if (Init->getType()->isNonOverloadPlaceholderType()) { ExprResult NonPlaceholder = CheckPlaceholderExpr(Init); if (NonPlaceholder.isInvalid()) return DAR_FailedAlreadyDiagnosed; Init = NonPlaceholder.get(); } if (Init->isTypeDependent() || Type.getType()->isDependentType()) { Result = SubstituteAutoTransform(*this, Context.DependentTy).Apply(Type); assert(!Result.isNull() && "substituting DependentTy can't fail"); return DAR_Succeeded; } // If this is a 'decltype(auto)' specifier, do the decltype dance. // Since 'decltype(auto)' can only occur at the top of the type, we // don't need to go digging for it. if (const AutoType *AT = Type.getType()->getAs()) { if (AT->isDecltypeAuto()) { if (isa(Init)) { Diag(Init->getLocStart(), diag::err_decltype_auto_initializer_list); return DAR_FailedAlreadyDiagnosed; } QualType Deduced = BuildDecltypeType(Init, Init->getLocStart()); // FIXME: Support a non-canonical deduced type for 'auto'. Deduced = Context.getCanonicalType(Deduced); Result = SubstituteAutoTransform(*this, Deduced).Apply(Type); if (Result.isNull()) return DAR_FailedAlreadyDiagnosed; return DAR_Succeeded; } } SourceLocation Loc = Init->getExprLoc(); LocalInstantiationScope InstScope(*this); // Build template void Func(FuncParam); TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create(Context, nullptr, SourceLocation(), Loc, 0, 0, nullptr, false, false); QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); NamedDecl *TemplParamPtr = TemplParam; FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr, Loc); QualType FuncParam = SubstituteAutoTransform(*this, TemplArg).Apply(Type); assert(!FuncParam.isNull() && "substituting template parameter for 'auto' failed"); // Deduce type of TemplParam in Func(Init) SmallVector Deduced; Deduced.resize(1); QualType InitType = Init->getType(); unsigned TDF = 0; TemplateDeductionInfo Info(Loc); InitListExpr *InitList = dyn_cast(Init); if (InitList) { for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) { if (DeduceTemplateArgumentByListElement(*this, &TemplateParams, TemplArg, InitList->getInit(i), Info, Deduced, TDF)) return DAR_Failed; } } else { if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams, FuncParam, InitType, Init, TDF)) return DAR_Failed; if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam, InitType, Info, Deduced, TDF)) return DAR_Failed; } if (Deduced[0].getKind() != TemplateArgument::Type) return DAR_Failed; QualType DeducedType = Deduced[0].getAsType(); if (InitList) { DeducedType = BuildStdInitializerList(DeducedType, Loc); if (DeducedType.isNull()) return DAR_FailedAlreadyDiagnosed; } Result = SubstituteAutoTransform(*this, DeducedType).Apply(Type); if (Result.isNull()) return DAR_FailedAlreadyDiagnosed; // Check that the deduced argument type is compatible with the original // argument type per C++ [temp.deduct.call]p4. if (!InitList && !Result.isNull() && CheckOriginalCallArgDeduction(*this, Sema::OriginalCallArg(FuncParam,0,InitType), Result)) { Result = QualType(); return DAR_Failed; } return DAR_Succeeded; } QualType Sema::SubstAutoType(QualType TypeWithAuto, QualType TypeToReplaceAuto) { return SubstituteAutoTransform(*this, TypeToReplaceAuto). TransformType(TypeWithAuto); } TypeSourceInfo* Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType TypeToReplaceAuto) { return SubstituteAutoTransform(*this, TypeToReplaceAuto). TransformType(TypeWithAuto); } void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) { if (isa(Init)) Diag(VDecl->getLocation(), VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure_from_init_list : diag::err_auto_var_deduction_failure_from_init_list) << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange(); else Diag(VDecl->getLocation(), VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure : diag::err_auto_var_deduction_failure) << VDecl->getDeclName() << VDecl->getType() << Init->getType() << Init->getSourceRange(); } bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose) { assert(FD->getReturnType()->isUndeducedType()); if (FD->getTemplateInstantiationPattern()) InstantiateFunctionDefinition(Loc, FD); bool StillUndeduced = FD->getReturnType()->isUndeducedType(); if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) { Diag(Loc, diag::err_auto_fn_used_before_defined) << FD; Diag(FD->getLocation(), diag::note_callee_decl) << FD; } return StillUndeduced; } static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Level, llvm::SmallBitVector &Deduced); /// \brief If this is a non-static member function, static void AddImplicitObjectParameterType(ASTContext &Context, CXXMethodDecl *Method, SmallVectorImpl &ArgTypes) { // C++11 [temp.func.order]p3: // [...] The new parameter is of type "reference to cv A," where cv are // the cv-qualifiers of the function template (if any) and A is // the class of which the function template is a member. // // The standard doesn't say explicitly, but we pick the appropriate kind of // reference type based on [over.match.funcs]p4. QualType ArgTy = Context.getTypeDeclType(Method->getParent()); ArgTy = Context.getQualifiedType(ArgTy, Qualifiers::fromCVRMask(Method->getTypeQualifiers())); if (Method->getRefQualifier() == RQ_RValue) ArgTy = Context.getRValueReferenceType(ArgTy); else ArgTy = Context.getLValueReferenceType(ArgTy); ArgTypes.push_back(ArgTy); } /// \brief Determine whether the function template \p FT1 is at least as /// specialized as \p FT2. static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc, FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, SmallVectorImpl *RefParamComparisons) { FunctionDecl *FD1 = FT1->getTemplatedDecl(); FunctionDecl *FD2 = FT2->getTemplatedDecl(); const FunctionProtoType *Proto1 = FD1->getType()->getAs(); const FunctionProtoType *Proto2 = FD2->getType()->getAs(); assert(Proto1 && Proto2 && "Function templates must have prototypes"); TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); SmallVector Deduced; Deduced.resize(TemplateParams->size()); // C++0x [temp.deduct.partial]p3: // The types used to determine the ordering depend on the context in which // the partial ordering is done: TemplateDeductionInfo Info(Loc); SmallVector Args2; switch (TPOC) { case TPOC_Call: { // - In the context of a function call, the function parameter types are // used. CXXMethodDecl *Method1 = dyn_cast(FD1); CXXMethodDecl *Method2 = dyn_cast(FD2); // C++11 [temp.func.order]p3: // [...] If only one of the function templates is a non-static // member, that function template is considered to have a new // first parameter inserted in its function parameter list. The // new parameter is of type "reference to cv A," where cv are // the cv-qualifiers of the function template (if any) and A is // the class of which the function template is a member. // // Note that we interpret this to mean "if one of the function // templates is a non-static member and the other is a non-member"; // otherwise, the ordering rules for static functions against non-static // functions don't make any sense. // // C++98/03 doesn't have this provision but we've extended DR532 to cover // it as wording was broken prior to it. SmallVector Args1; unsigned NumComparedArguments = NumCallArguments1; if (!Method2 && Method1 && !Method1->isStatic()) { // Compare 'this' from Method1 against first parameter from Method2. AddImplicitObjectParameterType(S.Context, Method1, Args1); ++NumComparedArguments; } else if (!Method1 && Method2 && !Method2->isStatic()) { // Compare 'this' from Method2 against first parameter from Method1. AddImplicitObjectParameterType(S.Context, Method2, Args2); } Args1.insert(Args1.end(), Proto1->param_type_begin(), Proto1->param_type_end()); Args2.insert(Args2.end(), Proto2->param_type_begin(), Proto2->param_type_end()); // C++ [temp.func.order]p5: // The presence of unused ellipsis and default arguments has no effect on // the partial ordering of function templates. if (Args1.size() > NumComparedArguments) Args1.resize(NumComparedArguments); if (Args2.size() > NumComparedArguments) Args2.resize(NumComparedArguments); if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(), Args1.data(), Args1.size(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; } case TPOC_Conversion: // - In the context of a call to a conversion operator, the return types // of the conversion function templates are used. if (DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; case TPOC_Other: // - In other contexts (14.6.6.2) the function template's function type // is used. if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, FD2->getType(), FD1->getType(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; } // C++0x [temp.deduct.partial]p11: // In most cases, all template parameters must have values in order for // deduction to succeed, but for partial ordering purposes a template // parameter may remain without a value provided it is not used in the // types being used for partial ordering. [ Note: a template parameter used // in a non-deduced context is considered used. -end note] unsigned ArgIdx = 0, NumArgs = Deduced.size(); for (; ArgIdx != NumArgs; ++ArgIdx) if (Deduced[ArgIdx].isNull()) break; if (ArgIdx == NumArgs) { // All template arguments were deduced. FT1 is at least as specialized // as FT2. return true; } // Figure out which template parameters were used. llvm::SmallBitVector UsedParameters(TemplateParams->size()); switch (TPOC) { case TPOC_Call: for (unsigned I = 0, N = Args2.size(); I != N; ++I) ::MarkUsedTemplateParameters(S.Context, Args2[I], false, TemplateParams->getDepth(), UsedParameters); break; case TPOC_Conversion: ::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), false, TemplateParams->getDepth(), UsedParameters); break; case TPOC_Other: ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false, TemplateParams->getDepth(), UsedParameters); break; } for (; ArgIdx != NumArgs; ++ArgIdx) // If this argument had no value deduced but was used in one of the types // used for partial ordering, then deduction fails. if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) return false; return true; } /// \brief Determine whether this a function template whose parameter-type-list /// ends with a function parameter pack. static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { FunctionDecl *Function = FunTmpl->getTemplatedDecl(); unsigned NumParams = Function->getNumParams(); if (NumParams == 0) return false; ParmVarDecl *Last = Function->getParamDecl(NumParams - 1); if (!Last->isParameterPack()) return false; // Make sure that no previous parameter is a parameter pack. while (--NumParams > 0) { if (Function->getParamDecl(NumParams - 1)->isParameterPack()) return false; } return true; } /// \brief Returns the more specialized function template according /// to the rules of function template partial ordering (C++ [temp.func.order]). /// /// \param FT1 the first function template /// /// \param FT2 the second function template /// /// \param TPOC the context in which we are performing partial ordering of /// function templates. /// /// \param NumCallArguments1 The number of arguments in the call to FT1, used /// only when \c TPOC is \c TPOC_Call. /// /// \param NumCallArguments2 The number of arguments in the call to FT2, used /// only when \c TPOC is \c TPOC_Call. /// /// \returns the more specialized function template. If neither /// template is more specialized, returns NULL. FunctionTemplateDecl * Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, unsigned NumCallArguments2) { SmallVector RefParamComparisons; bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, NumCallArguments1, nullptr); bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, NumCallArguments2, &RefParamComparisons); if (Better1 != Better2) // We have a clear winner return Better1? FT1 : FT2; if (!Better1 && !Better2) // Neither is better than the other return nullptr; // C++0x [temp.deduct.partial]p10: // If for each type being considered a given template is at least as // specialized for all types and more specialized for some set of types and // the other template is not more specialized for any types or is not at // least as specialized for any types, then the given template is more // specialized than the other template. Otherwise, neither template is more // specialized than the other. Better1 = false; Better2 = false; for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) { // C++0x [temp.deduct.partial]p9: // If, for a given type, deduction succeeds in both directions (i.e., the // types are identical after the transformations above) and both P and A // were reference types (before being replaced with the type referred to // above): // -- if the type from the argument template was an lvalue reference // and the type from the parameter template was not, the argument // type is considered to be more specialized than the other; // otherwise, if (!RefParamComparisons[I].ArgIsRvalueRef && RefParamComparisons[I].ParamIsRvalueRef) { Better2 = true; if (Better1) return nullptr; continue; } else if (!RefParamComparisons[I].ParamIsRvalueRef && RefParamComparisons[I].ArgIsRvalueRef) { Better1 = true; if (Better2) return nullptr; continue; } // -- if the type from the argument template is more cv-qualified than // the type from the parameter template (as described above), the // argument type is considered to be more specialized than the // other; otherwise, switch (RefParamComparisons[I].Qualifiers) { case NeitherMoreQualified: break; case ParamMoreQualified: Better1 = true; if (Better2) return nullptr; continue; case ArgMoreQualified: Better2 = true; if (Better1) return nullptr; continue; } // -- neither type is more specialized than the other. } assert(!(Better1 && Better2) && "Should have broken out in the loop above"); if (Better1) return FT1; else if (Better2) return FT2; // FIXME: This mimics what GCC implements, but doesn't match up with the // proposed resolution for core issue 692. This area needs to be sorted out, // but for now we attempt to maintain compatibility. bool Variadic1 = isVariadicFunctionTemplate(FT1); bool Variadic2 = isVariadicFunctionTemplate(FT2); if (Variadic1 != Variadic2) return Variadic1? FT2 : FT1; return nullptr; } /// \brief Determine if the two templates are equivalent. static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { if (T1 == T2) return true; if (!T1 || !T2) return false; return T1->getCanonicalDecl() == T2->getCanonicalDecl(); } /// \brief Retrieve the most specialized of the given function template /// specializations. /// /// \param SpecBegin the start iterator of the function template /// specializations that we will be comparing. /// /// \param SpecEnd the end iterator of the function template /// specializations, paired with \p SpecBegin. /// /// \param Loc the location where the ambiguity or no-specializations /// diagnostic should occur. /// /// \param NoneDiag partial diagnostic used to diagnose cases where there are /// no matching candidates. /// /// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one /// occurs. /// /// \param CandidateDiag partial diagnostic used for each function template /// specialization that is a candidate in the ambiguous ordering. One parameter /// in this diagnostic should be unbound, which will correspond to the string /// describing the template arguments for the function template specialization. /// /// \returns the most specialized function template specialization, if /// found. Otherwise, returns SpecEnd. UnresolvedSetIterator Sema::getMostSpecialized( UnresolvedSetIterator SpecBegin, UnresolvedSetIterator SpecEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain, QualType TargetType) { if (SpecBegin == SpecEnd) { if (Complain) { Diag(Loc, NoneDiag); FailedCandidates.NoteCandidates(*this, Loc); } return SpecEnd; } if (SpecBegin + 1 == SpecEnd) return SpecBegin; // Find the function template that is better than all of the templates it // has been compared to. UnresolvedSetIterator Best = SpecBegin; FunctionTemplateDecl *BestTemplate = cast(*Best)->getPrimaryTemplate(); assert(BestTemplate && "Not a function template specialization?"); for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) { FunctionTemplateDecl *Challenger = cast(*I)->getPrimaryTemplate(); assert(Challenger && "Not a function template specialization?"); if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, Loc, TPOC_Other, 0, 0), Challenger)) { Best = I; BestTemplate = Challenger; } } // Make sure that the "best" function template is more specialized than all // of the others. bool Ambiguous = false; for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { FunctionTemplateDecl *Challenger = cast(*I)->getPrimaryTemplate(); if (I != Best && !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, Loc, TPOC_Other, 0, 0), BestTemplate)) { Ambiguous = true; break; } } if (!Ambiguous) { // We found an answer. Return it. return Best; } // Diagnose the ambiguity. if (Complain) { Diag(Loc, AmbigDiag); // FIXME: Can we order the candidates in some sane way? for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { PartialDiagnostic PD = CandidateDiag; PD << getTemplateArgumentBindingsText( cast(*I)->getPrimaryTemplate()->getTemplateParameters(), *cast(*I)->getTemplateSpecializationArgs()); if (!TargetType.isNull()) HandleFunctionTypeMismatch(PD, cast(*I)->getType(), TargetType); Diag((*I)->getLocation(), PD); } } return SpecEnd; } /// \brief Returns the more specialized class template partial specialization /// according to the rules of partial ordering of class template partial /// specializations (C++ [temp.class.order]). /// /// \param PS1 the first class template partial specialization /// /// \param PS2 the second class template partial specialization /// /// \returns the more specialized class template partial specialization. If /// neither partial specialization is more specialized, returns NULL. ClassTemplatePartialSpecializationDecl * Sema::getMoreSpecializedPartialSpecialization( ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { // C++ [temp.class.order]p1: // For two class template partial specializations, the first is at least as // specialized as the second if, given the following rewrite to two // function templates, the first function template is at least as // specialized as the second according to the ordering rules for function // templates (14.6.6.2): // - the first function template has the same template parameters as the // first partial specialization and has a single function parameter // whose type is a class template specialization with the template // arguments of the first partial specialization, and // - the second function template has the same template parameters as the // second partial specialization and has a single function parameter // whose type is a class template specialization with the template // arguments of the second partial specialization. // // Rather than synthesize function templates, we merely perform the // equivalent partial ordering by performing deduction directly on // the template arguments of the class template partial // specializations. This computation is slightly simpler than the // general problem of function template partial ordering, because // class template partial specializations are more constrained. We // know that every template parameter is deducible from the class // template partial specialization's template arguments, for // example. SmallVector Deduced; TemplateDeductionInfo Info(Loc); QualType PT1 = PS1->getInjectedSpecializationType(); QualType PT2 = PS2->getInjectedSpecializationType(); // Determine whether PS1 is at least as specialized as PS2 Deduced.resize(PS2->getTemplateParameters()->size()); bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/nullptr); if (Better1) { SmallVector DeducedArgs(Deduced.begin(),Deduced.end()); InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info); Better1 = !::FinishTemplateArgumentDeduction( *this, PS2, PS1->getTemplateArgs(), Deduced, Info); } // Determine whether PS2 is at least as specialized as PS1 Deduced.clear(); Deduced.resize(PS1->getTemplateParameters()->size()); bool Better2 = !DeduceTemplateArgumentsByTypeMatch( *this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/nullptr); if (Better2) { SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info); Better2 = !::FinishTemplateArgumentDeduction( *this, PS1, PS2->getTemplateArgs(), Deduced, Info); } if (Better1 == Better2) return nullptr; return Better1 ? PS1 : PS2; } /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. VarTemplatePartialSpecializationDecl * Sema::getMoreSpecializedPartialSpecialization( VarTemplatePartialSpecializationDecl *PS1, VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { SmallVector Deduced; TemplateDeductionInfo Info(Loc); assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() && "the partial specializations being compared should specialize" " the same template."); TemplateName Name(PS1->getSpecializedTemplate()); TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name); QualType PT1 = Context.getTemplateSpecializationType( CanonTemplate, PS1->getTemplateArgs().data(), PS1->getTemplateArgs().size()); QualType PT2 = Context.getTemplateSpecializationType( CanonTemplate, PS2->getTemplateArgs().data(), PS2->getTemplateArgs().size()); // Determine whether PS1 is at least as specialized as PS2 Deduced.resize(PS2->getTemplateParameters()->size()); bool Better1 = !DeduceTemplateArgumentsByTypeMatch( *this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/nullptr); if (Better1) { SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info); Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, PS1->getTemplateArgs(), Deduced, Info); } // Determine whether PS2 is at least as specialized as PS1 Deduced.clear(); Deduced.resize(PS1->getTemplateParameters()->size()); bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/nullptr); if (Better2) { SmallVector DeducedArgs(Deduced.begin(),Deduced.end()); InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info); Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, PS2->getTemplateArgs(), Deduced, Info); } if (Better1 == Better2) return nullptr; return Better1? PS1 : PS2; } static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used); /// \brief Mark the template parameters that are used by the given /// expression. static void MarkUsedTemplateParameters(ASTContext &Ctx, const Expr *E, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { // We can deduce from a pack expansion. if (const PackExpansionExpr *Expansion = dyn_cast(E)) E = Expansion->getPattern(); // Skip through any implicit casts we added while type-checking, and any // substitutions performed by template alias expansion. while (1) { if (const ImplicitCastExpr *ICE = dyn_cast(E)) E = ICE->getSubExpr(); else if (const SubstNonTypeTemplateParmExpr *Subst = dyn_cast(E)) E = Subst->getReplacement(); else break; } // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to // find other occurrences of template parameters. const DeclRefExpr *DRE = dyn_cast(E); if (!DRE) return; const NonTypeTemplateParmDecl *NTTP = dyn_cast(DRE->getDecl()); if (!NTTP) return; if (NTTP->getDepth() == Depth) Used[NTTP->getIndex()] = true; } /// \brief Mark the template parameters that are used by the given /// nested name specifier. static void MarkUsedTemplateParameters(ASTContext &Ctx, NestedNameSpecifier *NNS, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (!NNS) return; MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0), OnlyDeduced, Depth, Used); } /// \brief Mark the template parameters that are used by the given /// template name. static void MarkUsedTemplateParameters(ASTContext &Ctx, TemplateName Name, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (TemplateDecl *Template = Name.getAsTemplateDecl()) { if (TemplateTemplateParmDecl *TTP = dyn_cast(Template)) { if (TTP->getDepth() == Depth) Used[TTP->getIndex()] = true; } return; } if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced, Depth, Used); if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced, Depth, Used); } /// \brief Mark the template parameters that are used by the given /// type. static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (T.isNull()) return; // Non-dependent types have nothing deducible if (!T->isDependentType()) return; T = Ctx.getCanonicalType(T); switch (T->getTypeClass()) { case Type::Pointer: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::BlockPointer: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::LValueReference: case Type::RValueReference: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::MemberPointer: { const MemberPointerType *MemPtr = cast(T.getTypePtr()); MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0), OnlyDeduced, Depth, Used); break; } case Type::DependentSizedArray: MarkUsedTemplateParameters(Ctx, cast(T)->getSizeExpr(), OnlyDeduced, Depth, Used); // Fall through to check the element type case Type::ConstantArray: case Type::IncompleteArray: MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::Vector: case Type::ExtVector: MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::DependentSizedExtVector: { const DependentSizedExtVectorType *VecType = cast(T); MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, Depth, Used); break; } case Type::FunctionProto: { const FunctionProtoType *Proto = cast(T); MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth, Used); for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced, Depth, Used); break; } case Type::TemplateTypeParm: { const TemplateTypeParmType *TTP = cast(T); if (TTP->getDepth() == Depth) Used[TTP->getIndex()] = true; break; } case Type::SubstTemplateTypeParmPack: { const SubstTemplateTypeParmPackType *Subst = cast(T); MarkUsedTemplateParameters(Ctx, QualType(Subst->getReplacedParameter(), 0), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(), OnlyDeduced, Depth, Used); break; } case Type::InjectedClassName: T = cast(T)->getInjectedSpecializationType(); // fall through case Type::TemplateSpecialization: { const TemplateSpecializationType *Spec = cast(T); MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced, Depth, Used); // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is // not the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) break; for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, Used); break; } case Type::Complex: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::Atomic: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getValueType(), OnlyDeduced, Depth, Used); break; case Type::DependentName: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getQualifier(), OnlyDeduced, Depth, Used); break; case Type::DependentTemplateSpecialization: { const DependentTemplateSpecializationType *Spec = cast(T); if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, Spec->getQualifier(), OnlyDeduced, Depth, Used); // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) break; for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, Used); break; } case Type::TypeOf: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingType(), OnlyDeduced, Depth, Used); break; case Type::TypeOfExpr: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingExpr(), OnlyDeduced, Depth, Used); break; case Type::Decltype: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingExpr(), OnlyDeduced, Depth, Used); break; case Type::UnaryTransform: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingType(), OnlyDeduced, Depth, Used); break; case Type::PackExpansion: MarkUsedTemplateParameters(Ctx, cast(T)->getPattern(), OnlyDeduced, Depth, Used); break; case Type::Auto: MarkUsedTemplateParameters(Ctx, cast(T)->getDeducedType(), OnlyDeduced, Depth, Used); // None of these types have any template parameters in them. case Type::Builtin: case Type::VariableArray: case Type::FunctionNoProto: case Type::Record: case Type::Enum: case Type::ObjCInterface: case Type::ObjCObject: case Type::ObjCObjectPointer: case Type::UnresolvedUsing: #define TYPE(Class, Base) #define ABSTRACT_TYPE(Class, Base) #define DEPENDENT_TYPE(Class, Base) #define NON_CANONICAL_TYPE(Class, Base) case Type::Class: #include "clang/AST/TypeNodes.def" break; } } /// \brief Mark the template parameters that are used by this /// template argument. static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { switch (TemplateArg.getKind()) { case TemplateArgument::Null: case TemplateArgument::Integral: case TemplateArgument::Declaration: break; case TemplateArgument::NullPtr: MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Type: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsTemplateOrTemplatePattern(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Expression: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Pack: for (const auto &P : TemplateArg.pack_elements()) MarkUsedTemplateParameters(Ctx, P, OnlyDeduced, Depth, Used); break; } } /// \brief Mark which template parameters can be deduced from a given /// template argument list. /// /// \param TemplateArgs the template argument list from which template /// parameters will be deduced. /// /// \param Used a bit vector whose elements will be set to \c true /// to indicate when the corresponding template parameter will be /// deduced. void Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size())) return; for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced, Depth, Used); } /// \brief Marks all of the template parameters that will be deduced by a /// call to the given function template. void Sema::MarkDeducedTemplateParameters( ASTContext &Ctx, const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced) { TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); Deduced.clear(); Deduced.resize(TemplateParams->size()); FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(), true, TemplateParams->getDepth(), Deduced); } bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T) { if (!T->isDependentType()) return false; TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); llvm::SmallBitVector Deduced(TemplateParams->size()); ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), Deduced); return Deduced.any(); } @ 1.1.1.5.4.1 log @file SemaTemplateDeduction.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:30 +0000 @ text @d1 5130 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 5130 //===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/ // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. //===----------------------------------------------------------------------===/ // // This file implements C++ template argument deduction. // //===----------------------------------------------------------------------===/ #include "clang/Sema/TemplateDeduction.h" #include "TreeTransform.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTLambda.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/StmtVisitor.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/Sema.h" #include "clang/Sema/Template.h" #include "llvm/ADT/SmallBitVector.h" #include namespace clang { using namespace sema; /// \brief Various flags that control template argument deduction. /// /// These flags can be bitwise-OR'd together. enum TemplateDeductionFlags { /// \brief No template argument deduction flags, which indicates the /// strictest results for template argument deduction (as used for, e.g., /// matching class template partial specializations). TDF_None = 0, /// \brief Within template argument deduction from a function call, we are /// matching with a parameter type for which the original parameter was /// a reference. TDF_ParamWithReferenceType = 0x1, /// \brief Within template argument deduction from a function call, we /// are matching in a case where we ignore cv-qualifiers. TDF_IgnoreQualifiers = 0x02, /// \brief Within template argument deduction from a function call, /// we are matching in a case where we can perform template argument /// deduction from a template-id of a derived class of the argument type. TDF_DerivedClass = 0x04, /// \brief Allow non-dependent types to differ, e.g., when performing /// template argument deduction from a function call where conversions /// may apply. TDF_SkipNonDependent = 0x08, /// \brief Whether we are performing template argument deduction for /// parameters and arguments in a top-level template argument TDF_TopLevelParameterTypeList = 0x10, /// \brief Within template argument deduction from overload resolution per /// C++ [over.over] allow matching function types that are compatible in /// terms of noreturn and default calling convention adjustments. TDF_InOverloadResolution = 0x20 }; } using namespace clang; /// \brief Compare two APSInts, extending and switching the sign as /// necessary to compare their values regardless of underlying type. static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { if (Y.getBitWidth() > X.getBitWidth()) X = X.extend(Y.getBitWidth()); else if (Y.getBitWidth() < X.getBitWidth()) Y = Y.extend(X.getBitWidth()); // If there is a signedness mismatch, correct it. if (X.isSigned() != Y.isSigned()) { // If the signed value is negative, then the values cannot be the same. if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) return false; Y.setIsSigned(true); X.setIsSigned(true); } return X == Y; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced); /// \brief Whether template argument deduction for two reference parameters /// resulted in the argument type, parameter type, or neither type being more /// qualified than the other. enum DeductionQualifierComparison { NeitherMoreQualified = 0, ParamMoreQualified, ArgMoreQualified }; /// \brief Stores the result of comparing two reference parameters while /// performing template argument deduction for partial ordering of function /// templates. struct RefParamPartialOrderingComparison { /// \brief Whether the parameter type is an rvalue reference type. bool ParamIsRvalueRef; /// \brief Whether the argument type is an rvalue reference type. bool ArgIsRvalueRef; /// \brief Whether the parameter or argument (or neither) is more qualified. DeductionQualifierComparison Qualifiers; }; static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl & Deduced, unsigned TDF, bool PartialOrdering = false, SmallVectorImpl * RefParamComparisons = 0); static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument *Params, unsigned NumParams, const TemplateArgument *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced); /// \brief If the given expression is of a form that permits the deduction /// of a non-type template parameter, return the declaration of that /// non-type template parameter. static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { // If we are within an alias template, the expression may have undergone // any number of parameter substitutions already. while (1) { if (ImplicitCastExpr *IC = dyn_cast(E)) E = IC->getSubExpr(); else if (SubstNonTypeTemplateParmExpr *Subst = dyn_cast(E)) E = Subst->getReplacement(); else break; } if (DeclRefExpr *DRE = dyn_cast(E)) return dyn_cast(DRE->getDecl()); return 0; } /// \brief Determine whether two declaration pointers refer to the same /// declaration. static bool isSameDeclaration(Decl *X, Decl *Y) { if (NamedDecl *NX = dyn_cast(X)) X = NX->getUnderlyingDecl(); if (NamedDecl *NY = dyn_cast(Y)) Y = NY->getUnderlyingDecl(); return X->getCanonicalDecl() == Y->getCanonicalDecl(); } /// \brief Verify that the given, deduced template arguments are compatible. /// /// \returns The deduced template argument, or a NULL template argument if /// the deduced template arguments were incompatible. static DeducedTemplateArgument checkDeducedTemplateArguments(ASTContext &Context, const DeducedTemplateArgument &X, const DeducedTemplateArgument &Y) { // We have no deduction for one or both of the arguments; they're compatible. if (X.isNull()) return Y; if (Y.isNull()) return X; switch (X.getKind()) { case TemplateArgument::Null: llvm_unreachable("Non-deduced template arguments handled above"); case TemplateArgument::Type: // If two template type arguments have the same type, they're compatible. if (Y.getKind() == TemplateArgument::Type && Context.hasSameType(X.getAsType(), Y.getAsType())) return X; return DeducedTemplateArgument(); case TemplateArgument::Integral: // If we deduced a constant in one case and either a dependent expression or // declaration in another case, keep the integral constant. // If both are integral constants with the same value, keep that value. if (Y.getKind() == TemplateArgument::Expression || Y.getKind() == TemplateArgument::Declaration || (Y.getKind() == TemplateArgument::Integral && hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()))) return DeducedTemplateArgument(X, X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Template: if (Y.getKind() == TemplateArgument::Template && Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::TemplateExpansion: if (Y.getKind() == TemplateArgument::TemplateExpansion && Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), Y.getAsTemplateOrTemplatePattern())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Expression: // If we deduced a dependent expression in one case and either an integral // constant or a declaration in another case, keep the integral constant // or declaration. if (Y.getKind() == TemplateArgument::Integral || Y.getKind() == TemplateArgument::Declaration) return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); if (Y.getKind() == TemplateArgument::Expression) { // Compare the expressions for equality llvm::FoldingSetNodeID ID1, ID2; X.getAsExpr()->Profile(ID1, Context, true); Y.getAsExpr()->Profile(ID2, Context, true); if (ID1 == ID2) return X; } // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Declaration: // If we deduced a declaration and a dependent expression, keep the // declaration. if (Y.getKind() == TemplateArgument::Expression) return X; // If we deduced a declaration and an integral constant, keep the // integral constant. if (Y.getKind() == TemplateArgument::Integral) return Y; // If we deduced two declarations, make sure they they refer to the // same declaration. if (Y.getKind() == TemplateArgument::Declaration && isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && X.isDeclForReferenceParam() == Y.isDeclForReferenceParam()) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::NullPtr: // If we deduced a null pointer and a dependent expression, keep the // null pointer. if (Y.getKind() == TemplateArgument::Expression) return X; // If we deduced a null pointer and an integral constant, keep the // integral constant. if (Y.getKind() == TemplateArgument::Integral) return Y; // If we deduced two null pointers, make sure they have the same type. if (Y.getKind() == TemplateArgument::NullPtr && Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType())) return X; // All other combinations are incompatible. return DeducedTemplateArgument(); case TemplateArgument::Pack: if (Y.getKind() != TemplateArgument::Pack || X.pack_size() != Y.pack_size()) return DeducedTemplateArgument(); for (TemplateArgument::pack_iterator XA = X.pack_begin(), XAEnd = X.pack_end(), YA = Y.pack_begin(); XA != XAEnd; ++XA, ++YA) { if (checkDeducedTemplateArguments(Context, DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) .isNull()) return DeducedTemplateArgument(); } return X; } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Deduce the value of the given non-type template parameter /// from the given constant. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, llvm::APSInt Value, QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType, DeducedFromArrayBound); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } /// \brief Deduce the value of the given non-type template parameter /// from the given type- or value-dependent expression. /// /// \returns true if deduction succeeded, false otherwise. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, Expr *Value, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); assert((Value->isTypeDependent() || Value->isValueDependent()) && "Expression template argument must be type- or value-dependent."); DeducedTemplateArgument NewDeduced(Value); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } /// \brief Deduce the value of the given non-type template parameter /// from the given declaration. /// /// \returns true if deduction succeeded, false otherwise. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, NonTypeTemplateParmDecl *NTTP, ValueDecl *D, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); D = D ? cast(D->getCanonicalDecl()) : 0; TemplateArgument New(D, NTTP->getType()->isReferenceType()); DeducedTemplateArgument NewDeduced(New); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[NTTP->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = NTTP; Info.FirstArg = Deduced[NTTP->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[NTTP->getIndex()] = Result; return Sema::TDK_Success; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, TemplateName Param, TemplateName Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); if (!ParamDecl) { // The parameter type is dependent and is not a template template parameter, // so there is nothing that we can deduce. return Sema::TDK_Success; } if (TemplateTemplateParmDecl *TempParam = dyn_cast(ParamDecl)) { DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[TempParam->getIndex()], NewDeduced); if (Result.isNull()) { Info.Param = TempParam; Info.FirstArg = Deduced[TempParam->getIndex()]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[TempParam->getIndex()] = Result; return Sema::TDK_Success; } // Verify that the two template names are equivalent. if (S.Context.hasSameTemplateName(Param, Arg)) return Sema::TDK_Success; // Mismatch of non-dependent template parameter to argument. Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } /// \brief Deduce the template arguments by comparing the template parameter /// type (which is a template-id) with the template argument type. /// /// \param S the Sema /// /// \param TemplateParams the template parameters that we are deducing /// /// \param Param the parameter type /// /// \param Arg the argument type /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateSpecializationType *Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { assert(Arg.isCanonical() && "Argument type must be canonical"); // Check whether the template argument is a dependent template-id. if (const TemplateSpecializationType *SpecArg = dyn_cast(Arg)) { // Perform template argument deduction for the template name. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Param->getTemplateName(), SpecArg->getTemplateName(), Info, Deduced)) return Result; // Perform template argument deduction on each template // argument. Ignore any missing/extra arguments, since they could be // filled in by default arguments. return DeduceTemplateArguments(S, TemplateParams, Param->getArgs(), Param->getNumArgs(), SpecArg->getArgs(), SpecArg->getNumArgs(), Info, Deduced); } // If the argument type is a class template specialization, we // perform template argument deduction using its template // arguments. const RecordType *RecordArg = dyn_cast(Arg); if (!RecordArg) { Info.FirstArg = TemplateArgument(QualType(Param, 0)); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } ClassTemplateSpecializationDecl *SpecArg = dyn_cast(RecordArg->getDecl()); if (!SpecArg) { Info.FirstArg = TemplateArgument(QualType(Param, 0)); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_NonDeducedMismatch; } // Perform template argument deduction for the template name. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Param->getTemplateName(), TemplateName(SpecArg->getSpecializedTemplate()), Info, Deduced)) return Result; // Perform template argument deduction for the template arguments. return DeduceTemplateArguments(S, TemplateParams, Param->getArgs(), Param->getNumArgs(), SpecArg->getTemplateArgs().data(), SpecArg->getTemplateArgs().size(), Info, Deduced); } /// \brief Determines whether the given type is an opaque type that /// might be more qualified when instantiated. static bool IsPossiblyOpaquelyQualifiedType(QualType T) { switch (T->getTypeClass()) { case Type::TypeOfExpr: case Type::TypeOf: case Type::DependentName: case Type::Decltype: case Type::UnresolvedUsing: case Type::TemplateTypeParm: return true; case Type::ConstantArray: case Type::IncompleteArray: case Type::VariableArray: case Type::DependentSizedArray: return IsPossiblyOpaquelyQualifiedType( cast(T)->getElementType()); default: return false; } } /// \brief Retrieve the depth and index of a template parameter. static std::pair getDepthAndIndex(NamedDecl *ND) { if (TemplateTypeParmDecl *TTP = dyn_cast(ND)) return std::make_pair(TTP->getDepth(), TTP->getIndex()); if (NonTypeTemplateParmDecl *NTTP = dyn_cast(ND)) return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); TemplateTemplateParmDecl *TTP = cast(ND); return std::make_pair(TTP->getDepth(), TTP->getIndex()); } /// \brief Retrieve the depth and index of an unexpanded parameter pack. static std::pair getDepthAndIndex(UnexpandedParameterPack UPP) { if (const TemplateTypeParmType *TTP = UPP.first.dyn_cast()) return std::make_pair(TTP->getDepth(), TTP->getIndex()); return getDepthAndIndex(UPP.first.get()); } /// \brief Helper function to build a TemplateParameter when we don't /// know its type statically. static TemplateParameter makeTemplateParameter(Decl *D) { if (TemplateTypeParmDecl *TTP = dyn_cast(D)) return TemplateParameter(TTP); if (NonTypeTemplateParmDecl *NTTP = dyn_cast(D)) return TemplateParameter(NTTP); return TemplateParameter(cast(D)); } typedef SmallVector, 2> NewlyDeducedPacksType; /// \brief Prepare to perform template argument deduction for all of the /// arguments in a set of argument packs. static void PrepareArgumentPackDeduction(Sema &S, SmallVectorImpl &Deduced, ArrayRef PackIndices, SmallVectorImpl &SavedPacks, NewlyDeducedPacksType &NewlyDeducedPacks) { // Save the deduced template arguments for each parameter pack expanded // by this pack expansion, then clear out the deduction. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { // Save the previously-deduced argument pack, then clear it out so that we // can deduce a new argument pack. SavedPacks[I] = Deduced[PackIndices[I]]; Deduced[PackIndices[I]] = TemplateArgument(); if (!S.CurrentInstantiationScope) continue; // If the template argument pack was explicitly specified, add that to // the set of deduced arguments. const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; if (NamedDecl *PartiallySubstitutedPack = S.CurrentInstantiationScope->getPartiallySubstitutedPack( &ExplicitArgs, &NumExplicitArgs)) { if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I]) NewlyDeducedPacks[I].append(ExplicitArgs, ExplicitArgs + NumExplicitArgs); } } } /// \brief Finish template argument deduction for a set of argument packs, /// producing the argument packs and checking for consistency with prior /// deductions. static Sema::TemplateDeductionResult FinishArgumentPackDeduction(Sema &S, TemplateParameterList *TemplateParams, bool HasAnyArguments, SmallVectorImpl &Deduced, ArrayRef PackIndices, SmallVectorImpl &SavedPacks, NewlyDeducedPacksType &NewlyDeducedPacks, TemplateDeductionInfo &Info) { // Build argument packs for each of the parameter packs expanded by this // pack expansion. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { // We were not able to deduce anything for this parameter pack, // so just restore the saved argument pack. Deduced[PackIndices[I]] = SavedPacks[I]; continue; } DeducedTemplateArgument NewPack; if (NewlyDeducedPacks[I].empty()) { // If we deduced an empty argument pack, create it now. NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); } else { TemplateArgument *ArgumentPack = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), ArgumentPack); NewPack = DeducedTemplateArgument(TemplateArgument(ArgumentPack, NewlyDeducedPacks[I].size()), NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); } DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); if (Result.isNull()) { Info.Param = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); Info.FirstArg = SavedPacks[I]; Info.SecondArg = NewPack; return Sema::TDK_Inconsistent; } Deduced[PackIndices[I]] = Result; } return Sema::TDK_Success; } /// \brief Deduce the template arguments by comparing the list of parameter /// types to the list of argument types, as in the parameter-type-lists of /// function types (C++ [temp.deduct.type]p10). /// /// \param S The semantic analysis object within which we are deducing /// /// \param TemplateParams The template parameters that we are deducing /// /// \param Params The list of parameter types /// /// \param NumParams The number of types in \c Params /// /// \param Args The list of argument types /// /// \param NumArgs The number of types in \c Args /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe /// how template argument deduction is performed. /// /// \param PartialOrdering If true, we are performing template argument /// deduction for during partial ordering for a call /// (C++0x [temp.deduct.partial]). /// /// \param RefParamComparisons If we're performing template argument deduction /// in the context of partial ordering, the set of qualifier comparisons. /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const QualType *Params, unsigned NumParams, const QualType *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF, bool PartialOrdering = false, SmallVectorImpl * RefParamComparisons = 0) { // Fast-path check to see if we have too many/too few arguments. if (NumParams != NumArgs && !(NumParams && isa(Params[NumParams - 1])) && !(NumArgs && isa(Args[NumArgs - 1]))) return Sema::TDK_MiscellaneousDeductionFailure; // C++0x [temp.deduct.type]p10: // Similarly, if P has a form that contains (T), then each parameter type // Pi of the respective parameter-type- list of P is compared with the // corresponding parameter type Ai of the corresponding parameter-type-list // of A. [...] unsigned ArgIdx = 0, ParamIdx = 0; for (; ParamIdx != NumParams; ++ParamIdx) { // Check argument types. const PackExpansionType *Expansion = dyn_cast(Params[ParamIdx]); if (!Expansion) { // Simple case: compare the parameter and argument types at this point. // Make sure we have an argument. if (ArgIdx >= NumArgs) return Sema::TDK_MiscellaneousDeductionFailure; if (isa(Args[ArgIdx])) { // C++0x [temp.deduct.type]p22: // If the original function parameter associated with A is a function // parameter pack and the function parameter associated with P is not // a function parameter pack, then template argument deduction fails. return Sema::TDK_MiscellaneousDeductionFailure; } if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Params[ParamIdx], Args[ArgIdx], Info, Deduced, TDF, PartialOrdering, RefParamComparisons)) return Result; ++ArgIdx; continue; } // C++0x [temp.deduct.type]p5: // The non-deduced contexts are: // - A function parameter pack that does not occur at the end of the // parameter-declaration-clause. if (ParamIdx + 1 < NumParams) return Sema::TDK_Success; // C++0x [temp.deduct.type]p10: // If the parameter-declaration corresponding to Pi is a function // parameter pack, then the type of its declarator- id is compared with // each remaining parameter type in the parameter-type-list of A. Each // comparison deduces template arguments for subsequent positions in the // template parameter packs expanded by the function parameter pack. // Compute the set of template parameter indices that correspond to // parameter packs expanded by the pack expansion. SmallVector PackIndices; QualType Pattern = Expansion->getPattern(); { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; S.collectUnexpandedParameterPacks(Pattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; PackIndices.push_back(Index); } } } assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); // Keep track of the deduced template arguments for each parameter pack // expanded by this pack expansion (the outer index) and for each // template argument (the inner SmallVectors). NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); SmallVector SavedPacks(PackIndices.size()); PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks); bool HasAnyArguments = false; for (; ArgIdx < NumArgs; ++ArgIdx) { HasAnyArguments = true; // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced, TDF, PartialOrdering, RefParamComparisons)) return Result; // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; if (!DeducedArg.isNull()) { NewlyDeducedPacks[I].push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } } } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (Sema::TemplateDeductionResult Result = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks, Info)) return Result; } // Make sure we don't have any extra arguments. if (ArgIdx < NumArgs) return Sema::TDK_MiscellaneousDeductionFailure; return Sema::TDK_Success; } /// \brief Determine whether the parameter has qualifiers that are either /// inconsistent with or a superset of the argument's qualifiers. static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, QualType ArgType) { Qualifiers ParamQs = ParamType.getQualifiers(); Qualifiers ArgQs = ArgType.getQualifiers(); if (ParamQs == ArgQs) return false; // Mismatched (but not missing) Objective-C GC attributes. if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && ParamQs.hasObjCGCAttr()) return true; // Mismatched (but not missing) address spaces. if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() && ParamQs.hasAddressSpace()) return true; // Mismatched (but not missing) Objective-C lifetime qualifiers. if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() && ParamQs.hasObjCLifetime()) return true; // CVR qualifier superset. return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) && ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers()) == ParamQs.getCVRQualifiers()); } /// \brief Compare types for equality with respect to possibly compatible /// function types (noreturn adjustment, implicit calling conventions). If any /// of parameter and argument is not a function, just perform type comparison. /// /// \param Param the template parameter type. /// /// \param Arg the argument type. bool Sema::isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg) { const FunctionType *ParamFunction = Param->getAs(), *ArgFunction = Arg->getAs(); // Just compare if not functions. if (!ParamFunction || !ArgFunction) return Param == Arg; // Noreturn adjustment. QualType AdjustedParam; if (IsNoReturnConversion(Param, Arg, AdjustedParam)) return Arg == Context.getCanonicalType(AdjustedParam); // FIXME: Compatible calling conventions. return Param == Arg; } /// \brief Deduce the template arguments by comparing the parameter type and /// the argument type (C++ [temp.deduct.type]). /// /// \param S the semantic analysis object within which we are deducing /// /// \param TemplateParams the template parameters that we are deducing /// /// \param ParamIn the parameter type /// /// \param ArgIn the argument type /// /// \param Info information about the template argument deduction itself /// /// \param Deduced the deduced template arguments /// /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe /// how template argument deduction is performed. /// /// \param PartialOrdering Whether we're performing template argument deduction /// in the context of partial ordering (C++0x [temp.deduct.partial]). /// /// \param RefParamComparisons If we're performing template argument deduction /// in the context of partial ordering, the set of qualifier comparisons. /// /// \returns the result of template argument deduction so far. Note that a /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType ParamIn, QualType ArgIn, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF, bool PartialOrdering, SmallVectorImpl * RefParamComparisons) { // We only want to look at the canonical types, since typedefs and // sugar are not part of template argument deduction. QualType Param = S.Context.getCanonicalType(ParamIn); QualType Arg = S.Context.getCanonicalType(ArgIn); // If the argument type is a pack expansion, look at its pattern. // This isn't explicitly called out if (const PackExpansionType *ArgExpansion = dyn_cast(Arg)) Arg = ArgExpansion->getPattern(); if (PartialOrdering) { // C++0x [temp.deduct.partial]p5: // Before the partial ordering is done, certain transformations are // performed on the types used for partial ordering: // - If P is a reference type, P is replaced by the type referred to. const ReferenceType *ParamRef = Param->getAs(); if (ParamRef) Param = ParamRef->getPointeeType(); // - If A is a reference type, A is replaced by the type referred to. const ReferenceType *ArgRef = Arg->getAs(); if (ArgRef) Arg = ArgRef->getPointeeType(); if (RefParamComparisons && ParamRef && ArgRef) { // C++0x [temp.deduct.partial]p6: // If both P and A were reference types (before being replaced with the // type referred to above), determine which of the two types (if any) is // more cv-qualified than the other; otherwise the types are considered // to be equally cv-qualified for partial ordering purposes. The result // of this determination will be used below. // // We save this information for later, using it only when deduction // succeeds in both directions. RefParamPartialOrderingComparison Comparison; Comparison.ParamIsRvalueRef = ParamRef->getAs(); Comparison.ArgIsRvalueRef = ArgRef->getAs(); Comparison.Qualifiers = NeitherMoreQualified; Qualifiers ParamQuals = Param.getQualifiers(); Qualifiers ArgQuals = Arg.getQualifiers(); if (ParamQuals.isStrictSupersetOf(ArgQuals)) Comparison.Qualifiers = ParamMoreQualified; else if (ArgQuals.isStrictSupersetOf(ParamQuals)) Comparison.Qualifiers = ArgMoreQualified; else if (ArgQuals.getObjCLifetime() != ParamQuals.getObjCLifetime() && ArgQuals.withoutObjCLifetime() == ParamQuals.withoutObjCLifetime()) { // Prefer binding to non-__unsafe_autoretained parameters. if (ArgQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && ParamQuals.getObjCLifetime()) Comparison.Qualifiers = ParamMoreQualified; else if (ParamQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && ArgQuals.getObjCLifetime()) Comparison.Qualifiers = ArgMoreQualified; } RefParamComparisons->push_back(Comparison); } // C++0x [temp.deduct.partial]p7: // Remove any top-level cv-qualifiers: // - If P is a cv-qualified type, P is replaced by the cv-unqualified // version of P. Param = Param.getUnqualifiedType(); // - If A is a cv-qualified type, A is replaced by the cv-unqualified // version of A. Arg = Arg.getUnqualifiedType(); } else { // C++0x [temp.deduct.call]p4 bullet 1: // - If the original P is a reference type, the deduced A (i.e., the type // referred to by the reference) can be more cv-qualified than the // transformed A. if (TDF & TDF_ParamWithReferenceType) { Qualifiers Quals; QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); Quals.setCVRQualifiers(Quals.getCVRQualifiers() & Arg.getCVRQualifiers()); Param = S.Context.getQualifiedType(UnqualParam, Quals); } if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) { // C++0x [temp.deduct.type]p10: // If P and A are function types that originated from deduction when // taking the address of a function template (14.8.2.2) or when deducing // template arguments from a function declaration (14.8.2.6) and Pi and // Ai are parameters of the top-level parameter-type-list of P and A, // respectively, Pi is adjusted if it is an rvalue reference to a // cv-unqualified template parameter and Ai is an lvalue reference, in // which case the type of Pi is changed to be the template parameter // type (i.e., T&& is changed to simply T). [ Note: As a result, when // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be // deduced as X&. - end note ] TDF &= ~TDF_TopLevelParameterTypeList; if (const RValueReferenceType *ParamRef = Param->getAs()) { if (isa(ParamRef->getPointeeType()) && !ParamRef->getPointeeType().getQualifiers()) if (Arg->isLValueReferenceType()) Param = ParamRef->getPointeeType(); } } } // C++ [temp.deduct.type]p9: // A template type argument T, a template template argument TT or a // template non-type argument i can be deduced if P and A have one of // the following forms: // // T // cv-list T if (const TemplateTypeParmType *TemplateTypeParm = Param->getAs()) { // Just skip any attempts to deduce from a placeholder type. if (Arg->isPlaceholderType()) return Sema::TDK_Success; unsigned Index = TemplateTypeParm->getIndex(); bool RecanonicalizeArg = false; // If the argument type is an array type, move the qualifiers up to the // top level, so they can be matched with the qualifiers on the parameter. if (isa(Arg)) { Qualifiers Quals; Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); if (Quals) { Arg = S.Context.getQualifiedType(Arg, Quals); RecanonicalizeArg = true; } } // The argument type can not be less qualified than the parameter // type. if (!(TDF & TDF_IgnoreQualifiers) && hasInconsistentOrSupersetQualifiersOf(Param, Arg)) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_Underqualified; } assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function"); QualType DeducedType = Arg; // Remove any qualifiers on the parameter from the deduced type. // We checked the qualifiers for consistency above. Qualifiers DeducedQs = DeducedType.getQualifiers(); Qualifiers ParamQs = Param.getQualifiers(); DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers()); if (ParamQs.hasObjCGCAttr()) DeducedQs.removeObjCGCAttr(); if (ParamQs.hasAddressSpace()) DeducedQs.removeAddressSpace(); if (ParamQs.hasObjCLifetime()) DeducedQs.removeObjCLifetime(); // Objective-C ARC: // If template deduction would produce a lifetime qualifier on a type // that is not a lifetime type, template argument deduction fails. if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() && !DeducedType->isDependentType()) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = TemplateArgument(Param); Info.SecondArg = TemplateArgument(Arg); return Sema::TDK_Underqualified; } // Objective-C ARC: // If template deduction would produce an argument type with lifetime type // but no lifetime qualifier, the __strong lifetime qualifier is inferred. if (S.getLangOpts().ObjCAutoRefCount && DeducedType->isObjCLifetimeType() && !DeducedQs.hasObjCLifetime()) DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong); DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(), DeducedQs); if (RecanonicalizeArg) DeducedType = S.Context.getCanonicalType(DeducedType); DeducedTemplateArgument NewDeduced(DeducedType); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[Index], NewDeduced); if (Result.isNull()) { Info.Param = cast(TemplateParams->getParam(Index)); Info.FirstArg = Deduced[Index]; Info.SecondArg = NewDeduced; return Sema::TDK_Inconsistent; } Deduced[Index] = Result; return Sema::TDK_Success; } // Set up the template argument deduction information for a failure. Info.FirstArg = TemplateArgument(ParamIn); Info.SecondArg = TemplateArgument(ArgIn); // If the parameter is an already-substituted template parameter // pack, do nothing: we don't know which of its arguments to look // at, so we have to wait until all of the parameter packs in this // expansion have arguments. if (isa(Param)) return Sema::TDK_Success; // Check the cv-qualifiers on the parameter and argument types. CanQualType CanParam = S.Context.getCanonicalType(Param); CanQualType CanArg = S.Context.getCanonicalType(Arg); if (!(TDF & TDF_IgnoreQualifiers)) { if (TDF & TDF_ParamWithReferenceType) { if (hasInconsistentOrSupersetQualifiersOf(Param, Arg)) return Sema::TDK_NonDeducedMismatch; } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) return Sema::TDK_NonDeducedMismatch; } // If the parameter type is not dependent, there is nothing to deduce. if (!Param->isDependentType()) { if (!(TDF & TDF_SkipNonDependent)) { bool NonDeduced = (TDF & TDF_InOverloadResolution)? !S.isSameOrCompatibleFunctionType(CanParam, CanArg) : Param != Arg; if (NonDeduced) { return Sema::TDK_NonDeducedMismatch; } } return Sema::TDK_Success; } } else if (!Param->isDependentType()) { CanQualType ParamUnqualType = CanParam.getUnqualifiedType(), ArgUnqualType = CanArg.getUnqualifiedType(); bool Success = (TDF & TDF_InOverloadResolution)? S.isSameOrCompatibleFunctionType(ParamUnqualType, ArgUnqualType) : ParamUnqualType == ArgUnqualType; if (Success) return Sema::TDK_Success; } switch (Param->getTypeClass()) { // Non-canonical types cannot appear here. #define NON_CANONICAL_TYPE(Class, Base) \ case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class); #define TYPE(Class, Base) #include "clang/AST/TypeNodes.def" case Type::TemplateTypeParm: case Type::SubstTemplateTypeParmPack: llvm_unreachable("Type nodes handled above"); // These types cannot be dependent, so simply check whether the types are // the same. case Type::Builtin: case Type::VariableArray: case Type::Vector: case Type::FunctionNoProto: case Type::Record: case Type::Enum: case Type::ObjCObject: case Type::ObjCInterface: case Type::ObjCObjectPointer: { if (TDF & TDF_SkipNonDependent) return Sema::TDK_Success; if (TDF & TDF_IgnoreQualifiers) { Param = Param.getUnqualifiedType(); Arg = Arg.getUnqualifiedType(); } return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch; } // _Complex T [placeholder extension] case Type::Complex: if (const ComplexType *ComplexArg = Arg->getAs()) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getElementType(), ComplexArg->getElementType(), Info, Deduced, TDF); return Sema::TDK_NonDeducedMismatch; // _Atomic T [extension] case Type::Atomic: if (const AtomicType *AtomicArg = Arg->getAs()) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getValueType(), AtomicArg->getValueType(), Info, Deduced, TDF); return Sema::TDK_NonDeducedMismatch; // T * case Type::Pointer: { QualType PointeeType; if (const PointerType *PointerArg = Arg->getAs()) { PointeeType = PointerArg->getPointeeType(); } else if (const ObjCObjectPointerType *PointerArg = Arg->getAs()) { PointeeType = PointerArg->getPointeeType(); } else { return Sema::TDK_NonDeducedMismatch; } unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), PointeeType, Info, Deduced, SubTDF); } // T & case Type::LValueReference: { const LValueReferenceType *ReferenceArg = Arg->getAs(); if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), ReferenceArg->getPointeeType(), Info, Deduced, 0); } // T && [C++0x] case Type::RValueReference: { const RValueReferenceType *ReferenceArg = Arg->getAs(); if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), ReferenceArg->getPointeeType(), Info, Deduced, 0); } // T [] (implied, but not stated explicitly) case Type::IncompleteArray: { const IncompleteArrayType *IncompleteArrayArg = S.Context.getAsIncompleteArrayType(Arg); if (!IncompleteArrayArg) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, S.Context.getAsIncompleteArrayType(Param)->getElementType(), IncompleteArrayArg->getElementType(), Info, Deduced, SubTDF); } // T [integer-constant] case Type::ConstantArray: { const ConstantArrayType *ConstantArrayArg = S.Context.getAsConstantArrayType(Arg); if (!ConstantArrayArg) return Sema::TDK_NonDeducedMismatch; const ConstantArrayType *ConstantArrayParm = S.Context.getAsConstantArrayType(Param); if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ConstantArrayParm->getElementType(), ConstantArrayArg->getElementType(), Info, Deduced, SubTDF); } // type [i] case Type::DependentSizedArray: { const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); if (!ArrayArg) return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; // Check the element type of the arrays const DependentSizedArrayType *DependentArrayParm = S.Context.getAsDependentSizedArrayType(Param); if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, DependentArrayParm->getElementType(), ArrayArg->getElementType(), Info, Deduced, SubTDF)) return Result; // Determine the array bound is something we can deduce. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; // We can perform template argument deduction for the given non-type // template parameter. assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument at depth > 0"); if (const ConstantArrayType *ConstantArrayArg = dyn_cast(ArrayArg)) { llvm::APSInt Size(ConstantArrayArg->getSize()); return DeduceNonTypeTemplateArgument(S, NTTP, Size, S.Context.getSizeType(), /*ArrayBound=*/true, Info, Deduced); } if (const DependentSizedArrayType *DependentArrayArg = dyn_cast(ArrayArg)) if (DependentArrayArg->getSizeExpr()) return DeduceNonTypeTemplateArgument(S, NTTP, DependentArrayArg->getSizeExpr(), Info, Deduced); // Incomplete type does not match a dependently-sized array type return Sema::TDK_NonDeducedMismatch; } // type(*)(T) // T(*)() // T(*)(T) case Type::FunctionProto: { unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList; const FunctionProtoType *FunctionProtoArg = dyn_cast(Arg); if (!FunctionProtoArg) return Sema::TDK_NonDeducedMismatch; const FunctionProtoType *FunctionProtoParam = cast(Param); if (FunctionProtoParam->getTypeQuals() != FunctionProtoArg->getTypeQuals() || FunctionProtoParam->getRefQualifier() != FunctionProtoArg->getRefQualifier() || FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) return Sema::TDK_NonDeducedMismatch; // Check return types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, FunctionProtoParam->getReturnType(), FunctionProtoArg->getReturnType(), Info, Deduced, 0)) return Result; return DeduceTemplateArguments( S, TemplateParams, FunctionProtoParam->param_type_begin(), FunctionProtoParam->getNumParams(), FunctionProtoArg->param_type_begin(), FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF); } case Type::InjectedClassName: { // Treat a template's injected-class-name as if the template // specialization type had been used. Param = cast(Param) ->getInjectedSpecializationType(); assert(isa(Param) && "injected class name is not a template specialization type"); // fall through } // template-name (where template-name refers to a class template) // template-name // TT // TT // TT<> case Type::TemplateSpecialization: { const TemplateSpecializationType *SpecParam = cast(Param); // Try to deduce template arguments from the template-id. Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info, Deduced); if (Result && (TDF & TDF_DerivedClass)) { // C++ [temp.deduct.call]p3b3: // If P is a class, and P has the form template-id, then A can be a // derived class of the deduced A. Likewise, if P is a pointer to a // class of the form template-id, A can be a pointer to a derived // class pointed to by the deduced A. // // More importantly: // These alternatives are considered only if type deduction would // otherwise fail. if (const RecordType *RecordT = Arg->getAs()) { // We cannot inspect base classes as part of deduction when the type // is incomplete, so either instantiate any templates necessary to // complete the type, or skip over it if it cannot be completed. if (S.RequireCompleteType(Info.getLocation(), Arg, 0)) return Result; // Use data recursion to crawl through the list of base classes. // Visited contains the set of nodes we have already visited, while // ToVisit is our stack of records that we still need to visit. llvm::SmallPtrSet Visited; SmallVector ToVisit; ToVisit.push_back(RecordT); bool Successful = false; SmallVector DeducedOrig(Deduced.begin(), Deduced.end()); while (!ToVisit.empty()) { // Retrieve the next class in the inheritance hierarchy. const RecordType *NextT = ToVisit.pop_back_val(); // If we have already seen this type, skip it. if (!Visited.insert(NextT)) continue; // If this is a base class, try to perform template argument // deduction from it. if (NextT != RecordT) { TemplateDeductionInfo BaseInfo(Info.getLocation()); Sema::TemplateDeductionResult BaseResult = DeduceTemplateArguments(S, TemplateParams, SpecParam, QualType(NextT, 0), BaseInfo, Deduced); // If template argument deduction for this base was successful, // note that we had some success. Otherwise, ignore any deductions // from this base class. if (BaseResult == Sema::TDK_Success) { Successful = true; DeducedOrig.clear(); DeducedOrig.append(Deduced.begin(), Deduced.end()); Info.Param = BaseInfo.Param; Info.FirstArg = BaseInfo.FirstArg; Info.SecondArg = BaseInfo.SecondArg; } else Deduced = DeducedOrig; } // Visit base classes CXXRecordDecl *Next = cast(NextT->getDecl()); for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), BaseEnd = Next->bases_end(); Base != BaseEnd; ++Base) { assert(Base->getType()->isRecordType() && "Base class that isn't a record?"); ToVisit.push_back(Base->getType()->getAs()); } } if (Successful) return Sema::TDK_Success; } } return Result; } // T type::* // T T::* // T (type::*)() // type (T::*)() // type (type::*)(T) // type (T::*)(T) // T (type::*)(T) // T (T::*)() // T (T::*)(T) case Type::MemberPointer: { const MemberPointerType *MemPtrParam = cast(Param); const MemberPointerType *MemPtrArg = dyn_cast(Arg); if (!MemPtrArg) return Sema::TDK_NonDeducedMismatch; if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, MemPtrParam->getPointeeType(), MemPtrArg->getPointeeType(), Info, Deduced, TDF & TDF_IgnoreQualifiers)) return Result; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, QualType(MemPtrParam->getClass(), 0), QualType(MemPtrArg->getClass(), 0), Info, Deduced, TDF & TDF_IgnoreQualifiers); } // (clang extension) // // type(^)(T) // T(^)() // T(^)(T) case Type::BlockPointer: { const BlockPointerType *BlockPtrParam = cast(Param); const BlockPointerType *BlockPtrArg = dyn_cast(Arg); if (!BlockPtrArg) return Sema::TDK_NonDeducedMismatch; return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, BlockPtrParam->getPointeeType(), BlockPtrArg->getPointeeType(), Info, Deduced, 0); } // (clang extension) // // T __attribute__(((ext_vector_type()))) case Type::ExtVector: { const ExtVectorType *VectorParam = cast(Param); if (const ExtVectorType *VectorArg = dyn_cast(Arg)) { // Make sure that the vectors have the same number of elements. if (VectorParam->getNumElements() != VectorArg->getNumElements()) return Sema::TDK_NonDeducedMismatch; // Perform deduction on the element types. return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF); } if (const DependentSizedExtVectorType *VectorArg = dyn_cast(Arg)) { // We can't check the number of elements, since the argument has a // dependent number of elements. This can only occur during partial // ordering. // Perform deduction on the element types. return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF); } return Sema::TDK_NonDeducedMismatch; } // (clang extension) // // T __attribute__(((ext_vector_type(N)))) case Type::DependentSizedExtVector: { const DependentSizedExtVectorType *VectorParam = cast(Param); if (const ExtVectorType *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); ArgSize = VectorArg->getNumElements(); return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy, false, Info, Deduced); } if (const DependentSizedExtVectorType *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, VectorParam->getElementType(), VectorArg->getElementType(), Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); if (!NTTP) return Sema::TDK_Success; return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(), Info, Deduced); } return Sema::TDK_NonDeducedMismatch; } case Type::TypeOfExpr: case Type::TypeOf: case Type::DependentName: case Type::UnresolvedUsing: case Type::Decltype: case Type::UnaryTransform: case Type::Auto: case Type::DependentTemplateSpecialization: case Type::PackExpansion: // No template argument deduction for these types return Sema::TDK_Success; } llvm_unreachable("Invalid Type Class!"); } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { // If the template argument is a pack expansion, perform template argument // deduction against the pattern of that expansion. This only occurs during // partial ordering. if (Arg.isPackExpansion()) Arg = Arg.getPackExpansionPattern(); switch (Param.getKind()) { case TemplateArgument::Null: llvm_unreachable("Null template argument in parameter list"); case TemplateArgument::Type: if (Arg.getKind() == TemplateArgument::Type) return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Param.getAsType(), Arg.getAsType(), Info, Deduced, 0); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Template: if (Arg.getKind() == TemplateArgument::Template) return DeduceTemplateArguments(S, TemplateParams, Param.getAsTemplate(), Arg.getAsTemplate(), Info, Deduced); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::TemplateExpansion: llvm_unreachable("caller should handle pack expansions"); case TemplateArgument::Declaration: if (Arg.getKind() == TemplateArgument::Declaration && isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) && Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam()) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::NullPtr: if (Arg.getKind() == TemplateArgument::NullPtr && S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType())) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Integral: if (Arg.getKind() == TemplateArgument::Integral) { if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral())) return Sema::TDK_Success; Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } if (Arg.getKind() == TemplateArgument::Expression) { Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; case TemplateArgument::Expression: { if (NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(Param.getAsExpr())) { if (Arg.getKind() == TemplateArgument::Integral) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsIntegral(), Arg.getIntegralType(), /*ArrayBound=*/false, Info, Deduced); if (Arg.getKind() == TemplateArgument::Expression) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(), Info, Deduced); if (Arg.getKind() == TemplateArgument::Declaration) return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(), Info, Deduced); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; } // Can't deduce anything, but that's okay. return Sema::TDK_Success; } case TemplateArgument::Pack: llvm_unreachable("Argument packs should be expanded by the caller!"); } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Determine whether there is a template argument to be used for /// deduction. /// /// This routine "expands" argument packs in-place, overriding its input /// parameters so that \c Args[ArgIdx] will be the available template argument. /// /// \returns true if there is another template argument (which will be at /// \c Args[ArgIdx]), false otherwise. static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args, unsigned &ArgIdx, unsigned &NumArgs) { if (ArgIdx == NumArgs) return false; const TemplateArgument &Arg = Args[ArgIdx]; if (Arg.getKind() != TemplateArgument::Pack) return true; assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?"); Args = Arg.pack_begin(); NumArgs = Arg.pack_size(); ArgIdx = 0; return ArgIdx < NumArgs; } /// \brief Determine whether the given set of template arguments has a pack /// expansion that is not the last template argument. static bool hasPackExpansionBeforeEnd(const TemplateArgument *Args, unsigned NumArgs) { unsigned ArgIdx = 0; while (ArgIdx < NumArgs) { const TemplateArgument &Arg = Args[ArgIdx]; // Unwrap argument packs. if (Args[ArgIdx].getKind() == TemplateArgument::Pack) { Args = Arg.pack_begin(); NumArgs = Arg.pack_size(); ArgIdx = 0; continue; } ++ArgIdx; if (ArgIdx == NumArgs) return false; if (Arg.isPackExpansion()) return true; } return false; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument *Params, unsigned NumParams, const TemplateArgument *Args, unsigned NumArgs, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (hasPackExpansionBeforeEnd(Params, NumParams)) return Sema::TDK_Success; // C++0x [temp.deduct.type]p9: // If P has a form that contains or , then each argument Pi of the // respective template argument list P is compared with the corresponding // argument Ai of the corresponding template argument list of A. unsigned ArgIdx = 0, ParamIdx = 0; for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); ++ParamIdx) { if (!Params[ParamIdx].isPackExpansion()) { // The simple case: deduce template arguments by matching Pi and Ai. // Check whether we have enough arguments. if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) return Sema::TDK_Success; if (Args[ArgIdx].isPackExpansion()) { // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here, // but applied to pack expansions that are template arguments. return Sema::TDK_MiscellaneousDeductionFailure; } // Perform deduction for this Pi/Ai pair. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Params[ParamIdx], Args[ArgIdx], Info, Deduced)) return Result; // Move to the next argument. ++ArgIdx; continue; } // The parameter is a pack expansion. // C++0x [temp.deduct.type]p9: // If Pi is a pack expansion, then the pattern of Pi is compared with // each remaining argument in the template argument list of A. Each // comparison deduces template arguments for subsequent positions in the // template parameter packs expanded by Pi. TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); // Compute the set of template parameter indices that correspond to // parameter packs expanded by the pack expansion. SmallVector PackIndices; { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; S.collectUnexpandedParameterPacks(Pattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; PackIndices.push_back(Index); } } } assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); // FIXME: If there are no remaining arguments, we can bail out early // and set any deduced parameter packs to an empty argument pack. // The latter part of this is a (minor) correctness issue. // Save the deduced template arguments for each parameter pack expanded // by this pack expansion, then clear out the deduction. SmallVector SavedPacks(PackIndices.size()); NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks); // Keep track of the deduced template arguments for each parameter pack // expanded by this pack expansion (the outer index) and for each // template argument (the inner SmallVectors). bool HasAnyArguments = false; while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) { HasAnyArguments = true; // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], Info, Deduced)) return Result; // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; if (!DeducedArg.isNull()) { NewlyDeducedPacks[I].push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } } ++ArgIdx; } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (Sema::TemplateDeductionResult Result = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks, Info)) return Result; } return Sema::TDK_Success; } static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgumentList &ParamList, const TemplateArgumentList &ArgList, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced) { return DeduceTemplateArguments(S, TemplateParams, ParamList.data(), ParamList.size(), ArgList.data(), ArgList.size(), Info, Deduced); } /// \brief Determine whether two template arguments are the same. static bool isSameTemplateArg(ASTContext &Context, const TemplateArgument &X, const TemplateArgument &Y) { if (X.getKind() != Y.getKind()) return false; switch (X.getKind()) { case TemplateArgument::Null: llvm_unreachable("Comparing NULL template argument"); case TemplateArgument::Type: return Context.getCanonicalType(X.getAsType()) == Context.getCanonicalType(Y.getAsType()); case TemplateArgument::Declaration: return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && X.isDeclForReferenceParam() == Y.isDeclForReferenceParam(); case TemplateArgument::NullPtr: return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()); case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: return Context.getCanonicalTemplateName( X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == Context.getCanonicalTemplateName( Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); case TemplateArgument::Integral: return X.getAsIntegral() == Y.getAsIntegral(); case TemplateArgument::Expression: { llvm::FoldingSetNodeID XID, YID; X.getAsExpr()->Profile(XID, Context, true); Y.getAsExpr()->Profile(YID, Context, true); return XID == YID; } case TemplateArgument::Pack: if (X.pack_size() != Y.pack_size()) return false; for (TemplateArgument::pack_iterator XP = X.pack_begin(), XPEnd = X.pack_end(), YP = Y.pack_begin(); XP != XPEnd; ++XP, ++YP) if (!isSameTemplateArg(Context, *XP, *YP)) return false; return true; } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Allocate a TemplateArgumentLoc where all locations have /// been initialized to the given location. /// /// \param S The semantic analysis object. /// /// \param Arg The template argument we are producing template argument /// location information for. /// /// \param NTTPType For a declaration template argument, the type of /// the non-type template parameter that corresponds to this template /// argument. /// /// \param Loc The source location to use for the resulting template /// argument. static TemplateArgumentLoc getTrivialTemplateArgumentLoc(Sema &S, const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc) { switch (Arg.getKind()) { case TemplateArgument::Null: llvm_unreachable("Can't get a NULL template argument here"); case TemplateArgument::Type: return TemplateArgumentLoc(Arg, S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); case TemplateArgument::Declaration: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .takeAs(); return TemplateArgumentLoc(TemplateArgument(E), E); } case TemplateArgument::NullPtr: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) .takeAs(); return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true), E); } case TemplateArgument::Integral: { Expr *E = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs(); return TemplateArgumentLoc(TemplateArgument(E), E); } case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: { NestedNameSpecifierLocBuilder Builder; TemplateName Template = Arg.getAsTemplate(); if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc); else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc); if (Arg.getKind() == TemplateArgument::Template) return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), Loc); return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), Loc, Loc); } case TemplateArgument::Expression: return TemplateArgumentLoc(Arg, Arg.getAsExpr()); case TemplateArgument::Pack: return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); } llvm_unreachable("Invalid TemplateArgument Kind!"); } /// \brief Convert the given deduced template argument and add it to the set of /// fully-converted template arguments. static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, DeducedTemplateArgument Arg, NamedDecl *Template, QualType NTTPType, unsigned ArgumentPackIndex, TemplateDeductionInfo &Info, bool InFunctionTemplate, SmallVectorImpl &Output) { if (Arg.getKind() == TemplateArgument::Pack) { // This is a template argument pack, so check each of its arguments against // the template parameter. SmallVector PackedArgsBuilder; for (TemplateArgument::pack_iterator PA = Arg.pack_begin(), PAEnd = Arg.pack_end(); PA != PAEnd; ++PA) { // When converting the deduced template argument, append it to the // general output list. We need to do this so that the template argument // checking logic has all of the prior template arguments available. DeducedTemplateArgument InnerArg(*PA); InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, NTTPType, PackedArgsBuilder.size(), Info, InFunctionTemplate, Output)) return true; // Move the converted template argument into our argument pack. PackedArgsBuilder.push_back(Output.pop_back_val()); } // Create the resulting argument pack. Output.push_back(TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder.data(), PackedArgsBuilder.size())); return false; } // Convert the deduced template argument into a template // argument that we can check, almost as if the user had written // the template argument explicitly. TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType, Info.getLocation()); // Check the template argument, converting it as necessary. return S.CheckTemplateArgument(Param, ArgLoc, Template, Template->getLocation(), Template->getSourceRange().getEnd(), ArgumentPackIndex, Output, InFunctionTemplate ? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound : Sema::CTAK_Deduced) : Sema::CTAK_Specified); } /// Complete template argument deduction for a class template partial /// specialization. static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(Sema &S, ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); Sema::ContextRAII SavedContext(S, Partial); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; TemplateParameterList *PartialParams = Partial->getTemplateParameters(); for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { NamedDecl *Param = PartialParams->getParam(I); if (Deduced[I].isNull()) { Info.Param = makeTemplateParameter(Param); return Sema::TDK_Incomplete; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType, 0, Info, false, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the template // arguments of the class template partial specialization, and // verify that the instantiated template arguments are both valid // and are equivalent to the template arguments originally provided // to the class template. LocalInstantiationScope InstScope(S); ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); const ASTTemplateArgumentListInfo *PartialTemplArgInfo = Partial->getTemplateArgsAsWritten(); const TemplateArgumentLoc *PartialTemplateArgs = PartialTemplArgInfo->getTemplateArgs(); TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc, PartialTemplArgInfo->RAngleLoc); if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs, InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; if (ParamIdx >= Partial->getTemplateParameters()->size()) ParamIdx = Partial->getTemplateParameters()->size() - 1; Decl *Param = const_cast( Partial->getTemplateParameters()->getParam(ParamIdx)); Info.Param = makeTemplateParameter(Param); Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); return Sema::TDK_SubstitutionFailure; } SmallVector ConvertedInstArgs; if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(), InstArgs, false, ConvertedInstArgs)) return Sema::TDK_SubstitutionFailure; TemplateParameterList *TemplateParams = ClassTemplate->getTemplateParameters(); for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { TemplateArgument InstArg = ConvertedInstArgs.data()[I]; if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); Info.FirstArg = TemplateArgs[I]; Info.SecondArg = InstArg; return Sema::TDK_NonDeducedMismatch; } } if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return Sema::TDK_Success; } /// \brief Perform template argument deduction to determine whether /// the given template arguments match the given class template /// partial specialization per C++ [temp.class.spec.match]. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, TemplateDeductionInfo &Info) { if (Partial->isInvalidDecl()) return TDK_Invalid; // C++ [temp.class.spec.match]p2: // A partial specialization matches a given actual template // argument list if the template arguments of the partial // specialization can be deduced from the actual template argument // list (14.8.2). // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); SmallVector Deduced; Deduced.resize(Partial->getTemplateParameters()->size()); if (TemplateDeductionResult Result = ::DeduceTemplateArguments(*this, Partial->getTemplateParameters(), Partial->getTemplateArgs(), TemplateArgs, Info, Deduced)) return Result; SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, Deduced, Info); } /// Complete template argument deduction for a variable template partial /// specialization. /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( Sema &S, VarTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, SmallVectorImpl &Deduced, TemplateDeductionInfo &Info) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); Sema::SFINAETrap Trap(S); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; TemplateParameterList *PartialParams = Partial->getTemplateParameters(); for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { NamedDecl *Param = PartialParams->getParam(I); if (Deduced[I].isNull()) { Info.Param = makeTemplateParameter(Param); return Sema::TDK_Incomplete; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType, 0, Info, false, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), Builder.size())); return Sema::TDK_SubstitutionFailure; } } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy( S.Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the template // arguments of the class template partial specialization, and // verify that the instantiated template arguments are both valid // and are equivalent to the template arguments originally provided // to the class template. LocalInstantiationScope InstScope(S); VarTemplateDecl *VarTemplate = Partial->getSpecializedTemplate(); const ASTTemplateArgumentListInfo *PartialTemplArgInfo = Partial->getTemplateArgsAsWritten(); const TemplateArgumentLoc *PartialTemplateArgs = PartialTemplArgInfo->getTemplateArgs(); TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc, PartialTemplArgInfo->RAngleLoc); if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs, InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; if (ParamIdx >= Partial->getTemplateParameters()->size()) ParamIdx = Partial->getTemplateParameters()->size() - 1; Decl *Param = const_cast( Partial->getTemplateParameters()->getParam(ParamIdx)); Info.Param = makeTemplateParameter(Param); Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); return Sema::TDK_SubstitutionFailure; } SmallVector ConvertedInstArgs; if (S.CheckTemplateArgumentList(VarTemplate, Partial->getLocation(), InstArgs, false, ConvertedInstArgs)) return Sema::TDK_SubstitutionFailure; TemplateParameterList *TemplateParams = VarTemplate->getTemplateParameters(); for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { TemplateArgument InstArg = ConvertedInstArgs.data()[I]; if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); Info.FirstArg = TemplateArgs[I]; Info.SecondArg = InstArg; return Sema::TDK_NonDeducedMismatch; } } if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return Sema::TDK_Success; } /// \brief Perform template argument deduction to determine whether /// the given template arguments match the given variable template /// partial specialization per C++ [temp.class.spec.match]. /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, TemplateDeductionInfo &Info) { if (Partial->isInvalidDecl()) return TDK_Invalid; // C++ [temp.class.spec.match]p2: // A partial specialization matches a given actual template // argument list if the template arguments of the partial // specialization can be deduced from the actual template argument // list (14.8.2). // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); SmallVector Deduced; Deduced.resize(Partial->getTemplateParameters()->size()); if (TemplateDeductionResult Result = ::DeduceTemplateArguments( *this, Partial->getTemplateParameters(), Partial->getTemplateArgs(), TemplateArgs, Info, Deduced)) return Result; SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, Deduced, Info); } /// \brief Determine whether the given type T is a simple-template-id type. static bool isSimpleTemplateIdType(QualType T) { if (const TemplateSpecializationType *Spec = T->getAs()) return Spec->getTemplateName().getAsTemplateDecl() != 0; return false; } /// \brief Substitute the explicitly-provided template arguments into the /// given function template according to C++ [temp.arg.explicit]. /// /// \param FunctionTemplate the function template into which the explicit /// template arguments will be substituted. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param Deduced the deduced template arguments, which will be populated /// with the converted and checked explicit template arguments. /// /// \param ParamTypes will be populated with the instantiated function /// parameters. /// /// \param FunctionType if non-NULL, the result type of the function template /// will also be instantiated and the pointed-to value will be updated with /// the instantiated function type. /// /// \param Info if substitution fails for any reason, this object will be /// populated with more information about the failure. /// /// \returns TDK_Success if substitution was successful, or some failure /// condition. Sema::TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo &ExplicitTemplateArgs, SmallVectorImpl &Deduced, SmallVectorImpl &ParamTypes, QualType *FunctionType, TemplateDeductionInfo &Info) { FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); if (ExplicitTemplateArgs.size() == 0) { // No arguments to substitute; just copy over the parameter types and // fill in the function type. for (FunctionDecl::param_iterator P = Function->param_begin(), PEnd = Function->param_end(); P != PEnd; ++P) ParamTypes.push_back((*P)->getType()); if (FunctionType) *FunctionType = Function->getType(); return TDK_Success; } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // C++ [temp.arg.explicit]p3: // Template arguments that are present shall be specified in the // declaration order of their corresponding template-parameters. The // template argument list shall not specify more template-arguments than // there are corresponding template-parameters. SmallVector Builder; // Enter a new template instantiation context where we check the // explicitly-specified template arguments against this function template, // and then substitute them into the function parameter types. SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate, DeducedArgs, ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; if (CheckTemplateArgumentList(FunctionTemplate, SourceLocation(), ExplicitTemplateArgs, true, Builder) || Trap.hasErrorOccurred()) { unsigned Index = Builder.size(); if (Index >= TemplateParams->size()) Index = TemplateParams->size() - 1; Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); return TDK_InvalidExplicitArguments; } // Form the template argument list from the explicitly-specified // template arguments. TemplateArgumentList *ExplicitArgumentList = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); Info.reset(ExplicitArgumentList); // Template argument deduction and the final substitution should be // done in the context of the templated declaration. Explicit // argument substitution, on the other hand, needs to happen in the // calling context. ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); // If we deduced template arguments for a template parameter pack, // note that the template argument pack is partially substituted and record // the explicit template arguments. They'll be used as part of deduction // for this template parameter pack. for (unsigned I = 0, N = Builder.size(); I != N; ++I) { const TemplateArgument &Arg = Builder[I]; if (Arg.getKind() == TemplateArgument::Pack) { CurrentInstantiationScope->SetPartiallySubstitutedPack( TemplateParams->getParam(I), Arg.pack_begin(), Arg.pack_size()); break; } } const FunctionProtoType *Proto = Function->getType()->getAs(); assert(Proto && "Function template does not have a prototype?"); // Instantiate the types of each of the function parameters given the // explicitly-specified template arguments. If the function has a trailing // return type, substitute it after the arguments to ensure we substitute // in lexical order. if (Proto->hasTrailingReturn()) { if (SubstParmTypes(Function->getLocation(), Function->param_begin(), Function->getNumParams(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), ParamTypes)) return TDK_SubstitutionFailure; } // Instantiate the return type. QualType ResultType; { // C++11 [expr.prim.general]p3: // If a declaration declares a member function or member function // template of a class X, the expression this is a prvalue of type // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq // and the end of the function-definition, member-declarator, or // declarator. unsigned ThisTypeQuals = 0; CXXRecordDecl *ThisContext = 0; if (CXXMethodDecl *Method = dyn_cast(Function)) { ThisContext = Method->getParent(); ThisTypeQuals = Method->getTypeQualifiers(); } CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals, getLangOpts().CPlusPlus11); ResultType = SubstType(Proto->getReturnType(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), Function->getTypeSpecStartLoc(), Function->getDeclName()); if (ResultType.isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; } // Instantiate the types of each of the function parameters given the // explicitly-specified template arguments if we didn't do so earlier. if (!Proto->hasTrailingReturn() && SubstParmTypes(Function->getLocation(), Function->param_begin(), Function->getNumParams(), MultiLevelTemplateArgumentList(*ExplicitArgumentList), ParamTypes)) return TDK_SubstitutionFailure; if (FunctionType) { *FunctionType = BuildFunctionType(ResultType, ParamTypes, Function->getLocation(), Function->getDeclName(), Proto->getExtProtoInfo()); if (FunctionType->isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; } // C++ [temp.arg.explicit]p2: // Trailing template arguments that can be deduced (14.8.2) may be // omitted from the list of explicit template-arguments. If all of the // template arguments can be deduced, they may all be omitted; in this // case, the empty template argument list <> itself may also be omitted. // // Take all of the explicitly-specified arguments and put them into // the set of deduced template arguments. Explicitly-specified // parameter packs, however, will be set to NULL since the deduction // mechanisms handle explicitly-specified argument packs directly. Deduced.reserve(TemplateParams->size()); for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) { const TemplateArgument &Arg = ExplicitArgumentList->get(I); if (Arg.getKind() == TemplateArgument::Pack) Deduced.push_back(DeducedTemplateArgument()); else Deduced.push_back(Arg); } return TDK_Success; } /// \brief Check whether the deduced argument type for a call to a function /// template matches the actual argument type per C++ [temp.deduct.call]p4. static bool CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg, QualType DeducedA) { ASTContext &Context = S.Context; QualType A = OriginalArg.OriginalArgType; QualType OriginalParamType = OriginalArg.OriginalParamType; // Check for type equality (top-level cv-qualifiers are ignored). if (Context.hasSameUnqualifiedType(A, DeducedA)) return false; // Strip off references on the argument types; they aren't needed for // the following checks. if (const ReferenceType *DeducedARef = DeducedA->getAs()) DeducedA = DeducedARef->getPointeeType(); if (const ReferenceType *ARef = A->getAs()) A = ARef->getPointeeType(); // C++ [temp.deduct.call]p4: // [...] However, there are three cases that allow a difference: // - If the original P is a reference type, the deduced A (i.e., the // type referred to by the reference) can be more cv-qualified than // the transformed A. if (const ReferenceType *OriginalParamRef = OriginalParamType->getAs()) { // We don't want to keep the reference around any more. OriginalParamType = OriginalParamRef->getPointeeType(); Qualifiers AQuals = A.getQualifiers(); Qualifiers DeducedAQuals = DeducedA.getQualifiers(); // Under Objective-C++ ARC, the deduced type may have implicitly // been given strong or (when dealing with a const reference) // unsafe_unretained lifetime. If so, update the original // qualifiers to include this lifetime. if (S.getLangOpts().ObjCAutoRefCount && ((DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong && AQuals.getObjCLifetime() == Qualifiers::OCL_None) || (DeducedAQuals.hasConst() && DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone))) { AQuals.setObjCLifetime(DeducedAQuals.getObjCLifetime()); } if (AQuals == DeducedAQuals) { // Qualifiers match; there's nothing to do. } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) { return true; } else { // Qualifiers are compatible, so have the argument type adopt the // deduced argument type's qualifiers as if we had performed the // qualification conversion. A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals); } } // - The transformed A can be another pointer or pointer to member // type that can be converted to the deduced A via a qualification // conversion. // // Also allow conversions which merely strip [[noreturn]] from function types // (recursively) as an extension. // FIXME: Currently, this doesn't play nicely with qualification conversions. bool ObjCLifetimeConversion = false; QualType ResultTy; if ((A->isAnyPointerType() || A->isMemberPointerType()) && (S.IsQualificationConversion(A, DeducedA, false, ObjCLifetimeConversion) || S.IsNoReturnConversion(A, DeducedA, ResultTy))) return false; // - If P is a class and P has the form simple-template-id, then the // transformed A can be a derived class of the deduced A. [...] // [...] Likewise, if P is a pointer to a class of the form // simple-template-id, the transformed A can be a pointer to a // derived class pointed to by the deduced A. if (const PointerType *OriginalParamPtr = OriginalParamType->getAs()) { if (const PointerType *DeducedAPtr = DeducedA->getAs()) { if (const PointerType *APtr = A->getAs()) { if (A->getPointeeType()->isRecordType()) { OriginalParamType = OriginalParamPtr->getPointeeType(); DeducedA = DeducedAPtr->getPointeeType(); A = APtr->getPointeeType(); } } } } if (Context.hasSameUnqualifiedType(A, DeducedA)) return false; if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) && S.IsDerivedFrom(A, DeducedA)) return false; return true; } /// \brief Finish template argument deduction for a function template, /// checking the deduced template arguments for completeness and forming /// the function template specialization. /// /// \param OriginalCallArgs If non-NULL, the original call arguments against /// which the deduced argument types should be compared. Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl &Deduced, unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, SmallVectorImpl const *OriginalCallArgs) { TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // Enter a new template instantiation context while we instantiate the // actual function declaration. SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate, DeducedArgs, ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); // C++ [temp.deduct.type]p2: // [...] or if any template argument remains neither deduced nor // explicitly specified, template argument deduction fails. SmallVector Builder; for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { NamedDecl *Param = TemplateParams->getParam(I); if (!Deduced[I].isNull()) { if (I < NumExplicitlySpecified) { // We have already fully type-checked and converted this // argument, because it was explicitly-specified. Just record the // presence of this argument. Builder.push_back(Deduced[I]); continue; } // We have deduced this argument, so it still needs to be // checked and converted. // First, for a non-type template parameter type that is // initialized by a declaration, we need the type of the // corresponding non-type template parameter. QualType NTTPType; if (NonTypeTemplateParmDecl *NTTP = dyn_cast(Param)) { NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Builder.data(), Builder.size()); NTTPType = SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); if (NTTPType.isNull()) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } } } if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I], FunctionTemplate, NTTPType, 0, Info, true, Builder)) { Info.Param = makeTemplateParameter(Param); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } continue; } // C++0x [temp.arg.explicit]p3: // A trailing template parameter pack (14.5.3) not otherwise deduced will // be deduced to an empty sequence of template arguments. // FIXME: Where did the word "trailing" come from? if (Param->isTemplateParameterPack()) { // We may have had explicitly-specified template arguments for this // template parameter pack. If so, our empty deduction extends the // explicitly-specified set (C++0x [temp.arg.explicit]p9). const TemplateArgument *ExplicitArgs; unsigned NumExplicitArgs; if (CurrentInstantiationScope && CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs, &NumExplicitArgs) == Param) { Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs)); // Forget the partially-substituted pack; it's substitution is now // complete. CurrentInstantiationScope->ResetPartiallySubstitutedPack(); } else { Builder.push_back(TemplateArgument::getEmptyPack()); } continue; } // Substitute into the default template argument, if available. bool HasDefaultArg = false; TemplateArgumentLoc DefArg = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate, FunctionTemplate->getLocation(), FunctionTemplate->getSourceRange().getEnd(), Param, Builder, HasDefaultArg); // If there was no default argument, deduction is incomplete. if (DefArg.getArgument().isNull()) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return HasDefaultArg ? TDK_SubstitutionFailure : TDK_Incomplete; } // Check whether we can actually use the default argument. if (CheckTemplateArgument(Param, DefArg, FunctionTemplate, FunctionTemplate->getLocation(), FunctionTemplate->getSourceRange().getEnd(), 0, Builder, CTAK_Specified)) { Info.Param = makeTemplateParameter( const_cast(TemplateParams->getParam(I))); // FIXME: These template arguments are temporary. Free them! Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size())); return TDK_SubstitutionFailure; } // If we get here, we successfully used the default template argument. } // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); Info.reset(DeducedArgumentList); // Substitute the deduced template arguments into the function template // declaration to produce the function template specialization. DeclContext *Owner = FunctionTemplate->getDeclContext(); if (FunctionTemplate->getFriendObjectKind()) Owner = FunctionTemplate->getLexicalDeclContext(); Specialization = cast_or_null( SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, MultiLevelTemplateArgumentList(*DeducedArgumentList))); if (!Specialization || Specialization->isInvalidDecl()) return TDK_SubstitutionFailure; assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == FunctionTemplate->getCanonicalDecl()); // If the template argument list is owned by the function template // specialization, release it. if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList && !Trap.hasErrorOccurred()) Info.take(); // There may have been an error that did not prevent us from constructing a // declaration. Mark the declaration invalid and return with a substitution // failure. if (Trap.hasErrorOccurred()) { Specialization->setInvalidDecl(true); return TDK_SubstitutionFailure; } if (OriginalCallArgs) { // C++ [temp.deduct.call]p4: // In general, the deduction process attempts to find template argument // values that will make the deduced A identical to A (after the type A // is transformed as described above). [...] for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) { OriginalCallArg OriginalArg = (*OriginalCallArgs)[I]; unsigned ParamIdx = OriginalArg.ArgIdx; if (ParamIdx >= Specialization->getNumParams()) continue; QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType(); if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) return Sema::TDK_SubstitutionFailure; } } // If we suppressed any diagnostics while performing template argument // deduction, and if we haven't already instantiated this declaration, // keep track of these diagnostics. They'll be emitted if this specialization // is actually used. if (Info.diag_begin() != Info.diag_end()) { SuppressedDiagnosticsMap::iterator Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); if (Pos == SuppressedDiagnostics.end()) SuppressedDiagnostics[Specialization->getCanonicalDecl()] .append(Info.diag_begin(), Info.diag_end()); } return TDK_Success; } /// Gets the type of a function for template-argument-deducton /// purposes when it's considered as part of an overload set. static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R, FunctionDecl *Fn) { // We may need to deduce the return type of the function now. if (S.getLangOpts().CPlusPlus1y && Fn->getReturnType()->isUndeducedType() && S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false)) return QualType(); if (CXXMethodDecl *Method = dyn_cast(Fn)) if (Method->isInstance()) { // An instance method that's referenced in a form that doesn't // look like a member pointer is just invalid. if (!R.HasFormOfMemberPointer) return QualType(); return S.Context.getMemberPointerType(Fn->getType(), S.Context.getTypeDeclType(Method->getParent()).getTypePtr()); } if (!R.IsAddressOfOperand) return Fn->getType(); return S.Context.getPointerType(Fn->getType()); } /// Apply the deduction rules for overload sets. /// /// \return the null type if this argument should be treated as an /// undeduced context static QualType ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, Expr *Arg, QualType ParamType, bool ParamWasReference) { OverloadExpr::FindResult R = OverloadExpr::find(Arg); OverloadExpr *Ovl = R.Expression; // C++0x [temp.deduct.call]p4 unsigned TDF = 0; if (ParamWasReference) TDF |= TDF_ParamWithReferenceType; if (R.IsAddressOfOperand) TDF |= TDF_IgnoreQualifiers; // C++0x [temp.deduct.call]p6: // When P is a function type, pointer to function type, or pointer // to member function type: if (!ParamType->isFunctionType() && !ParamType->isFunctionPointerType() && !ParamType->isMemberFunctionPointerType()) { if (Ovl->hasExplicitTemplateArgs()) { // But we can still look for an explicit specialization. if (FunctionDecl *ExplicitSpec = S.ResolveSingleFunctionTemplateSpecialization(Ovl)) return GetTypeOfFunction(S, R, ExplicitSpec); } return QualType(); } // Gather the explicit template arguments, if any. TemplateArgumentListInfo ExplicitTemplateArgs; if (Ovl->hasExplicitTemplateArgs()) Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs); QualType Match; for (UnresolvedSetIterator I = Ovl->decls_begin(), E = Ovl->decls_end(); I != E; ++I) { NamedDecl *D = (*I)->getUnderlyingDecl(); if (FunctionTemplateDecl *FunTmpl = dyn_cast(D)) { // - If the argument is an overload set containing one or more // function templates, the parameter is treated as a // non-deduced context. if (!Ovl->hasExplicitTemplateArgs()) return QualType(); // Otherwise, see if we can resolve a function type FunctionDecl *Specialization = 0; TemplateDeductionInfo Info(Ovl->getNameLoc()); if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs, Specialization, Info)) continue; D = Specialization; } FunctionDecl *Fn = cast(D); QualType ArgType = GetTypeOfFunction(S, R, Fn); if (ArgType.isNull()) continue; // Function-to-pointer conversion. if (!ParamWasReference && ParamType->isPointerType() && ArgType->isFunctionType()) ArgType = S.Context.getPointerType(ArgType); // - If the argument is an overload set (not containing function // templates), trial argument deduction is attempted using each // of the members of the set. If deduction succeeds for only one // of the overload set members, that member is used as the // argument value for the deduction. If deduction succeeds for // more than one member of the overload set the parameter is // treated as a non-deduced context. // We do all of this in a fresh context per C++0x [temp.deduct.type]p2: // Type deduction is done independently for each P/A pair, and // the deduced template argument values are then combined. // So we do not reject deductions which were made elsewhere. SmallVector Deduced(TemplateParams->size()); TemplateDeductionInfo Info(Ovl->getNameLoc()); Sema::TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF); if (Result) continue; if (!Match.isNull()) return QualType(); Match = ArgType; } return Match; } /// \brief Perform the adjustments to the parameter and argument types /// described in C++ [temp.deduct.call]. /// /// \returns true if the caller should not attempt to perform any template /// argument deduction based on this P/A pair because the argument is an /// overloaded function set that could not be resolved. static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, TemplateParameterList *TemplateParams, QualType &ParamType, QualType &ArgType, Expr *Arg, unsigned &TDF) { // C++0x [temp.deduct.call]p3: // If P is a cv-qualified type, the top level cv-qualifiers of P's type // are ignored for type deduction. if (ParamType.hasQualifiers()) ParamType = ParamType.getUnqualifiedType(); const ReferenceType *ParamRefType = ParamType->getAs(); if (ParamRefType) { QualType PointeeType = ParamRefType->getPointeeType(); // If the argument has incomplete array type, try to complete its type. if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0)) ArgType = Arg->getType(); // [C++0x] If P is an rvalue reference to a cv-unqualified // template parameter and the argument is an lvalue, the type // "lvalue reference to A" is used in place of A for type // deduction. if (isa(ParamType)) { if (!PointeeType.getQualifiers() && isa(PointeeType) && Arg->Classify(S.Context).isLValue() && Arg->getType() != S.Context.OverloadTy && Arg->getType() != S.Context.BoundMemberTy) ArgType = S.Context.getLValueReferenceType(ArgType); } // [...] If P is a reference type, the type referred to by P is used // for type deduction. ParamType = PointeeType; } // Overload sets usually make this parameter an undeduced // context, but there are sometimes special circumstances. if (ArgType == S.Context.OverloadTy) { ArgType = ResolveOverloadForDeduction(S, TemplateParams, Arg, ParamType, ParamRefType != 0); if (ArgType.isNull()) return true; } if (ParamRefType) { // C++0x [temp.deduct.call]p3: // [...] If P is of the form T&&, where T is a template parameter, and // the argument is an lvalue, the type A& is used in place of A for // type deduction. if (ParamRefType->isRValueReferenceType() && ParamRefType->getAs() && Arg->isLValue()) ArgType = S.Context.getLValueReferenceType(ArgType); } else { // C++ [temp.deduct.call]p2: // If P is not a reference type: // - If A is an array type, the pointer type produced by the // array-to-pointer standard conversion (4.2) is used in place of // A for type deduction; otherwise, if (ArgType->isArrayType()) ArgType = S.Context.getArrayDecayedType(ArgType); // - If A is a function type, the pointer type produced by the // function-to-pointer standard conversion (4.3) is used in place // of A for type deduction; otherwise, else if (ArgType->isFunctionType()) ArgType = S.Context.getPointerType(ArgType); else { // - If A is a cv-qualified type, the top level cv-qualifiers of A's // type are ignored for type deduction. ArgType = ArgType.getUnqualifiedType(); } } // C++0x [temp.deduct.call]p4: // In general, the deduction process attempts to find template argument // values that will make the deduced A identical to A (after the type A // is transformed as described above). [...] TDF = TDF_SkipNonDependent; // - If the original P is a reference type, the deduced A (i.e., the // type referred to by the reference) can be more cv-qualified than // the transformed A. if (ParamRefType) TDF |= TDF_ParamWithReferenceType; // - The transformed A can be another pointer or pointer to member // type that can be converted to the deduced A via a qualification // conversion (4.4). if (ArgType->isPointerType() || ArgType->isMemberPointerType() || ArgType->isObjCObjectPointerType()) TDF |= TDF_IgnoreQualifiers; // - If P is a class and P has the form simple-template-id, then the // transformed A can be a derived class of the deduced A. Likewise, // if P is a pointer to a class of the form simple-template-id, the // transformed A can be a pointer to a derived class pointed to by // the deduced A. if (isSimpleTemplateIdType(ParamType) || (isa(ParamType) && isSimpleTemplateIdType( ParamType->getAs()->getPointeeType()))) TDF |= TDF_DerivedClass; return false; } static bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T); /// \brief Perform template argument deduction by matching a parameter type /// against a single expression, where the expression is an element of /// an initializer list that was originally matched against a parameter /// of type \c initializer_list\. static Sema::TemplateDeductionResult DeduceTemplateArgumentByListElement(Sema &S, TemplateParameterList *TemplateParams, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, SmallVectorImpl &Deduced, unsigned TDF) { // Handle the case where an init list contains another init list as the // element. if (InitListExpr *ILE = dyn_cast(Arg)) { QualType X; if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X)) return Sema::TDK_Success; // Just ignore this expression. // Recurse down into the init list. for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (Sema::TemplateDeductionResult Result = DeduceTemplateArgumentByListElement(S, TemplateParams, X, ILE->getInit(i), Info, Deduced, TDF)) return Result; } return Sema::TDK_Success; } // For all other cases, just match by type. QualType ArgType = Arg->getType(); if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, ArgType, Arg, TDF)) { Info.Expression = Arg; return Sema::TDK_FailedOverloadResolution; } return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF); } /// \brief Perform template argument deduction from a function call /// (C++ [temp.deduct.call]). /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicit template arguments provided /// for this call. /// /// \param Args the function call arguments /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef Args, FunctionDecl *&Specialization, TemplateDeductionInfo &Info) { if (FunctionTemplate->isInvalidDecl()) return TDK_Invalid; FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); // C++ [temp.deduct.call]p1: // Template argument deduction is done by comparing each function template // parameter type (call it P) with the type of the corresponding argument // of the call (call it A) as described below. unsigned CheckArgs = Args.size(); if (Args.size() < Function->getMinRequiredArguments()) return TDK_TooFewArguments; else if (Args.size() > Function->getNumParams()) { const FunctionProtoType *Proto = Function->getType()->getAs(); if (Proto->isTemplateVariadic()) /* Do nothing */; else if (Proto->isVariadic()) CheckArgs = Function->getNumParams(); else return TDK_TooManyArguments; } // The types of the parameters from which we will perform template argument // deduction. LocalInstantiationScope InstScope(*this); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); SmallVector Deduced; SmallVector ParamTypes; unsigned NumExplicitlySpecified = 0; if (ExplicitTemplateArgs) { TemplateDeductionResult Result = SubstituteExplicitTemplateArguments(FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, 0, Info); if (Result) return Result; NumExplicitlySpecified = Deduced.size(); } else { // Just fill in the parameter types from the function declaration. for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) ParamTypes.push_back(Function->getParamDecl(I)->getType()); } // Deduce template arguments from the function parameters. Deduced.resize(TemplateParams->size()); unsigned ArgIdx = 0; SmallVector OriginalCallArgs; for (unsigned ParamIdx = 0, NumParams = ParamTypes.size(); ParamIdx != NumParams; ++ParamIdx) { QualType OrigParamType = ParamTypes[ParamIdx]; QualType ParamType = OrigParamType; const PackExpansionType *ParamExpansion = dyn_cast(ParamType); if (!ParamExpansion) { // Simple case: matching a function parameter to a function argument. if (ArgIdx >= CheckArgs) break; Expr *Arg = Args[ArgIdx++]; QualType ArgType = Arg->getType(); unsigned TDF = 0; if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, ParamType, ArgType, Arg, TDF)) continue; // If we have nothing to deduce, we're done. if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) continue; // If the argument is an initializer list ... if (InitListExpr *ILE = dyn_cast(Arg)) { // ... then the parameter is an undeduced context, unless the parameter // type is (reference to cv) std::initializer_list, in which case // deduction is done for each element of the initializer list, and the // result is the deduced type if it's the same for all elements. QualType X; // Removing references was already done. if (!isStdInitializerList(ParamType, &X)) continue; for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (TemplateDeductionResult Result = DeduceTemplateArgumentByListElement(*this, TemplateParams, X, ILE->getInit(i), Info, Deduced, TDF)) return Result; } // Don't track the argument type, since an initializer list has none. continue; } // Keep track of the argument type and corresponding parameter index, // so we can check for compatibility between the deduced A and A. OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1, ArgType)); if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, ParamType, ArgType, Info, Deduced, TDF)) return Result; continue; } // C++0x [temp.deduct.call]p1: // For a function parameter pack that occurs at the end of the // parameter-declaration-list, the type A of each remaining argument of // the call is compared with the type P of the declarator-id of the // function parameter pack. Each comparison deduces template arguments // for subsequent positions in the template parameter packs expanded by // the function parameter pack. For a function parameter pack that does // not occur at the end of the parameter-declaration-list, the type of // the parameter pack is a non-deduced context. if (ParamIdx + 1 < NumParams) break; QualType ParamPattern = ParamExpansion->getPattern(); SmallVector PackIndices; { llvm::SmallBitVector SawIndices(TemplateParams->size()); SmallVector Unexpanded; collectUnexpandedParameterPacks(ParamPattern, Unexpanded); for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { unsigned Depth, Index; llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); if (Depth == 0 && !SawIndices[Index]) { SawIndices[Index] = true; PackIndices.push_back(Index); } } } assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); // Keep track of the deduced template arguments for each parameter pack // expanded by this pack expansion (the outer index) and for each // template argument (the inner SmallVectors). NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); SmallVector SavedPacks(PackIndices.size()); PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks); bool HasAnyArguments = false; for (; ArgIdx < Args.size(); ++ArgIdx) { HasAnyArguments = true; QualType OrigParamType = ParamPattern; ParamType = OrigParamType; Expr *Arg = Args[ArgIdx]; QualType ArgType = Arg->getType(); unsigned TDF = 0; if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, ParamType, ArgType, Arg, TDF)) { // We can't actually perform any deduction for this argument, so stop // deduction at this point. ++ArgIdx; break; } // As above, initializer lists need special handling. if (InitListExpr *ILE = dyn_cast(Arg)) { QualType X; if (!isStdInitializerList(ParamType, &X)) { ++ArgIdx; break; } for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X, ILE->getInit(i)->getType(), Info, Deduced, TDF)) return Result; } } else { // Keep track of the argument type and corresponding argument index, // so we can check for compatibility between the deduced A and A. if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx, ArgType)); if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, ParamType, ArgType, Info, Deduced, TDF)) return Result; } // Capture the deduced template arguments for each parameter pack expanded // by this pack expansion, add them to the list of arguments we've deduced // for that pack, then clear out the deduced argument. for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; if (!DeducedArg.isNull()) { NewlyDeducedPacks[I].push_back(DeducedArg); DeducedArg = DeducedTemplateArgument(); } } } // Build argument packs for each of the parameter packs expanded by this // pack expansion. if (Sema::TemplateDeductionResult Result = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments, Deduced, PackIndices, SavedPacks, NewlyDeducedPacks, Info)) return Result; // After we've matching against a parameter pack, we're done. break; } return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info, &OriginalCallArgs); } QualType Sema::adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType) { if (ArgFunctionType.isNull()) return ArgFunctionType; const FunctionProtoType *FunctionTypeP = FunctionType->castAs(); CallingConv CC = FunctionTypeP->getCallConv(); bool NoReturn = FunctionTypeP->getNoReturnAttr(); const FunctionProtoType *ArgFunctionTypeP = ArgFunctionType->getAs(); if (ArgFunctionTypeP->getCallConv() == CC && ArgFunctionTypeP->getNoReturnAttr() == NoReturn) return ArgFunctionType; FunctionType::ExtInfo EI = ArgFunctionTypeP->getExtInfo().withCallingConv(CC); EI = EI.withNoReturn(NoReturn); ArgFunctionTypeP = cast(Context.adjustFunctionType(ArgFunctionTypeP, EI)); return QualType(ArgFunctionTypeP, 0); } /// \brief Deduce template arguments when taking the address of a function /// template (C++ [temp.deduct.funcaddr]) or matching a specialization to /// a template. /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param ArgFunctionType the function type that will be used as the /// "argument" type (A) when performing template argument deduction from the /// function template's function type. This type may be NULL, if there is no /// argument type to compare against, in C++0x [temp.arg.explicit]p3. /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ArgFunctionType, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool InOverloadResolution) { if (FunctionTemplate->isInvalidDecl()) return TDK_Invalid; FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); QualType FunctionType = Function->getType(); if (!InOverloadResolution) ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType); // Substitute any explicit template arguments. LocalInstantiationScope InstScope(*this); SmallVector Deduced; unsigned NumExplicitlySpecified = 0; SmallVector ParamTypes; if (ExplicitTemplateArgs) { if (TemplateDeductionResult Result = SubstituteExplicitTemplateArguments(FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, &FunctionType, Info)) return Result; NumExplicitlySpecified = Deduced.size(); } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); Deduced.resize(TemplateParams->size()); // If the function has a deduced return type, substitute it for a dependent // type so that we treat it as a non-deduced context in what follows. bool HasDeducedReturnType = false; if (getLangOpts().CPlusPlus1y && InOverloadResolution && Function->getReturnType()->getContainedAutoType()) { FunctionType = SubstAutoType(FunctionType, Context.DependentTy); HasDeducedReturnType = true; } if (!ArgFunctionType.isNull()) { unsigned TDF = TDF_TopLevelParameterTypeList; if (InOverloadResolution) TDF |= TDF_InOverloadResolution; // Deduce template arguments from the function type. if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, FunctionType, ArgFunctionType, Info, Deduced, TDF)) return Result; } if (TemplateDeductionResult Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info)) return Result; // If the function has a deduced return type, deduce it now, so we can check // that the deduced function type matches the requested type. if (HasDeducedReturnType && Specialization->getReturnType()->isUndeducedType() && DeduceReturnType(Specialization, Info.getLocation(), false)) return TDK_MiscellaneousDeductionFailure; // If the requested function type does not match the actual type of the // specialization with respect to arguments of compatible pointer to function // types, template argument deduction fails. if (!ArgFunctionType.isNull()) { if (InOverloadResolution && !isSameOrCompatibleFunctionType( Context.getCanonicalType(Specialization->getType()), Context.getCanonicalType(ArgFunctionType))) return TDK_MiscellaneousDeductionFailure; else if(!InOverloadResolution && !Context.hasSameType(Specialization->getType(), ArgFunctionType)) return TDK_MiscellaneousDeductionFailure; } return TDK_Success; } /// \brief Given a function declaration (e.g. a generic lambda conversion /// function) that contains an 'auto' in its result type, substitute it /// with TypeToReplaceAutoWith. Be careful to pass in the type you want /// to replace 'auto' with and not the actual result type you want /// to set the function to. static inline void SubstAutoWithinFunctionReturnType(FunctionDecl *F, QualType TypeToReplaceAutoWith, Sema &S) { assert(!TypeToReplaceAutoWith->getContainedAutoType()); QualType AutoResultType = F->getReturnType(); assert(AutoResultType->getContainedAutoType()); QualType DeducedResultType = S.SubstAutoType(AutoResultType, TypeToReplaceAutoWith); S.Context.adjustDeducedFunctionResultType(F, DeducedResultType); } /// \brief Given a specialized conversion operator of a generic lambda /// create the corresponding specializations of the call operator and /// the static-invoker. If the return type of the call operator is auto, /// deduce its return type and check if that matches the /// return type of the destination function ptr. static inline Sema::TemplateDeductionResult SpecializeCorrespondingLambdaCallOperatorAndInvoker( CXXConversionDecl *ConversionSpecialized, SmallVectorImpl &DeducedArguments, QualType ReturnTypeOfDestFunctionPtr, TemplateDeductionInfo &TDInfo, Sema &S) { CXXRecordDecl *LambdaClass = ConversionSpecialized->getParent(); assert(LambdaClass && LambdaClass->isGenericLambda()); CXXMethodDecl *CallOpGeneric = LambdaClass->getLambdaCallOperator(); QualType CallOpResultType = CallOpGeneric->getReturnType(); const bool GenericLambdaCallOperatorHasDeducedReturnType = CallOpResultType->getContainedAutoType(); FunctionTemplateDecl *CallOpTemplate = CallOpGeneric->getDescribedFunctionTemplate(); FunctionDecl *CallOpSpecialized = 0; // Use the deduced arguments of the conversion function, to specialize our // generic lambda's call operator. if (Sema::TemplateDeductionResult Result = S.FinishTemplateArgumentDeduction(CallOpTemplate, DeducedArguments, 0, CallOpSpecialized, TDInfo)) return Result; // If we need to deduce the return type, do so (instantiates the callop). if (GenericLambdaCallOperatorHasDeducedReturnType && CallOpSpecialized->getReturnType()->isUndeducedType()) S.DeduceReturnType(CallOpSpecialized, CallOpSpecialized->getPointOfInstantiation(), /*Diagnose*/ true); // Check to see if the return type of the destination ptr-to-function // matches the return type of the call operator. if (!S.Context.hasSameType(CallOpSpecialized->getReturnType(), ReturnTypeOfDestFunctionPtr)) return Sema::TDK_NonDeducedMismatch; // Since we have succeeded in matching the source and destination // ptr-to-functions (now including return type), and have successfully // specialized our corresponding call operator, we are ready to // specialize the static invoker with the deduced arguments of our // ptr-to-function. FunctionDecl *InvokerSpecialized = 0; FunctionTemplateDecl *InvokerTemplate = LambdaClass-> getLambdaStaticInvoker()->getDescribedFunctionTemplate(); Sema::TemplateDeductionResult LLVM_ATTRIBUTE_UNUSED Result = S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0, InvokerSpecialized, TDInfo); assert(Result == Sema::TDK_Success && "If the call operator succeeded so should the invoker!"); // Set the result type to match the corresponding call operator // specialization's result type. if (GenericLambdaCallOperatorHasDeducedReturnType && InvokerSpecialized->getReturnType()->isUndeducedType()) { // Be sure to get the type to replace 'auto' with and not // the full result type of the call op specialization // to substitute into the 'auto' of the invoker and conversion // function. // For e.g. // int* (*fp)(int*) = [](auto* a) -> auto* { return a; }; // We don't want to subst 'int*' into 'auto' to get int**. QualType TypeToReplaceAutoWith = CallOpSpecialized->getReturnType() ->getContainedAutoType() ->getDeducedType(); SubstAutoWithinFunctionReturnType(InvokerSpecialized, TypeToReplaceAutoWith, S); SubstAutoWithinFunctionReturnType(ConversionSpecialized, TypeToReplaceAutoWith, S); } // Ensure that static invoker doesn't have a const qualifier. // FIXME: When creating the InvokerTemplate in SemaLambda.cpp // do not use the CallOperator's TypeSourceInfo which allows // the const qualifier to leak through. const FunctionProtoType *InvokerFPT = InvokerSpecialized-> getType().getTypePtr()->castAs(); FunctionProtoType::ExtProtoInfo EPI = InvokerFPT->getExtProtoInfo(); EPI.TypeQuals = 0; InvokerSpecialized->setType(S.Context.getFunctionType( InvokerFPT->getReturnType(), InvokerFPT->getParamTypes(), EPI)); return Sema::TDK_Success; } /// \brief Deduce template arguments for a templated conversion /// function (C++ [temp.deduct.conv]) and, if successful, produce a /// conversion function template specialization. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate, QualType ToType, CXXConversionDecl *&Specialization, TemplateDeductionInfo &Info) { if (ConversionTemplate->isInvalidDecl()) return TDK_Invalid; CXXConversionDecl *ConversionGeneric = cast(ConversionTemplate->getTemplatedDecl()); QualType FromType = ConversionGeneric->getConversionType(); // Canonicalize the types for deduction. QualType P = Context.getCanonicalType(FromType); QualType A = Context.getCanonicalType(ToType); // C++0x [temp.deduct.conv]p2: // If P is a reference type, the type referred to by P is used for // type deduction. if (const ReferenceType *PRef = P->getAs()) P = PRef->getPointeeType(); // C++0x [temp.deduct.conv]p4: // [...] If A is a reference type, the type referred to by A is used // for type deduction. if (const ReferenceType *ARef = A->getAs()) A = ARef->getPointeeType().getUnqualifiedType(); // C++ [temp.deduct.conv]p3: // // If A is not a reference type: else { assert(!A->isReferenceType() && "Reference types were handled above"); // - If P is an array type, the pointer type produced by the // array-to-pointer standard conversion (4.2) is used in place // of P for type deduction; otherwise, if (P->isArrayType()) P = Context.getArrayDecayedType(P); // - If P is a function type, the pointer type produced by the // function-to-pointer standard conversion (4.3) is used in // place of P for type deduction; otherwise, else if (P->isFunctionType()) P = Context.getPointerType(P); // - If P is a cv-qualified type, the top level cv-qualifiers of // P's type are ignored for type deduction. else P = P.getUnqualifiedType(); // C++0x [temp.deduct.conv]p4: // If A is a cv-qualified type, the top level cv-qualifiers of A's // type are ignored for type deduction. If A is a reference type, the type // referred to by A is used for type deduction. A = A.getUnqualifiedType(); } // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); SFINAETrap Trap(*this); // C++ [temp.deduct.conv]p1: // Template argument deduction is done by comparing the return // type of the template conversion function (call it P) with the // type that is required as the result of the conversion (call it // A) as described in 14.8.2.4. TemplateParameterList *TemplateParams = ConversionTemplate->getTemplateParameters(); SmallVector Deduced; Deduced.resize(TemplateParams->size()); // C++0x [temp.deduct.conv]p4: // In general, the deduction process attempts to find template // argument values that will make the deduced A identical to // A. However, there are two cases that allow a difference: unsigned TDF = 0; // - If the original A is a reference type, A can be more // cv-qualified than the deduced A (i.e., the type referred to // by the reference) if (ToType->isReferenceType()) TDF |= TDF_ParamWithReferenceType; // - The deduced A can be another pointer or pointer to member // type that can be converted to A via a qualification // conversion. // // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when // both P and A are pointers or member pointers. In this case, we // just ignore cv-qualifiers completely). if ((P->isPointerType() && A->isPointerType()) || (P->isMemberPointerType() && A->isMemberPointerType())) TDF |= TDF_IgnoreQualifiers; if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, P, A, Info, Deduced, TDF)) return Result; // Create an Instantiation Scope for finalizing the operator. LocalInstantiationScope InstScope(*this); // Finish template argument deduction. FunctionDecl *ConversionSpecialized = 0; TemplateDeductionResult Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0, ConversionSpecialized, Info); Specialization = cast_or_null(ConversionSpecialized); // If the conversion operator is being invoked on a lambda closure to convert // to a ptr-to-function, use the deduced arguments from the conversion function // to specialize the corresponding call operator. // e.g., int (*fp)(int) = [](auto a) { return a; }; if (Result == TDK_Success && isLambdaConversionOperator(ConversionGeneric)) { // Get the return type of the destination ptr-to-function we are converting // to. This is necessary for matching the lambda call operator's return // type to that of the destination ptr-to-function's return type. assert(A->isPointerType() && "Can only convert from lambda to ptr-to-function"); const FunctionType *ToFunType = A->getPointeeType().getTypePtr()->getAs(); const QualType DestFunctionPtrReturnType = ToFunType->getReturnType(); // Create the corresponding specializations of the call operator and // the static-invoker; and if the return type is auto, // deduce the return type and check if it matches the // DestFunctionPtrReturnType. // For instance: // auto L = [](auto a) { return f(a); }; // int (*fp)(int) = L; // char (*fp2)(int) = L; <-- Not OK. Result = SpecializeCorrespondingLambdaCallOperatorAndInvoker( Specialization, Deduced, DestFunctionPtrReturnType, Info, *this); } return Result; } /// \brief Deduce template arguments for a function template when there is /// nothing to deduce against (C++0x [temp.arg.explicit]p3). /// /// \param FunctionTemplate the function template for which we are performing /// template argument deduction. /// /// \param ExplicitTemplateArgs the explicitly-specified template /// arguments. /// /// \param Specialization if template argument deduction was successful, /// this will be set to the function template specialization produced by /// template argument deduction. /// /// \param Info the argument will be updated to provide additional information /// about template argument deduction. /// /// \returns the result of template argument deduction. Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, FunctionDecl *&Specialization, TemplateDeductionInfo &Info, bool InOverloadResolution) { return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, QualType(), Specialization, Info, InOverloadResolution); } namespace { /// Substitute the 'auto' type specifier within a type for a given replacement /// type. class SubstituteAutoTransform : public TreeTransform { QualType Replacement; public: SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) : TreeTransform(SemaRef), Replacement(Replacement) { } QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) { // If we're building the type pattern to deduce against, don't wrap the // substituted type in an AutoType. Certain template deduction rules // apply only when a template type parameter appears directly (and not if // the parameter is found through desugaring). For instance: // auto &&lref = lvalue; // must transform into "rvalue reference to T" not "rvalue reference to // auto type deduced as T" in order for [temp.deduct.call]p3 to apply. if (!Replacement.isNull() && isa(Replacement)) { QualType Result = Replacement; TemplateTypeParmTypeLoc NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } else { bool Dependent = !Replacement.isNull() && Replacement->isDependentType(); QualType Result = SemaRef.Context.getAutoType(Dependent ? QualType() : Replacement, TL.getTypePtr()->isDecltypeAuto(), Dependent); AutoTypeLoc NewTL = TLB.push(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } } ExprResult TransformLambdaExpr(LambdaExpr *E) { // Lambdas never need to be transformed. return E; } QualType Apply(TypeLoc TL) { // Create some scratch storage for the transformed type locations. // FIXME: We're just going to throw this information away. Don't build it. TypeLocBuilder TLB; TLB.reserve(TL.getFullDataSize()); return TransformType(TLB, TL); } }; } Sema::DeduceAutoResult Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result) { return DeduceAutoType(Type->getTypeLoc(), Init, Result); } /// \brief Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) /// /// \param Type the type pattern using the auto type-specifier. /// \param Init the initializer for the variable whose type is to be deduced. /// \param Result if type deduction was successful, this will be set to the /// deduced type. Sema::DeduceAutoResult Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) { if (Init->getType()->isNonOverloadPlaceholderType()) { ExprResult NonPlaceholder = CheckPlaceholderExpr(Init); if (NonPlaceholder.isInvalid()) return DAR_FailedAlreadyDiagnosed; Init = NonPlaceholder.take(); } if (Init->isTypeDependent() || Type.getType()->isDependentType()) { Result = SubstituteAutoTransform(*this, Context.DependentTy).Apply(Type); assert(!Result.isNull() && "substituting DependentTy can't fail"); return DAR_Succeeded; } // If this is a 'decltype(auto)' specifier, do the decltype dance. // Since 'decltype(auto)' can only occur at the top of the type, we // don't need to go digging for it. if (const AutoType *AT = Type.getType()->getAs()) { if (AT->isDecltypeAuto()) { if (isa(Init)) { Diag(Init->getLocStart(), diag::err_decltype_auto_initializer_list); return DAR_FailedAlreadyDiagnosed; } QualType Deduced = BuildDecltypeType(Init, Init->getLocStart()); // FIXME: Support a non-canonical deduced type for 'auto'. Deduced = Context.getCanonicalType(Deduced); Result = SubstituteAutoTransform(*this, Deduced).Apply(Type); if (Result.isNull()) return DAR_FailedAlreadyDiagnosed; return DAR_Succeeded; } } SourceLocation Loc = Init->getExprLoc(); LocalInstantiationScope InstScope(*this); // Build template void Func(FuncParam); TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0, false, false); QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); NamedDecl *TemplParamPtr = TemplParam; FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr, Loc); QualType FuncParam = SubstituteAutoTransform(*this, TemplArg).Apply(Type); assert(!FuncParam.isNull() && "substituting template parameter for 'auto' failed"); // Deduce type of TemplParam in Func(Init) SmallVector Deduced; Deduced.resize(1); QualType InitType = Init->getType(); unsigned TDF = 0; TemplateDeductionInfo Info(Loc); InitListExpr *InitList = dyn_cast(Init); if (InitList) { for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) { if (DeduceTemplateArgumentByListElement(*this, &TemplateParams, TemplArg, InitList->getInit(i), Info, Deduced, TDF)) return DAR_Failed; } } else { if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams, FuncParam, InitType, Init, TDF)) return DAR_Failed; if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam, InitType, Info, Deduced, TDF)) return DAR_Failed; } if (Deduced[0].getKind() != TemplateArgument::Type) return DAR_Failed; QualType DeducedType = Deduced[0].getAsType(); if (InitList) { DeducedType = BuildStdInitializerList(DeducedType, Loc); if (DeducedType.isNull()) return DAR_FailedAlreadyDiagnosed; } Result = SubstituteAutoTransform(*this, DeducedType).Apply(Type); if (Result.isNull()) return DAR_FailedAlreadyDiagnosed; // Check that the deduced argument type is compatible with the original // argument type per C++ [temp.deduct.call]p4. if (!InitList && !Result.isNull() && CheckOriginalCallArgDeduction(*this, Sema::OriginalCallArg(FuncParam,0,InitType), Result)) { Result = QualType(); return DAR_Failed; } return DAR_Succeeded; } QualType Sema::SubstAutoType(QualType TypeWithAuto, QualType TypeToReplaceAuto) { return SubstituteAutoTransform(*this, TypeToReplaceAuto). TransformType(TypeWithAuto); } TypeSourceInfo* Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType TypeToReplaceAuto) { return SubstituteAutoTransform(*this, TypeToReplaceAuto). TransformType(TypeWithAuto); } void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) { if (isa(Init)) Diag(VDecl->getLocation(), VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure_from_init_list : diag::err_auto_var_deduction_failure_from_init_list) << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange(); else Diag(VDecl->getLocation(), VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure : diag::err_auto_var_deduction_failure) << VDecl->getDeclName() << VDecl->getType() << Init->getType() << Init->getSourceRange(); } bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose) { assert(FD->getReturnType()->isUndeducedType()); if (FD->getTemplateInstantiationPattern()) InstantiateFunctionDefinition(Loc, FD); bool StillUndeduced = FD->getReturnType()->isUndeducedType(); if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) { Diag(Loc, diag::err_auto_fn_used_before_defined) << FD; Diag(FD->getLocation(), diag::note_callee_decl) << FD; } return StillUndeduced; } static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Level, llvm::SmallBitVector &Deduced); /// \brief If this is a non-static member function, static void AddImplicitObjectParameterType(ASTContext &Context, CXXMethodDecl *Method, SmallVectorImpl &ArgTypes) { // C++11 [temp.func.order]p3: // [...] The new parameter is of type "reference to cv A," where cv are // the cv-qualifiers of the function template (if any) and A is // the class of which the function template is a member. // // The standard doesn't say explicitly, but we pick the appropriate kind of // reference type based on [over.match.funcs]p4. QualType ArgTy = Context.getTypeDeclType(Method->getParent()); ArgTy = Context.getQualifiedType(ArgTy, Qualifiers::fromCVRMask(Method->getTypeQualifiers())); if (Method->getRefQualifier() == RQ_RValue) ArgTy = Context.getRValueReferenceType(ArgTy); else ArgTy = Context.getLValueReferenceType(ArgTy); ArgTypes.push_back(ArgTy); } /// \brief Determine whether the function template \p FT1 is at least as /// specialized as \p FT2. static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc, FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, SmallVectorImpl *RefParamComparisons) { FunctionDecl *FD1 = FT1->getTemplatedDecl(); FunctionDecl *FD2 = FT2->getTemplatedDecl(); const FunctionProtoType *Proto1 = FD1->getType()->getAs(); const FunctionProtoType *Proto2 = FD2->getType()->getAs(); assert(Proto1 && Proto2 && "Function templates must have prototypes"); TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); SmallVector Deduced; Deduced.resize(TemplateParams->size()); // C++0x [temp.deduct.partial]p3: // The types used to determine the ordering depend on the context in which // the partial ordering is done: TemplateDeductionInfo Info(Loc); SmallVector Args2; switch (TPOC) { case TPOC_Call: { // - In the context of a function call, the function parameter types are // used. CXXMethodDecl *Method1 = dyn_cast(FD1); CXXMethodDecl *Method2 = dyn_cast(FD2); // C++11 [temp.func.order]p3: // [...] If only one of the function templates is a non-static // member, that function template is considered to have a new // first parameter inserted in its function parameter list. The // new parameter is of type "reference to cv A," where cv are // the cv-qualifiers of the function template (if any) and A is // the class of which the function template is a member. // // Note that we interpret this to mean "if one of the function // templates is a non-static member and the other is a non-member"; // otherwise, the ordering rules for static functions against non-static // functions don't make any sense. // // C++98/03 doesn't have this provision, so instead we drop the // first argument of the free function, which seems to match // existing practice. SmallVector Args1; unsigned Skip1 = 0, Skip2 = 0; unsigned NumComparedArguments = NumCallArguments1; if (!Method2 && Method1 && !Method1->isStatic()) { if (S.getLangOpts().CPlusPlus11) { // Compare 'this' from Method1 against first parameter from Method2. AddImplicitObjectParameterType(S.Context, Method1, Args1); ++NumComparedArguments; } else // Ignore first parameter from Method2. ++Skip2; } else if (!Method1 && Method2 && !Method2->isStatic()) { if (S.getLangOpts().CPlusPlus11) // Compare 'this' from Method2 against first parameter from Method1. AddImplicitObjectParameterType(S.Context, Method2, Args2); else // Ignore first parameter from Method1. ++Skip1; } Args1.insert(Args1.end(), Proto1->param_type_begin() + Skip1, Proto1->param_type_end()); Args2.insert(Args2.end(), Proto2->param_type_begin() + Skip2, Proto2->param_type_end()); // C++ [temp.func.order]p5: // The presence of unused ellipsis and default arguments has no effect on // the partial ordering of function templates. if (Args1.size() > NumComparedArguments) Args1.resize(NumComparedArguments); if (Args2.size() > NumComparedArguments) Args2.resize(NumComparedArguments); if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(), Args1.data(), Args1.size(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; } case TPOC_Conversion: // - In the context of a call to a conversion operator, the return types // of the conversion function templates are used. if (DeduceTemplateArgumentsByTypeMatch( S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; case TPOC_Other: // - In other contexts (14.6.6.2) the function template's function type // is used. if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, FD2->getType(), FD1->getType(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) return false; break; } // C++0x [temp.deduct.partial]p11: // In most cases, all template parameters must have values in order for // deduction to succeed, but for partial ordering purposes a template // parameter may remain without a value provided it is not used in the // types being used for partial ordering. [ Note: a template parameter used // in a non-deduced context is considered used. -end note] unsigned ArgIdx = 0, NumArgs = Deduced.size(); for (; ArgIdx != NumArgs; ++ArgIdx) if (Deduced[ArgIdx].isNull()) break; if (ArgIdx == NumArgs) { // All template arguments were deduced. FT1 is at least as specialized // as FT2. return true; } // Figure out which template parameters were used. llvm::SmallBitVector UsedParameters(TemplateParams->size()); switch (TPOC) { case TPOC_Call: for (unsigned I = 0, N = Args2.size(); I != N; ++I) ::MarkUsedTemplateParameters(S.Context, Args2[I], false, TemplateParams->getDepth(), UsedParameters); break; case TPOC_Conversion: ::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), false, TemplateParams->getDepth(), UsedParameters); break; case TPOC_Other: ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false, TemplateParams->getDepth(), UsedParameters); break; } for (; ArgIdx != NumArgs; ++ArgIdx) // If this argument had no value deduced but was used in one of the types // used for partial ordering, then deduction fails. if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) return false; return true; } /// \brief Determine whether this a function template whose parameter-type-list /// ends with a function parameter pack. static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { FunctionDecl *Function = FunTmpl->getTemplatedDecl(); unsigned NumParams = Function->getNumParams(); if (NumParams == 0) return false; ParmVarDecl *Last = Function->getParamDecl(NumParams - 1); if (!Last->isParameterPack()) return false; // Make sure that no previous parameter is a parameter pack. while (--NumParams > 0) { if (Function->getParamDecl(NumParams - 1)->isParameterPack()) return false; } return true; } /// \brief Returns the more specialized function template according /// to the rules of function template partial ordering (C++ [temp.func.order]). /// /// \param FT1 the first function template /// /// \param FT2 the second function template /// /// \param TPOC the context in which we are performing partial ordering of /// function templates. /// /// \param NumCallArguments1 The number of arguments in the call to FT1, used /// only when \c TPOC is \c TPOC_Call. /// /// \param NumCallArguments2 The number of arguments in the call to FT2, used /// only when \c TPOC is \c TPOC_Call. /// /// \returns the more specialized function template. If neither /// template is more specialized, returns NULL. FunctionTemplateDecl * Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, unsigned NumCallArguments2) { SmallVector RefParamComparisons; bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, NumCallArguments1, 0); bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, NumCallArguments2, &RefParamComparisons); if (Better1 != Better2) // We have a clear winner return Better1? FT1 : FT2; if (!Better1 && !Better2) // Neither is better than the other return 0; // C++0x [temp.deduct.partial]p10: // If for each type being considered a given template is at least as // specialized for all types and more specialized for some set of types and // the other template is not more specialized for any types or is not at // least as specialized for any types, then the given template is more // specialized than the other template. Otherwise, neither template is more // specialized than the other. Better1 = false; Better2 = false; for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) { // C++0x [temp.deduct.partial]p9: // If, for a given type, deduction succeeds in both directions (i.e., the // types are identical after the transformations above) and both P and A // were reference types (before being replaced with the type referred to // above): // -- if the type from the argument template was an lvalue reference // and the type from the parameter template was not, the argument // type is considered to be more specialized than the other; // otherwise, if (!RefParamComparisons[I].ArgIsRvalueRef && RefParamComparisons[I].ParamIsRvalueRef) { Better2 = true; if (Better1) return 0; continue; } else if (!RefParamComparisons[I].ParamIsRvalueRef && RefParamComparisons[I].ArgIsRvalueRef) { Better1 = true; if (Better2) return 0; continue; } // -- if the type from the argument template is more cv-qualified than // the type from the parameter template (as described above), the // argument type is considered to be more specialized than the // other; otherwise, switch (RefParamComparisons[I].Qualifiers) { case NeitherMoreQualified: break; case ParamMoreQualified: Better1 = true; if (Better2) return 0; continue; case ArgMoreQualified: Better2 = true; if (Better1) return 0; continue; } // -- neither type is more specialized than the other. } assert(!(Better1 && Better2) && "Should have broken out in the loop above"); if (Better1) return FT1; else if (Better2) return FT2; // FIXME: This mimics what GCC implements, but doesn't match up with the // proposed resolution for core issue 692. This area needs to be sorted out, // but for now we attempt to maintain compatibility. bool Variadic1 = isVariadicFunctionTemplate(FT1); bool Variadic2 = isVariadicFunctionTemplate(FT2); if (Variadic1 != Variadic2) return Variadic1? FT2 : FT1; return 0; } /// \brief Determine if the two templates are equivalent. static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { if (T1 == T2) return true; if (!T1 || !T2) return false; return T1->getCanonicalDecl() == T2->getCanonicalDecl(); } /// \brief Retrieve the most specialized of the given function template /// specializations. /// /// \param SpecBegin the start iterator of the function template /// specializations that we will be comparing. /// /// \param SpecEnd the end iterator of the function template /// specializations, paired with \p SpecBegin. /// /// \param Loc the location where the ambiguity or no-specializations /// diagnostic should occur. /// /// \param NoneDiag partial diagnostic used to diagnose cases where there are /// no matching candidates. /// /// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one /// occurs. /// /// \param CandidateDiag partial diagnostic used for each function template /// specialization that is a candidate in the ambiguous ordering. One parameter /// in this diagnostic should be unbound, which will correspond to the string /// describing the template arguments for the function template specialization. /// /// \returns the most specialized function template specialization, if /// found. Otherwise, returns SpecEnd. UnresolvedSetIterator Sema::getMostSpecialized( UnresolvedSetIterator SpecBegin, UnresolvedSetIterator SpecEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain, QualType TargetType) { if (SpecBegin == SpecEnd) { if (Complain) { Diag(Loc, NoneDiag); FailedCandidates.NoteCandidates(*this, Loc); } return SpecEnd; } if (SpecBegin + 1 == SpecEnd) return SpecBegin; // Find the function template that is better than all of the templates it // has been compared to. UnresolvedSetIterator Best = SpecBegin; FunctionTemplateDecl *BestTemplate = cast(*Best)->getPrimaryTemplate(); assert(BestTemplate && "Not a function template specialization?"); for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) { FunctionTemplateDecl *Challenger = cast(*I)->getPrimaryTemplate(); assert(Challenger && "Not a function template specialization?"); if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, Loc, TPOC_Other, 0, 0), Challenger)) { Best = I; BestTemplate = Challenger; } } // Make sure that the "best" function template is more specialized than all // of the others. bool Ambiguous = false; for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { FunctionTemplateDecl *Challenger = cast(*I)->getPrimaryTemplate(); if (I != Best && !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, Loc, TPOC_Other, 0, 0), BestTemplate)) { Ambiguous = true; break; } } if (!Ambiguous) { // We found an answer. Return it. return Best; } // Diagnose the ambiguity. if (Complain) { Diag(Loc, AmbigDiag); // FIXME: Can we order the candidates in some sane way? for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { PartialDiagnostic PD = CandidateDiag; PD << getTemplateArgumentBindingsText( cast(*I)->getPrimaryTemplate()->getTemplateParameters(), *cast(*I)->getTemplateSpecializationArgs()); if (!TargetType.isNull()) HandleFunctionTypeMismatch(PD, cast(*I)->getType(), TargetType); Diag((*I)->getLocation(), PD); } } return SpecEnd; } /// \brief Returns the more specialized class template partial specialization /// according to the rules of partial ordering of class template partial /// specializations (C++ [temp.class.order]). /// /// \param PS1 the first class template partial specialization /// /// \param PS2 the second class template partial specialization /// /// \returns the more specialized class template partial specialization. If /// neither partial specialization is more specialized, returns NULL. ClassTemplatePartialSpecializationDecl * Sema::getMoreSpecializedPartialSpecialization( ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { // C++ [temp.class.order]p1: // For two class template partial specializations, the first is at least as // specialized as the second if, given the following rewrite to two // function templates, the first function template is at least as // specialized as the second according to the ordering rules for function // templates (14.6.6.2): // - the first function template has the same template parameters as the // first partial specialization and has a single function parameter // whose type is a class template specialization with the template // arguments of the first partial specialization, and // - the second function template has the same template parameters as the // second partial specialization and has a single function parameter // whose type is a class template specialization with the template // arguments of the second partial specialization. // // Rather than synthesize function templates, we merely perform the // equivalent partial ordering by performing deduction directly on // the template arguments of the class template partial // specializations. This computation is slightly simpler than the // general problem of function template partial ordering, because // class template partial specializations are more constrained. We // know that every template parameter is deducible from the class // template partial specialization's template arguments, for // example. SmallVector Deduced; TemplateDeductionInfo Info(Loc); QualType PT1 = PS1->getInjectedSpecializationType(); QualType PT2 = PS2->getInjectedSpecializationType(); // Determine whether PS1 is at least as specialized as PS2 Deduced.resize(PS2->getTemplateParameters()->size()); bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); if (Better1) { SmallVector DeducedArgs(Deduced.begin(),Deduced.end()); InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info); Better1 = !::FinishTemplateArgumentDeduction( *this, PS2, PS1->getTemplateArgs(), Deduced, Info); } // Determine whether PS2 is at least as specialized as PS1 Deduced.clear(); Deduced.resize(PS1->getTemplateParameters()->size()); bool Better2 = !DeduceTemplateArgumentsByTypeMatch( *this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); if (Better2) { SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info); Better2 = !::FinishTemplateArgumentDeduction( *this, PS1, PS2->getTemplateArgs(), Deduced, Info); } if (Better1 == Better2) return 0; return Better1 ? PS1 : PS2; } /// TODO: Unify with ClassTemplatePartialSpecializationDecl version? /// May require unifying ClassTemplate(Partial)SpecializationDecl and /// VarTemplate(Partial)SpecializationDecl with a new data /// structure Template(Partial)SpecializationDecl, and /// using Template(Partial)SpecializationDecl as input type. VarTemplatePartialSpecializationDecl * Sema::getMoreSpecializedPartialSpecialization( VarTemplatePartialSpecializationDecl *PS1, VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) { SmallVector Deduced; TemplateDeductionInfo Info(Loc); assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() && "the partial specializations being compared should specialize" " the same template."); TemplateName Name(PS1->getSpecializedTemplate()); TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name); QualType PT1 = Context.getTemplateSpecializationType( CanonTemplate, PS1->getTemplateArgs().data(), PS1->getTemplateArgs().size()); QualType PT2 = Context.getTemplateSpecializationType( CanonTemplate, PS2->getTemplateArgs().data(), PS2->getTemplateArgs().size()); // Determine whether PS1 is at least as specialized as PS2 Deduced.resize(PS2->getTemplateParameters()->size()); bool Better1 = !DeduceTemplateArgumentsByTypeMatch( *this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); if (Better1) { SmallVector DeducedArgs(Deduced.begin(), Deduced.end()); InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info); Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, PS1->getTemplateArgs(), Deduced, Info); } // Determine whether PS2 is at least as specialized as PS1 Deduced.clear(); Deduced.resize(PS1->getTemplateParameters()->size()); bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); if (Better2) { SmallVector DeducedArgs(Deduced.begin(),Deduced.end()); InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info); Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, PS2->getTemplateArgs(), Deduced, Info); } if (Better1 == Better2) return 0; return Better1? PS1 : PS2; } static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used); /// \brief Mark the template parameters that are used by the given /// expression. static void MarkUsedTemplateParameters(ASTContext &Ctx, const Expr *E, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { // We can deduce from a pack expansion. if (const PackExpansionExpr *Expansion = dyn_cast(E)) E = Expansion->getPattern(); // Skip through any implicit casts we added while type-checking, and any // substitutions performed by template alias expansion. while (1) { if (const ImplicitCastExpr *ICE = dyn_cast(E)) E = ICE->getSubExpr(); else if (const SubstNonTypeTemplateParmExpr *Subst = dyn_cast(E)) E = Subst->getReplacement(); else break; } // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to // find other occurrences of template parameters. const DeclRefExpr *DRE = dyn_cast(E); if (!DRE) return; const NonTypeTemplateParmDecl *NTTP = dyn_cast(DRE->getDecl()); if (!NTTP) return; if (NTTP->getDepth() == Depth) Used[NTTP->getIndex()] = true; } /// \brief Mark the template parameters that are used by the given /// nested name specifier. static void MarkUsedTemplateParameters(ASTContext &Ctx, NestedNameSpecifier *NNS, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (!NNS) return; MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0), OnlyDeduced, Depth, Used); } /// \brief Mark the template parameters that are used by the given /// template name. static void MarkUsedTemplateParameters(ASTContext &Ctx, TemplateName Name, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (TemplateDecl *Template = Name.getAsTemplateDecl()) { if (TemplateTemplateParmDecl *TTP = dyn_cast(Template)) { if (TTP->getDepth() == Depth) Used[TTP->getIndex()] = true; } return; } if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced, Depth, Used); if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced, Depth, Used); } /// \brief Mark the template parameters that are used by the given /// type. static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { if (T.isNull()) return; // Non-dependent types have nothing deducible if (!T->isDependentType()) return; T = Ctx.getCanonicalType(T); switch (T->getTypeClass()) { case Type::Pointer: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::BlockPointer: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::LValueReference: case Type::RValueReference: MarkUsedTemplateParameters(Ctx, cast(T)->getPointeeType(), OnlyDeduced, Depth, Used); break; case Type::MemberPointer: { const MemberPointerType *MemPtr = cast(T.getTypePtr()); MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0), OnlyDeduced, Depth, Used); break; } case Type::DependentSizedArray: MarkUsedTemplateParameters(Ctx, cast(T)->getSizeExpr(), OnlyDeduced, Depth, Used); // Fall through to check the element type case Type::ConstantArray: case Type::IncompleteArray: MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::Vector: case Type::ExtVector: MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::DependentSizedExtVector: { const DependentSizedExtVectorType *VecType = cast(T); MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, Depth, Used); break; } case Type::FunctionProto: { const FunctionProtoType *Proto = cast(T); MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth, Used); for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced, Depth, Used); break; } case Type::TemplateTypeParm: { const TemplateTypeParmType *TTP = cast(T); if (TTP->getDepth() == Depth) Used[TTP->getIndex()] = true; break; } case Type::SubstTemplateTypeParmPack: { const SubstTemplateTypeParmPackType *Subst = cast(T); MarkUsedTemplateParameters(Ctx, QualType(Subst->getReplacedParameter(), 0), OnlyDeduced, Depth, Used); MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(), OnlyDeduced, Depth, Used); break; } case Type::InjectedClassName: T = cast(T)->getInjectedSpecializationType(); // fall through case Type::TemplateSpecialization: { const TemplateSpecializationType *Spec = cast(T); MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced, Depth, Used); // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) break; for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, Used); break; } case Type::Complex: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getElementType(), OnlyDeduced, Depth, Used); break; case Type::Atomic: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getValueType(), OnlyDeduced, Depth, Used); break; case Type::DependentName: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getQualifier(), OnlyDeduced, Depth, Used); break; case Type::DependentTemplateSpecialization: { const DependentTemplateSpecializationType *Spec = cast(T); if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, Spec->getQualifier(), OnlyDeduced, Depth, Used); // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) break; for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, Used); break; } case Type::TypeOf: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingType(), OnlyDeduced, Depth, Used); break; case Type::TypeOfExpr: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingExpr(), OnlyDeduced, Depth, Used); break; case Type::Decltype: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingExpr(), OnlyDeduced, Depth, Used); break; case Type::UnaryTransform: if (!OnlyDeduced) MarkUsedTemplateParameters(Ctx, cast(T)->getUnderlyingType(), OnlyDeduced, Depth, Used); break; case Type::PackExpansion: MarkUsedTemplateParameters(Ctx, cast(T)->getPattern(), OnlyDeduced, Depth, Used); break; case Type::Auto: MarkUsedTemplateParameters(Ctx, cast(T)->getDeducedType(), OnlyDeduced, Depth, Used); // None of these types have any template parameters in them. case Type::Builtin: case Type::VariableArray: case Type::FunctionNoProto: case Type::Record: case Type::Enum: case Type::ObjCInterface: case Type::ObjCObject: case Type::ObjCObjectPointer: case Type::UnresolvedUsing: #define TYPE(Class, Base) #define ABSTRACT_TYPE(Class, Base) #define DEPENDENT_TYPE(Class, Base) #define NON_CANONICAL_TYPE(Class, Base) case Type::Class: #include "clang/AST/TypeNodes.def" break; } } /// \brief Mark the template parameters that are used by this /// template argument. static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { switch (TemplateArg.getKind()) { case TemplateArgument::Null: case TemplateArgument::Integral: case TemplateArgument::Declaration: break; case TemplateArgument::NullPtr: MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Type: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsTemplateOrTemplatePattern(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Expression: MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced, Depth, Used); break; case TemplateArgument::Pack: for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(), PEnd = TemplateArg.pack_end(); P != PEnd; ++P) MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used); break; } } /// \brief Mark which template parameters can be deduced from a given /// template argument list. /// /// \param TemplateArgs the template argument list from which template /// parameters will be deduced. /// /// \param Used a bit vector whose elements will be set to \c true /// to indicate when the corresponding template parameter will be /// deduced. void Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used) { // C++0x [temp.deduct.type]p9: // If the template argument list of P contains a pack expansion that is not // the last template argument, the entire template argument list is a // non-deduced context. if (OnlyDeduced && hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size())) return; for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced, Depth, Used); } /// \brief Marks all of the template parameters that will be deduced by a /// call to the given function template. void Sema::MarkDeducedTemplateParameters(ASTContext &Ctx, const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced) { TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); Deduced.clear(); Deduced.resize(TemplateParams->size()); FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(), true, TemplateParams->getDepth(), Deduced); } bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T) { if (!T->isDependentType()) return false; TemplateParameterList *TemplateParams = FunctionTemplate->getTemplateParameters(); llvm::SmallBitVector Deduced(TemplateParams->size()); ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), Deduced); return Deduced.any(); } @