43 #include "llvm/ADT/APInt.h"
44 #include "llvm/ADT/APSInt.h"
45 #include "llvm/ADT/ArrayRef.h"
46 #include "llvm/ADT/DenseMap.h"
47 #include "llvm/ADT/FoldingSet.h"
48 #include "llvm/ADT/Optional.h"
49 #include "llvm/ADT/SmallBitVector.h"
50 #include "llvm/ADT/SmallPtrSet.h"
51 #include "llvm/ADT/SmallVector.h"
52 #include "llvm/Support/Casting.h"
53 #include "llvm/Support/Compiler.h"
54 #include "llvm/Support/ErrorHandling.h"
110 using namespace clang;
111 using namespace sema;
116 if (Y.getBitWidth() >
X.getBitWidth())
117 X =
X.extend(Y.getBitWidth());
118 else if (Y.getBitWidth() <
X.getBitWidth())
119 Y = Y.extend(
X.getBitWidth());
122 if (
X.isSigned() != Y.isSigned()) {
124 if ((Y.isSigned() && Y.isNegative()) || (
X.isSigned() &&
X.isNegative()))
137 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
unsigned TDF,
138 bool PartialOrdering =
false,
bool DeducedFromArrayBound =
false);
142 ArrayRef<TemplateArgument> Ps,
143 ArrayRef<TemplateArgument> As,
145 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
146 bool NumberOfArgumentsMustMatch);
150 bool OnlyDeduced,
unsigned Depth,
151 llvm::SmallBitVector &Used);
154 bool OnlyDeduced,
unsigned Level,
155 llvm::SmallBitVector &Deduced);
165 if (
const auto *IC = dyn_cast<ImplicitCastExpr>(E))
166 E = IC->getSubExpr();
167 else if (
const auto *CE = dyn_cast<ConstantExpr>(E))
168 E = CE->getSubExpr();
169 else if (
const auto *Subst = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
170 E = Subst->getReplacement();
171 else if (
const auto *CCE = dyn_cast<CXXConstructExpr>(E)) {
173 if (CCE->getParenOrBraceRange().isValid())
176 assert(CCE->getNumArgs() >= 1 &&
"implicit construct expr should have 1 arg");
182 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
183 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
184 if (NTTP->getDepth() ==
Depth)
199 X = NX->getUnderlyingDecl();
200 if (
NamedDecl *NY = dyn_cast<NamedDecl>(Y))
201 Y = NY->getUnderlyingDecl();
226 QualType XType =
X.getNonTypeTemplateArgumentType();
234 switch (
X.getKind()) {
236 llvm_unreachable(
"Non-deduced template arguments handled above");
247 return X.wasDeducedFromArrayBound() ? Y :
X;
260 return X.wasDeducedFromArrayBound() ? Y :
X;
287 llvm::FoldingSetNodeID ID1, ID2;
288 X.getAsExpr()->Profile(ID1, Context,
true);
291 return X.wasDeducedFromArrayBound() ? Y :
X;
298 assert(!
X.wasDeducedFromArrayBound());
311 X.getParamTypeForDecl());
349 XAEnd =
X.pack_end(),
351 XA != XAEnd; ++XA, ++YA) {
355 if (Merged.isNull() && !(XA->isNull() && YA->isNull()))
357 NewPack.push_back(Merged);
366 llvm_unreachable(
"Invalid TemplateArgument Kind!");
376 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
378 "deducing non-type template argument with wrong depth");
382 if (Result.isNull()) {
403 if (
auto *Expansion = dyn_cast<PackExpansionType>(ParamType))
404 ParamType = Expansion->getPattern();
418 S, TemplateParams, ParamType, ValueType, Info, Deduced,
429 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
431 S, TemplateParams, NTTP,
433 DeducedFromArrayBound),
434 ValueType, Info, Deduced);
443 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
453 Value->getType(), Info, Deduced);
463 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
466 Value->getType(), Info, Deduced);
477 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
490 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
499 = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
506 Deduced[TempParam->getIndex()],
508 if (Result.isNull()) {
509 Info.
Param = TempParam;
510 Info.
FirstArg = Deduced[TempParam->getIndex()];
515 Deduced[TempParam->getIndex()] = Result;
551 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
554 UP = IP->getInjectedSpecializationType();
563 UA = Injected->getInjectedSpecializationType();
572 SA->getTemplateName(), Info, Deduced))
578 SA->template_arguments(), Info, Deduced,
587 RA ? dyn_cast<ClassTemplateSpecializationDecl>(RA->getDecl()) :
nullptr;
596 S, TemplateParams, TP->getTemplateName(),
597 TemplateName(SA->getSpecializedTemplate()), Info, Deduced))
602 SA->getTemplateArgs().asArray(), Info, Deduced,
610 case Type::TypeOfExpr:
612 case Type::DependentName:
614 case Type::UnresolvedUsing:
615 case Type::TemplateTypeParm:
618 case Type::ConstantArray:
619 case Type::IncompleteArray:
620 case Type::VariableArray:
621 case Type::DependentSizedArray:
623 cast<ArrayType>(T)->getElementType().getTypePtr());
672 class PackDeductionScope {
676 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
678 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
679 unsigned NumNamedPacks = addPacks(Pattern);
680 finishConstruction(NumNamedPacks);
685 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
687 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
689 finishConstruction(1);
693 void addPack(
unsigned Index) {
697 Pack.Saved = Deduced[Index];
705 FixedNumExpansions = ExpandedPackExpansions;
707 Packs.push_back(Pack);
713 llvm::SmallBitVector SawIndices(TemplateParams->size());
716 auto AddPack = [&](
unsigned Index) {
717 if (SawIndices[Index])
719 SawIndices[Index] =
true;
726 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
727 TemplateParams->getParam(Index))) {
728 if (!NTTP->isExpandedParameterPack())
729 if (
auto *Expansion = dyn_cast<PackExpansionType>(NTTP->getType()))
730 ExtraDeductions.push_back(Expansion->getPattern());
739 for (
unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
740 unsigned Depth, Index;
742 if (
Depth == Info.getDeducedDepth())
749 assert(!Packs.empty() &&
"Pack expansion without unexpanded packs?");
751 unsigned NumNamedPacks = Packs.size();
755 while (!ExtraDeductions.empty())
756 Collect(ExtraDeductions.pop_back_val());
758 return NumNamedPacks;
761 void finishConstruction(
unsigned NumNamedPacks) {
764 unsigned NumPartialPackArgs = 0;
765 std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u);
767 if (
auto *Partial =
Scope->getPartiallySubstitutedPack(
768 &PartialPackArgs, &NumPartialPackArgs))
774 bool IsExpanded =
true;
775 for (
unsigned I = 0; I != NumNamedPacks; ++I) {
776 if (Packs[I].Index >= Info.getNumExplicitArgs()) {
778 IsPartiallyExpanded =
false;
781 if (PartialPackDepthIndex ==
782 std::make_pair(Info.getDeducedDepth(), Packs[I].Index)) {
783 IsPartiallyExpanded =
true;
789 if (IsPartiallyExpanded)
790 PackElements += NumPartialPackArgs;
792 PackElements += *FixedNumExpansions;
794 for (
auto &Pack : Packs) {
795 if (Info.PendingDeducedPacks.size() > Pack.Index)
796 Pack.Outer = Info.PendingDeducedPacks[Pack.Index];
798 Info.PendingDeducedPacks.resize(Pack.Index + 1);
799 Info.PendingDeducedPacks[Pack.Index] = &Pack;
801 if (PartialPackDepthIndex ==
802 std::make_pair(Info.getDeducedDepth(), Pack.Index)) {
803 Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs);
812 if (!IsPartiallyExpanded)
813 Deduced[Pack.Index] = Pack.New[PackElements];
819 ~PackDeductionScope() {
820 for (
auto &Pack : Packs)
821 Info.PendingDeducedPacks[Pack.Index] = Pack.Outer;
826 bool isPartiallyExpanded() {
return IsPartiallyExpanded; }
831 bool hasFixedArity() {
return FixedNumExpansions.has_value(); }
836 bool hasNextElement() {
837 return !FixedNumExpansions || *FixedNumExpansions > PackElements;
841 void nextPackElement() {
845 for (
auto &Pack : Packs) {
847 if (!Pack.New.empty() || !DeducedArg.
isNull()) {
848 while (Pack.New.size() < PackElements)
850 if (Pack.New.size() == PackElements)
851 Pack.New.push_back(DeducedArg);
853 Pack.New[PackElements] = DeducedArg;
854 DeducedArg = Pack.New.size() > PackElements + 1
855 ? Pack.New[PackElements + 1]
868 for (
auto &Pack : Packs) {
870 Deduced[Pack.Index] = Pack.Saved;
885 Pack.New.resize(PackElements);
889 if (Pack.New.empty()) {
895 std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
903 Pack.New[0].wasDeducedFromArrayBound());
909 if (Pack.Outer->DeferredDeduction.isNull()) {
912 Pack.Outer->DeferredDeduction = NewPack;
915 Loc = &Pack.Outer->DeferredDeduction;
917 Loc = &Deduced[Pack.Index];
926 if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) {
928 NewPack = Pack.DeferredDeduction;
932 NamedDecl *Param = TemplateParams->getParam(Pack.Index);
933 if (Result.isNull()) {
935 Info.FirstArg = OldPack;
936 Info.SecondArg = NewPack;
943 if (*Expansions != PackElements) {
945 Info.FirstArg = Result;
959 SmallVectorImpl<DeducedTemplateArgument> &Deduced;
961 unsigned PackElements = 0;
962 bool IsPartiallyExpanded =
false;
1004 const QualType *Params,
unsigned NumParams,
1005 const QualType *Args,
unsigned NumArgs,
1007 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
1009 bool PartialOrdering =
false) {
1019 = dyn_cast<PackExpansionType>(Params[
ParamIdx]);
1024 if (ArgIdx >= NumArgs)
1027 if (isa<PackExpansionType>(Args[ArgIdx])) {
1037 S, TemplateParams, Params[
ParamIdx].getUnqualifiedType(),
1038 Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
1055 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
1059 if (
ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) {
1060 for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) {
1069 PackScope.nextPackElement();
1090 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
1091 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs;
1093 PackScope.nextPackElement();
1099 if (
auto Result = PackScope.finish())
1104 if (ArgIdx < NumArgs)
1119 if (ParamQs == ArgQs)
1158 if (IsFunctionConversion(
P, A, AdjustedParam))
1172 if (!Guide || !Guide->isImplicit())
1174 return Guide->getDeducedTemplate()->getTemplateParameters()->size();
1184 if (ParamRef->getPointeeType().getQualifiers())
1187 return TypeParm && TypeParm->
getIndex() >= FirstInnerIndex;
1193 return cast<CXXRecordDecl>(
1219 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1247 auto AddBases = [&Visited, &ToVisit](
const CXXRecordDecl *RD) {
1250 assert(T->
isRecordType() &&
"Base class that isn't a record?");
1252 ToVisit.push_back(T);
1261 while (!ToVisit.empty()) {
1262 QualType NextT = ToVisit.pop_back_val();
1268 S, TemplateParams,
P, NextT, BaseInfo, DeducedCopy);
1274 Matches.insert({RD, DeducedCopy});
1285 if (Matches.size() > 1) {
1287 for (
const auto &Match : Matches)
1288 AddBases(Match.first);
1292 while (Matches.size() > 1 && !ToVisit.empty()) {
1302 if (Matches.empty())
1304 if (Matches.size() > 1)
1307 std::swap(Matches.front().second, Deduced);
1338 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
unsigned TDF,
1339 bool PartialOrdering,
bool DeducedFromArrayBound) {
1343 if (
const auto *AExp = dyn_cast<PackExpansionType>(A))
1344 A = AExp->getPattern();
1428 P =
P->getPointeeType();
1445 unsigned Index = TTP->getIndex();
1460 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1472 "saw template type parameter with wrong depth");
1474 "Unresolved overloaded function");
1494 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1513 if (Result.isNull()) {
1514 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1520 Deduced[Index] = Result;
1559 if (!
P->isDependentType()) {
1575 switch (
P.getCanonicalType()->getTypeClass()) {
1577 #define NON_CANONICAL_TYPE(Class, Base) \
1578 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1579 #define TYPE(Class, Base)
1580 #include "clang/AST/TypeNodes.inc"
1582 case Type::TemplateTypeParm:
1583 case Type::SubstTemplateTypeParmPack:
1584 llvm_unreachable(
"Type nodes handled above");
1588 if (
P->isDependentType())
1592 case Type::VariableArray:
1594 case Type::FunctionNoProto:
1597 case Type::ObjCObject:
1598 case Type::ObjCInterface:
1599 case Type::ObjCObjectPointer:
1609 case Type::Complex: {
1614 S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
1619 case Type::Atomic: {
1624 S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
1629 case Type::Pointer: {
1640 PointeeType, Info, Deduced,
1645 case Type::LValueReference: {
1652 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1657 case Type::RValueReference: {
1664 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1669 case Type::IncompleteArray: {
1681 case Type::ConstantArray: {
1685 if (!CAA || CAA->getSize() != CAP->getSize())
1689 S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info,
1694 case Type::DependentSizedArray: {
1703 S, TemplateParams, DAP->getElementType(), AA->getElementType(),
1716 "saw non-type template parameter with wrong depth");
1717 if (
const auto *CAA = dyn_cast<ConstantArrayType>(AA)) {
1721 true, Info, Deduced);
1723 if (
const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
1724 if (DAA->getSizeExpr())
1726 S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced);
1735 case Type::FunctionProto: {
1741 if (FPP->getMethodQuals() != FPA->getMethodQuals() ||
1742 FPP->getRefQualifier() != FPA->getRefQualifier() ||
1743 FPP->isVariadic() != FPA->isVariadic())
1748 S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
1756 S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(),
1757 FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced,
1767 Expr *NoexceptExpr = FPP->getNoexceptExpr();
1772 "saw non-type template parameter with wrong depth");
1775 switch (FPA->canThrow()) {
1785 true, Info, Deduced);
1788 if (
Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
1790 S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
1803 case Type::InjectedClassName:
1812 case Type::TemplateSpecialization: {
1834 Deduced = DeducedOrig;
1838 TemplateParams,
P, Info, Deduced);
1851 case Type::MemberPointer: {
1868 S, TemplateParams, PPT, APT, Info, Deduced, SubTDF))
1871 S, TemplateParams,
QualType(MPP->getClass(), 0),
1872 QualType(MPA->getClass(), 0), Info, Deduced, SubTDF);
1880 case Type::BlockPointer: {
1886 S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info,
1893 case Type::ExtVector: {
1898 if (VP->getNumElements() != VA->getNumElements())
1900 ElementType = VA->getElementType();
1905 ElementType = VA->getElementType();
1911 S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
1915 case Type::DependentVector: {
1921 S, TemplateParams, VP->getElementType(), VA->getElementType(),
1922 Info, Deduced, TDF))
1932 ArgSize = VA->getNumElements();
1944 S, TemplateParams, VP->getElementType(), VA->getElementType(),
1945 Info, Deduced, TDF))
1955 VA->getSizeExpr(), Info, Deduced);
1964 case Type::DependentSizedExtVector: {
1970 S, TemplateParams, VP->getElementType(), VA->getElementType(),
1971 Info, Deduced, TDF))
1981 ArgSize = VA->getNumElements();
1993 S, TemplateParams, VP->getElementType(), VA->getElementType(),
1994 Info, Deduced, TDF))
2004 VA->getSizeExpr(), Info, Deduced);
2014 case Type::ConstantMatrix: {
2021 if (MP->getNumRows() != MA->getNumRows() ||
2022 MP->getNumColumns() != MA->getNumColumns()) {
2027 S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
2031 case Type::DependentSizedMatrix: {
2040 Info, Deduced, TDF))
2044 auto DeduceMatrixArg =
2045 [&S, &Info, &Deduced, &TemplateParams](
2049 const auto *ACM = dyn_cast<ConstantMatrixType>(A);
2050 const auto *ADM = dyn_cast<DependentSizedMatrixType>(A);
2051 if (!ParamExpr->isValueDependent()) {
2053 ParamExpr->getIntegerConstantExpr(S.
Context);
2058 if ((ACM->*GetArgDimension)() == *ParamConst)
2063 Expr *ArgExpr = (ADM->*GetArgDimensionExpr)();
2066 if (*ArgConst == *ParamConst)
2079 ArgConst = (ACM->*GetArgDimension)();
2082 true, Info, Deduced);
2086 (ADM->*GetArgDimensionExpr)(),
2090 if (
auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
2095 return DeduceMatrixArg(MP->getColumnExpr(), MA,
2103 case Type::DependentAddressSpace: {
2109 S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(),
2110 Info, Deduced, TDF))
2120 S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced);
2130 S, TemplateParams, ASP->getPointeeType(),
2142 true, Info, Deduced);
2147 case Type::DependentBitInt: {
2151 if (IP->isUnsigned() != IA->isUnsigned())
2160 ArgSize = IA->getNumBits();
2168 if (IP->isUnsigned() != IA->isUnsigned())
2176 case Type::TypeOfExpr:
2178 case Type::DependentName:
2179 case Type::UnresolvedUsing:
2180 case Type::Decltype:
2181 case Type::UnaryTransform:
2182 case Type::DeducedTemplateSpecialization:
2183 case Type::DependentTemplateSpecialization:
2184 case Type::PackExpansion:
2190 llvm_unreachable(
"Invalid Type Class!");
2197 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
2204 switch (
P.getKind()) {
2206 llvm_unreachable(
"Null template argument in parameter list");
2211 S, TemplateParams,
P.getAsType(), A.
getAsType(), Info, Deduced, 0);
2225 llvm_unreachable(
"caller should handle pack expansions");
2260 false, Info, Deduced);
2280 llvm_unreachable(
"Argument packs should be expanded by the caller!");
2283 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2296 if (ArgIdx == Args.size())
2303 assert(ArgIdx == Args.size() - 1 &&
"Pack not at the end of argument list?");
2306 return ArgIdx < Args.size();
2312 bool FoundPackExpansion =
false;
2313 for (
const auto &A : Args) {
2314 if (FoundPackExpansion)
2322 if (A.isPackExpansion())
2323 FoundPackExpansion =
true;
2331 ArrayRef<TemplateArgument> Ps,
2332 ArrayRef<TemplateArgument> As,
2334 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2335 bool NumberOfArgumentsMustMatch) {
2350 if (!
P.isPackExpansion()) {
2355 return NumberOfArgumentsMustMatch
2362 if (As[ArgIdx].isPackExpansion())
2367 As[ArgIdx], Info, Deduced))
2385 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
2391 PackScope.hasNextElement();
2395 As[ArgIdx], Info, Deduced))
2398 PackScope.nextPackElement();
2403 if (
auto Result = PackScope.finish())
2415 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
2417 ArgList.
asArray(), Info, Deduced,
2425 bool PackExpansionMatchesPack =
false) {
2428 if (PackExpansionMatchesPack &&
X.isPackExpansion() && !Y.
isPackExpansion())
2429 X =
X.getPackExpansionPattern();
2434 switch (
X.getKind()) {
2436 llvm_unreachable(
"Comparing NULL template argument");
2459 llvm::FoldingSetNodeID XID, YID;
2460 X.getAsExpr()->Profile(XID, Context,
true);
2470 XPEnd =
X.pack_end(),
2472 XP != XPEnd; ++XP, ++YP)
2479 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2500 llvm_unreachable(
"Can't get a NULL template argument here");
2509 Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2517 Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2525 BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs<
Expr>();
2534 Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
2537 Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
2541 Builder.getWithLocInContext(Context), Loc);
2544 Context, Arg, Builder.getWithLocInContext(Context), Loc, Loc);
2554 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2560 return getTrivialTemplateArgumentLoc(
2572 SmallVectorImpl<TemplateArgument> &Output) {
2574 unsigned ArgumentPackIndex) {
2602 "deduced nested pack");
2609 diag::err_template_arg_deduced_incomplete_pack)
2613 if (ConvertArg(InnerArg, PackedArgsBuilder.size()))
2617 PackedArgsBuilder.push_back(Output.pop_back_val());
2622 if (PackedArgsBuilder.empty()) {
2627 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2632 S.
SubstType(NTTP->getType(), Args, NTTP->getLocation(),
2633 NTTP->getDeclName()).isNull())
2635 }
else if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) {
2651 return ConvertArg(Arg, 0);
2657 template<
typename TemplateDeclT>
2659 Sema &S, TemplateDeclT *Template,
bool IsDeduced,
2660 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2663 unsigned NumAlreadyConverted = 0,
bool PartialOverloading =
false) {
2666 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
2675 PackDeductionScope(S, TemplateParams, Deduced, Info, I).finish())
2679 if (!Deduced[I].isNull()) {
2680 if (I < NumAlreadyConverted) {
2685 CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) {
2688 CurrentInstantiationScope->ResetPartiallySubstitutedPack();
2695 Builder.push_back(Deduced[I]);
2703 IsDeduced, Builder)) {
2714 bool HasDefaultArg =
false;
2717 assert(isa<ClassTemplatePartialSpecializationDecl>(Template) ||
2718 isa<VarTemplatePartialSpecializationDecl>(Template));
2727 if (Rec->isLambda())
2728 if (
auto *Method = dyn_cast<CXXMethodDecl>(Rec->getDeclContext())) {
2730 ThisTypeQuals = Method->getMethodQualifiers();
2746 if (PartialOverloading)
break;
2770 if (
auto *DC = dyn_cast<DeclContext>(D))
2776 static constexpr
bool value =
false;
2780 static constexpr
bool value =
true;
2784 static constexpr
bool value =
true;
2787 template<
typename TemplateDeclT>
2790 ArrayRef<TemplateArgument> DeducedArgs,
2793 Template->getAssociatedConstraints(AssociatedConstraints);
2805 template <
typename T>
2806 static std::enable_if_t<IsPartialSpecialization<T>::value,
2809 Sema &S, T *Partial,
bool IsPartialOrdering,
2811 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2825 S, Partial, IsPartialOrdering, Deduced, Info, Builder))
2832 Info.
reset(DeducedArgumentList);
2840 auto *Template = Partial->getSpecializedTemplate();
2842 Partial->getTemplateArgsAsWritten();
2851 if (
ParamIdx >= Partial->getTemplateParameters()->size())
2852 ParamIdx = Partial->getTemplateParameters()->size() - 1;
2855 Partial->getTemplateParameters()->getParam(
ParamIdx));
2857 Info.
FirstArg = (*PartialTemplArgInfo)[ArgIdx].getArgument();
2861 bool ConstraintsNotSatisfied;
2864 false, ConvertedInstArgs,
2866 &ConstraintsNotSatisfied))
2871 for (
unsigned I = 0, E = TemplateParams->
size(); I != E; ++I) {
2896 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2915 for (
unsigned I = 0, E = TemplateParams->
size(); I != E; ++I) {
2967 TemplateArgs, Info, Deduced))
2974 return TDK_InstantiationDepth;
2981 Result = ::FinishTemplateArgumentDeduction(*this, Partial,
2983 TemplateArgs, Deduced, Info);
3017 TemplateArgs, Info, Deduced))
3024 return TDK_InstantiationDepth;
3031 Result = ::FinishTemplateArgumentDeduction(*this, Partial,
3033 TemplateArgs, Deduced, Info);
3042 return Spec->getTemplateName().getAsTemplateDecl() !=
nullptr;
3094 if (ExplicitTemplateArgs.
size() == 0) {
3097 for (
auto P : Function->parameters())
3098 ParamTypes.push_back(
P->getType());
3122 *
this, Info.
getLocation(), FunctionTemplate, DeducedArgs,
3123 CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
3125 return TDK_InstantiationDepth;
3127 if (CheckTemplateArgumentList(FunctionTemplate,
SourceLocation(),
3128 ExplicitTemplateArgs,
true, Builder,
false) ||
3130 unsigned Index = Builder.size();
3131 if (Index >= TemplateParams->
size())
3132 return TDK_SubstitutionFailure;
3134 return TDK_InvalidExplicitArguments;
3153 unsigned PartiallySubstitutedPackIndex = -1u;
3154 if (!Builder.empty()) {
3157 auto *Param = TemplateParams->
getParam(Builder.size() - 1);
3161 if (!Expansions || Arg.
pack_size() < *Expansions) {
3162 PartiallySubstitutedPackIndex = Builder.size() - 1;
3163 CurrentInstantiationScope->SetPartiallySubstitutedPack(
3171 assert(Proto &&
"Function template does not have a prototype?");
3183 if (SubstParmTypes(Function->getLocation(), Function->parameters(),
3186 ParamTypes,
nullptr, ExtParamInfos))
3187 return TDK_SubstitutionFailure;
3201 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
3203 ThisTypeQuals = Method->getMethodQualifiers();
3212 Function->getTypeSpecStartLoc(), Function->getDeclName());
3214 return TDK_SubstitutionFailure;
3216 if (getLangOpts().
CUDA)
3217 if (Function->hasAttr<CUDAGlobalAttr>() && !ResultType->
isVoidType()) {
3218 Diag(Function->getLocation(), diag::err_kern_type_not_void_return)
3219 << Function->getType() << Function->getSourceRange();
3220 return TDK_SubstitutionFailure;
3227 SubstParmTypes(Function->getLocation(), Function->parameters(),
3230 ParamTypes,
nullptr, ExtParamInfos))
3231 return TDK_SubstitutionFailure;
3243 Function->getLocation(), EPI.ExceptionSpec, ExceptionStorage,
3245 return TDK_SubstitutionFailure;
3247 *
FunctionType = BuildFunctionType(ResultType, ParamTypes,
3248 Function->getLocation(),
3249 Function->getDeclName(),
3252 return TDK_SubstitutionFailure;
3265 Deduced.reserve(TemplateParams->
size());
3266 for (
unsigned I = 0, N = ExplicitArgumentList->
size(); I != N; ++I) {
3268 if (I == PartiallySubstitutedPackIndex)
3271 Deduced.push_back(Arg);
3339 if (AQuals == DeducedAQuals) {
3357 bool ObjCLifetimeConversion =
false;
3361 ObjCLifetimeConversion) ||
3407 if (PD->isParameterPack()) {
3408 unsigned NumExpansions =
3410 if (Idx + NumExpansions >
ParamIdx)
3412 Idx += NumExpansions;
3420 llvm_unreachable(
"parameter index would not be produced from template");
3432 unsigned NumExplicitlySpecified,
FunctionDecl *&Specialization,
3435 bool PartialOverloading, llvm::function_ref<
bool()> CheckNonDependent) {
3445 *
this, Info.
getLocation(), FunctionTemplate, DeducedArgs,
3446 CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
3448 return TDK_InstantiationDepth;
3457 *
this, FunctionTemplate,
true, Deduced, Info, Builder,
3458 CurrentInstantiationScope, NumExplicitlySpecified,
3459 PartialOverloading))
3471 if (CheckNonDependent())
3472 return TDK_NonDependentConversionFailure;
3477 Info.
reset(DeducedArgumentList);
3488 return TDK_SubstitutionFailure;
3490 assert(
Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
3495 if (
Specialization->getTemplateSpecializationArgs() == DeducedArgumentList &&
3504 return TDK_SubstitutionFailure;
3515 if (!PartialOverloading ||
3517 if (CheckInstantiatedFunctionTemplateConstraints(Info.
getLocation(),
3519 return TDK_MiscellaneousDeductionFailure;
3523 return TDK_ConstraintsNotSatisfied;
3527 if (OriginalCallArgs) {
3532 llvm::SmallDenseMap<std::pair<unsigned, QualType>,
QualType> DeducedATypes;
3533 for (
unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
3554 if (CacheEntry.
isNull()) {
3563 DeducedA = CacheEntry;
3577 SuppressedDiagnosticsMap::iterator
3578 Pos = SuppressedDiagnostics.find(
Specialization->getCanonicalDecl());
3579 if (Pos == SuppressedDiagnostics.end())
3597 if (Method->isInstance()) {
3618 bool ParamWasReference) {
3626 if (ParamWasReference)
3681 if (ArgType.
isNull())
continue;
3701 Deduced(TemplateParams->
size());
3705 ArgType, Info, Deduced, TDF);
3706 if (Result)
continue;
3742 ParamRefType !=
nullptr);
3805 (isa<PointerType>(ParamType) &&
3820 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3821 SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs,
3822 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF);
3829 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3830 SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs,
unsigned ArgIdx,
3846 ElTy = ArrTy->getElementType();
3856 if (isa<DesignatedInitExpr>(E))
3863 S, TemplateParams, 0, ElTy, E, Info, Deduced, OriginalCallArgs,
true,
3871 if (
auto *DependentArrTy = dyn_cast_or_null<DependentSizedArrayType>(ArrTy)) {
3883 true, Info, Deduced))
3896 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3897 SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs,
3898 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF) {
3900 QualType OrigParamType = ParamType;
3905 S, TemplateParams, FirstInnerIndex, ParamType, ArgType, Arg, TDF))
3911 Deduced, OriginalCallArgs, ArgIdx, TDF);
3918 OriginalCallArgs.push_back(
3921 ArgType, Info, Deduced, TDF);
3953 bool PartialOverloading,
3959 unsigned NumParams = Function->getNumParams();
3967 if (Args.size() < Function->getMinRequiredArguments() && !PartialOverloading)
3968 return TDK_TooFewArguments;
3969 else if (TooManyArguments(NumParams, Args.size(), PartialOverloading)) {
3971 if (Proto->isTemplateVariadic())
3973 else if (!Proto->isVariadic())
3974 return TDK_TooManyArguments;
3984 unsigned NumExplicitlySpecified = 0;
3985 if (ExplicitTemplateArgs) {
3988 Result = SubstituteExplicitTemplateArguments(
3989 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, nullptr,
3995 NumExplicitlySpecified = Deduced.size();
3998 for (
unsigned I = 0; I != NumParams; ++I)
3999 ParamTypes.push_back(Function->getParamDecl(I)->getType());
4005 auto DeduceCallArgument = [&](
QualType ParamType,
unsigned ArgIdx) {
4015 *
this, TemplateParams, FirstInnerIndex, ParamType, Args[ArgIdx], Info, Deduced,
4016 OriginalCallArgs,
false, ArgIdx, 0);
4020 Deduced.resize(TemplateParams->
size());
4022 for (
unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0;
4027 dyn_cast<PackExpansionType>(ParamType);
4028 if (!ParamExpansion) {
4030 if (ArgIdx >= Args.size())
4033 ParamTypesForArgChecking.push_back(ParamType);
4034 if (
auto Result = DeduceCallArgument(ParamType, ArgIdx++))
4041 PackDeductionScope PackScope(*
this, TemplateParams, Deduced, Info,
4060 if (
ParamIdx + 1 == NumParamTypes || PackScope.hasFixedArity()) {
4061 for (; ArgIdx < Args.size() && PackScope.hasNextElement();
4062 PackScope.nextPackElement(), ++ArgIdx) {
4063 ParamTypesForArgChecking.push_back(ParamPattern);
4064 if (
auto Result = DeduceCallArgument(ParamPattern, ArgIdx))
4072 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
4073 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
4075 ParamTypesForArgChecking.push_back(ParamPattern);
4078 PackScope.nextPackElement();
4085 if (
auto Result = PackScope.finish())
4095 Result = FinishTemplateArgumentDeduction(
4096 FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
4097 &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() {
4098 ContextRAII SavedContext(*this, CallingCtx);
4099 return CheckNonDependent(ParamTypesForArgChecking);
4107 bool AdjustExceptionSpec) {
4108 if (ArgFunctionType.
isNull())
4109 return ArgFunctionType;
4114 bool Rebuild =
false;
4117 if (EPI.ExtInfo.getCC() != CC) {
4118 EPI.
ExtInfo = EPI.ExtInfo.withCallingConv(CC);
4122 bool NoReturn = FunctionTypeP->getNoReturnAttr();
4123 if (EPI.ExtInfo.getNoReturn() != NoReturn) {
4124 EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn);
4128 if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() ||
4130 EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec;
4135 return ArgFunctionType;
4173 bool IsAddressOfFunction) {
4185 unsigned NumExplicitlySpecified = 0;
4187 if (ExplicitTemplateArgs) {
4190 Result = SubstituteExplicitTemplateArguments(
4191 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes,
4192 &FunctionType, Info);
4197 NumExplicitlySpecified = Deduced.size();
4203 if (!IsAddressOfFunction)
4212 Deduced.resize(TemplateParams->
size());
4218 bool HasDeducedReturnType =
false;
4220 Function->getReturnType()->getContainedAutoType()) {
4222 HasDeducedReturnType =
true;
4232 Info, Deduced, TDF))
4238 Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
4239 NumExplicitlySpecified,
4240 Specialization, Info);
4247 if (HasDeducedReturnType &&
4254 auto *SpecializationFPT =
4266 if (!IsAddressOfFunction)
4273 if (!ArgFunctionType.
isNull()) {
4274 if (IsAddressOfFunction &&
4280 if (!IsAddressOfFunction &&
4312 P = PRef->getPointeeType();
4324 P =
P.getUnqualifiedType();
4331 assert(!A->
isReferenceType() &&
"Reference types were handled above");
4336 if (
P->isArrayType())
4341 else if (
P->isFunctionType())
4346 P =
P.getUnqualifiedType();
4368 Deduced.resize(TemplateParams->
size());
4392 P, A, Info, Deduced, TDF))
4401 Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
4402 ConversionSpecialized, Info);
4404 Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
4436 bool IsAddressOfFunction) {
4439 IsAddressOfFunction);
4443 struct DependentAuto {
bool IsPack; };
4447 class SubstituteDeducedTypeTransform :
4450 bool ReplacementIsPack;
4454 SubstituteDeducedTypeTransform(
Sema &SemaRef, DependentAuto DA)
4456 ReplacementIsPack(DA.IsPack), UseTypeSugar(
true) {}
4458 SubstituteDeducedTypeTransform(
Sema &SemaRef,
QualType Replacement,
4459 bool UseTypeSugar =
true)
4461 Replacement(Replacement), ReplacementIsPack(
false),
4462 UseTypeSugar(UseTypeSugar) {}
4465 assert(isa<TemplateTypeParmType>(Replacement) &&
4466 "unexpected unsugared replacement kind");
4484 return TransformDesugared(TLB, TL);
4486 QualType Result = SemaRef.Context.getAutoType(
4495 QualType TransformDeducedTemplateSpecializationType(
4498 return TransformDesugared(TLB, TL);
4500 QualType Result = SemaRef.Context.getDeducedTemplateSpecializationType(
4502 Replacement, Replacement.
isNull());
4518 return TransformType(TLB, TL);
4527 bool IgnoreConstraints) {
4529 DependentDeductionDepth, IgnoreConstraints);
4538 ArrayRef<SourceRange> Ranges) {
4542 auto D = S.
Diag(Info.
getLocation(), diag::err_auto_inconsistent_deduction);
4544 for (
auto R : Ranges)
4567 Deduced,
TypeLoc.getNameLoc())));
4568 for (
unsigned I = 0, C =
TypeLoc.getNumArgs(); I != C; ++I)
4581 llvm::raw_string_ostream OS(Buf);
4582 OS <<
"'" << Concept->getName();
4583 if (
TypeLoc.hasExplicitTemplateArgs()) {
4586 Type.getTypeConstraintConcept()->getTemplateParameters());
4591 diag::err_placeholder_constraints_not_satisfied)
4618 bool IgnoreConstraints) {
4619 if (Init->containsErrors())
4621 if (Init->getType()->isNonOverloadPlaceholderType()) {
4625 Init = NonPlaceholder.
get();
4628 DependentAuto DependentResult = {
4631 if (!DependentDeductionDepth &&
4633 Init->containsUnexpandedParameterPack())) {
4634 Result = SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
4635 assert(!Result.isNull() &&
"substituting DependentTy can't fail");
4640 unsigned Depth = DependentDeductionDepth.value_or(0);
4646 if (AT->isDecltypeAuto()) {
4647 if (isa<InitListExpr>(Init)) {
4648 Diag(Init->getBeginLoc(), diag::err_decltype_auto_initializer_list);
4656 assert(!Deduced.
isNull());
4657 if (AT->isConstrained() && !IgnoreConstraints) {
4658 auto ConstraintsResult =
4660 Type.getContainedAutoTypeLoc(),
4663 return ConstraintsResult;
4665 Result = SubstituteDeducedTypeTransform(*
this, Deduced).Apply(
Type);
4666 if (Result.isNull())
4670 if (isa<InitListExpr>(Init)) {
4671 Diag(Init->getBeginLoc(), diag::err_auto_init_list_from_c);
4688 Context, Loc, Loc, TemplParamPtr, Loc,
nullptr);
4691 SubstituteDeducedTypeTransform(*
this, TemplArg,
true)
4693 assert(!FuncParam.
isNull() &&
4694 "substituting template parameter for 'auto' failed");
4706 if (Init->isTypeDependent()) {
4708 SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
4709 assert(!Result.isNull() &&
"substituting DependentTy can't fail");
4730 if (isa<DesignatedInitExpr>(E))
4734 for (
unsigned i = 0, e = InitList->
getNumInits(); i < e; ++i) {
4738 *
this, TemplateParamsSt.get(), 0, TemplArg, Init,
4739 Info, Deduced, OriginalCallArgs,
true,
4741 return DeductionFailed(TDK, {DeducedFromInitRange,
4742 Init->getSourceRange()});
4746 DeducedFromInitRange = Init->getSourceRange();
4750 Diag(Loc, diag::err_auto_bitfield);
4755 *
this, TemplateParamsSt.get(), 0, FuncParam, Init, Info, Deduced,
4756 OriginalCallArgs,
false, 0, 0))
4757 return DeductionFailed(TDK, {});
4772 QualType MaybeAuto =
Type.getType().getNonReferenceType();
4776 if (AT->isConstrained() && !IgnoreConstraints) {
4780 return ConstraintsResult;
4784 Result = SubstituteDeducedTypeTransform(*
this,
DeducedType).Apply(
Type);
4785 if (Result.isNull())
4790 QualType DeducedA = InitList ? Deduced[0].getAsType() : Result;
4792 assert((
bool)InitList == OriginalArg.DecomposedParam &&
4793 "decomposed non-init-list in auto deduction?");
4797 return DeductionFailed(TDK, {});
4807 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
4808 .TransformType(TypeWithAuto);
4814 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
4815 .TransformType(TypeWithAuto);
4819 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
4820 .TransformType(TypeWithAuto);
4825 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
4826 .TransformType(TypeWithAuto);
4831 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
4833 .TransformType(TypeWithAuto);
4838 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
4840 .TransformType(TypeWithAuto);
4844 if (isa<InitListExpr>(Init))
4847 ? diag::err_init_capture_deduction_failure_from_init_list
4848 : diag::err_auto_var_deduction_failure_from_init_list)
4852 VDecl->
isInitCapture() ? diag::err_init_capture_deduction_failure
4853 : diag::err_auto_var_deduction_failure)
4855 << Init->getSourceRange();
4887 "failed to deduce lambda return type");
4914 Diag(Loc, diag::err_auto_fn_used_before_defined) << FD;
4918 return StillUndeduced;
4925 SmallVectorImpl<QualType> &ArgTypes) {
4939 ArgTypes.push_back(ArgTy);
4949 unsigned NumCallArguments1,
4958 assert(Proto1 && Proto2 &&
"Function templates must have prototypes");
4961 Deduced.resize(TemplateParams->
size());
4992 unsigned NumComparedArguments = NumCallArguments1;
4994 if (!Method2 && Method1 && !Method1->
isStatic()) {
4997 ++NumComparedArguments;
4998 }
else if (!Method1 && Method2 && !Method2->
isStatic()) {
5001 }
else if (Method1 && Method2 &&
Reversed) {
5006 ++NumComparedArguments;
5011 Args2.insert(Args2.end(), Proto2->param_type_begin(),
5012 Proto2->param_type_end());
5017 if (Args1.size() > NumComparedArguments)
5018 Args1.resize(NumComparedArguments);
5019 if (Args2.size() > NumComparedArguments)
5020 Args2.resize(NumComparedArguments);
5022 std::reverse(Args2.begin(), Args2.end());
5025 Args1.data(), Args1.size(), Info, Deduced,
5036 S, TemplateParams, Proto2->getReturnType(), Proto1->
getReturnType(),
5059 unsigned ArgIdx = 0, NumArgs = Deduced.size();
5060 for (; ArgIdx != NumArgs; ++ArgIdx)
5061 if (Deduced[ArgIdx].isNull())
5068 if (ArgIdx == NumArgs) {
5075 llvm::SmallBitVector UsedParameters(TemplateParams->
size());
5078 for (
unsigned I = 0, N = Args2.size(); I != N; ++I)
5086 TemplateParams->
getDepth(), UsedParameters);
5096 for (; ArgIdx != NumArgs; ++ArgIdx)
5099 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
5109 unsigned NumParams = Function->getNumParams();
5114 if (!
Last->isParameterPack())
5118 while (--NumParams > 0) {
5119 if (Function->getParamDecl(NumParams - 1)->isParameterPack())
5154 unsigned NumCallArguments2,
bool Reversed,
5155 bool AllowOrderingByConstraints) {
5158 if (!AllowOrderingByConstraints)
5163 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
5168 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
5170 return AtLeastAsConstrained1 ? FT1 : FT2;
5178 if (Better1 != Better2)
5179 return Better1 ? FT1 : FT2;
5181 if (!Better1 && !Better2)
5182 return JudgeByConstraints();
5189 if (Variadic1 != Variadic2)
5190 return Variadic1? FT2 : FT1;
5192 return JudgeByConstraints();
5236 bool Complain,
QualType TargetType) {
5237 if (SpecBegin == SpecEnd) {
5239 Diag(Loc, NoneDiag);
5245 if (SpecBegin + 1 == SpecEnd)
5252 = cast<FunctionDecl>(*Best)->getPrimaryTemplate();
5253 assert(BestTemplate &&
"Not a function template specialization?");
5256 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
5257 assert(Challenger &&
"Not a function template specialization?");
5262 BestTemplate = Challenger;
5268 bool Ambiguous =
false;
5271 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
5288 Diag(Loc, AmbigDiag);
5293 const auto *FD = cast<FunctionDecl>(*I);
5295 FD->getPrimaryTemplate()->getTemplateParameters(),
5296 *FD->getTemplateSpecializationArgs());
5297 if (!TargetType.
isNull())
5299 Diag((*I)->getLocation(), PD);
5313 template<
typename TemplateLikeDecl>
5315 TemplateLikeDecl *P2,
5344 Deduced.resize(P2->getTemplateParameters()->size());
5358 bool AtLeastAsSpecialized;
5363 TST1->template_arguments()),
5366 return AtLeastAsSpecialized;
5391 if (!Better1 && !Better2)
5393 if (Better1 && Better2) {
5397 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
5402 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
5404 return AtLeastAsConstrained1 ? PS1 : PS2;
5407 return Better1 ? PS1 : PS2;
5423 bool AtLeastAsConstrainedPrimary, AtLeastAsConstrainedSpec;
5425 AtLeastAsConstrainedSpec))
5427 if (!AtLeastAsConstrainedSpec)
5430 AtLeastAsConstrainedPrimary))
5432 return !AtLeastAsConstrainedPrimary;