44#include "llvm/ADT/APInt.h"
45#include "llvm/ADT/APSInt.h"
46#include "llvm/ADT/ArrayRef.h"
47#include "llvm/ADT/DenseMap.h"
48#include "llvm/ADT/FoldingSet.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"
112using namespace clang;
118 if (Y.getBitWidth() >
X.getBitWidth())
119 X =
X.extend(Y.getBitWidth());
120 else if (Y.getBitWidth() <
X.getBitWidth())
121 Y = Y.extend(
X.getBitWidth());
124 if (
X.isSigned() != Y.isSigned()) {
126 if ((Y.isSigned() && Y.isNegative()) || (
X.isSigned() &&
X.isNegative()))
148 bool NumberOfArgumentsMustMatch);
152 bool OnlyDeduced,
unsigned Depth,
153 llvm::SmallBitVector &
Used);
156 bool OnlyDeduced,
unsigned Level,
157 llvm::SmallBitVector &Deduced);
167 if (
const auto *IC = dyn_cast<ImplicitCastExpr>(E))
168 E = IC->getSubExpr();
169 else if (
const auto *CE = dyn_cast<ConstantExpr>(E))
170 E = CE->getSubExpr();
171 else if (
const auto *Subst = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
172 E = Subst->getReplacement();
173 else if (
const auto *CCE = dyn_cast<CXXConstructExpr>(E)) {
175 if (CCE->getParenOrBraceRange().isValid())
178 assert(CCE->getNumArgs() >= 1 &&
"implicit construct expr should have 1 arg");
184 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
185 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
186 if (NTTP->getDepth() == Depth)
201 X = NX->getUnderlyingDecl();
202 if (
NamedDecl *NY = dyn_cast<NamedDecl>(Y))
203 Y = NY->getUnderlyingDecl();
216 bool AggregateCandidateDeduction =
false) {
229 QualType XType =
X.getNonTypeTemplateArgumentType();
237 switch (
X.getKind()) {
239 llvm_unreachable(
"Non-deduced template arguments handled above");
246 X.wasDeducedFromArrayBound() ||
252 return X.wasDeducedFromArrayBound() ? Y :
X;
266 return X.wasDeducedFromArrayBound() ? Y :
X;
293 llvm::FoldingSetNodeID ID1, ID2;
294 X.getAsExpr()->Profile(ID1, Context,
true);
297 return X.wasDeducedFromArrayBound() ? Y :
X;
304 assert(!
X.wasDeducedFromArrayBound());
317 X.getParamTypeForDecl());
354 (!AggregateCandidateDeduction &&
X.pack_size() != Y.
pack_size()))
361 XA != XAEnd; ++XA, ++YA) {
366 if (Merged.isNull() && !(XA->isNull() && YA->isNull()))
368 NewPack.push_back(Merged);
370 NewPack.push_back(*XA);
380 llvm_unreachable(
"Invalid TemplateArgument Kind!");
392 "deducing non-type template argument with wrong depth");
396 if (Result.isNull()) {
417 if (
auto *Expansion = dyn_cast<PackExpansionType>(ParamType))
418 ParamType = Expansion->getPattern();
432 S, TemplateParams, ParamType, ValueType, Info, Deduced,
445 S, TemplateParams, NTTP,
447 DeducedFromArrayBound),
448 ValueType, Info, Deduced);
513 = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
520 Deduced[TempParam->getIndex()],
522 if (Result.isNull()) {
523 Info.
Param = TempParam;
524 Info.
FirstArg = Deduced[TempParam->getIndex()];
529 Deduced[TempParam->getIndex()] = Result;
568 UP = IP->getInjectedSpecializationType();
575 if (
const auto *TD = TNP.getAsTemplateDecl(); TD && TD->isTypeAlias())
583 UA = Injected->getInjectedSpecializationType();
603 SA->template_arguments(), Info, Deduced,
612 RA ? dyn_cast<ClassTemplateSpecializationDecl>(RA->getDecl()) :
nullptr;
621 S, TemplateParams, TP->getTemplateName(),
622 TemplateName(SA->getSpecializedTemplate()), Info, Deduced))
627 SA->getTemplateArgs().asArray(), Info, Deduced,
635 case Type::TypeOfExpr:
637 case Type::DependentName:
639 case Type::UnresolvedUsing:
640 case Type::TemplateTypeParm:
643 case Type::ConstantArray:
644 case Type::IncompleteArray:
645 case Type::VariableArray:
646 case Type::DependentSizedArray:
648 cast<ArrayType>(T)->getElementType().getTypePtr());
697class PackDeductionScope {
703 bool DeducePackIfNotAlreadyDeduced =
false)
704 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info),
705 DeducePackIfNotAlreadyDeduced(DeducePackIfNotAlreadyDeduced){
706 unsigned NumNamedPacks = addPacks(Pattern);
707 finishConstruction(NumNamedPacks);
714 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
716 finishConstruction(1);
720 void addPack(
unsigned Index) {
724 Pack.Saved = Deduced[Index];
730 if (std::optional<unsigned> ExpandedPackExpansions =
732 FixedNumExpansions = ExpandedPackExpansions;
734 Packs.push_back(Pack);
740 llvm::SmallBitVector SawIndices(TemplateParams->size());
743 auto AddPack = [&](
unsigned Index) {
744 if (SawIndices[Index])
746 SawIndices[Index] =
true;
753 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
754 TemplateParams->getParam(Index))) {
755 if (!NTTP->isExpandedParameterPack())
756 if (
auto *Expansion = dyn_cast<PackExpansionType>(NTTP->getType()))
757 ExtraDeductions.push_back(Expansion->getPattern());
766 for (
unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
767 unsigned Depth, Index;
769 if (Depth == Info.getDeducedDepth())
776 assert(!Packs.empty() &&
"Pack expansion without unexpanded packs?");
778 unsigned NumNamedPacks = Packs.size();
782 while (!ExtraDeductions.empty())
783 Collect(ExtraDeductions.pop_back_val());
785 return NumNamedPacks;
788 void finishConstruction(
unsigned NumNamedPacks) {
791 unsigned NumPartialPackArgs = 0;
792 std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u);
794 if (
auto *Partial =
Scope->getPartiallySubstitutedPack(
795 &PartialPackArgs, &NumPartialPackArgs))
801 bool IsExpanded =
true;
802 for (
unsigned I = 0; I != NumNamedPacks; ++I) {
803 if (Packs[I].Index >= Info.getNumExplicitArgs()) {
805 IsPartiallyExpanded =
false;
808 if (PartialPackDepthIndex ==
809 std::make_pair(Info.getDeducedDepth(), Packs[I].Index)) {
810 IsPartiallyExpanded =
true;
816 if (IsPartiallyExpanded)
817 PackElements += NumPartialPackArgs;
819 PackElements += *FixedNumExpansions;
821 for (
auto &Pack : Packs) {
822 if (Info.PendingDeducedPacks.size() > Pack.Index)
823 Pack.Outer = Info.PendingDeducedPacks[Pack.Index];
825 Info.PendingDeducedPacks.resize(Pack.Index + 1);
826 Info.PendingDeducedPacks[Pack.Index] = &Pack;
828 if (PartialPackDepthIndex ==
829 std::make_pair(Info.getDeducedDepth(), Pack.Index)) {
830 Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs);
839 if (!IsPartiallyExpanded)
840 Deduced[Pack.Index] = Pack.New[PackElements];
846 ~PackDeductionScope() {
847 for (
auto &Pack : Packs)
848 Info.PendingDeducedPacks[Pack.Index] = Pack.Outer;
853 bool isPartiallyExpanded() {
return IsPartiallyExpanded; }
858 bool hasFixedArity() {
return FixedNumExpansions.has_value(); }
863 bool hasNextElement() {
864 return !FixedNumExpansions || *FixedNumExpansions > PackElements;
868 void nextPackElement() {
872 for (
auto &Pack : Packs) {
874 if (!Pack.New.empty() || !DeducedArg.
isNull()) {
875 while (Pack.New.size() < PackElements)
877 if (Pack.New.size() == PackElements)
878 Pack.New.push_back(DeducedArg);
880 Pack.New[PackElements] = DeducedArg;
881 DeducedArg = Pack.New.size() > PackElements + 1
882 ? Pack.New[PackElements + 1]
895 for (
auto &Pack : Packs) {
897 Deduced[Pack.Index] = Pack.Saved;
912 Pack.New.resize(PackElements);
916 if (Pack.New.empty()) {
922 std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
930 Pack.New[0].wasDeducedFromArrayBound());
936 if (Pack.Outer->DeferredDeduction.isNull()) {
939 Pack.Outer->DeferredDeduction = NewPack;
942 Loc = &Pack.Outer->DeferredDeduction;
944 Loc = &Deduced[Pack.Index];
950 S.
Context, OldPack, NewPack, DeducePackIfNotAlreadyDeduced);
952 Info.AggregateDeductionCandidateHasMismatchedArity =
958 if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) {
960 NewPack = Pack.DeferredDeduction;
964 NamedDecl *Param = TemplateParams->getParam(Pack.Index);
965 if (Result.isNull()) {
967 Info.FirstArg = OldPack;
968 Info.SecondArg = NewPack;
975 if (*Expansions != PackElements) {
977 Info.FirstArg = Result;
993 unsigned PackElements = 0;
994 bool IsPartiallyExpanded =
false;
995 bool DeducePackIfNotAlreadyDeduced =
false;
997 std::optional<unsigned> FixedNumExpansions;
1037 const QualType *Params,
unsigned NumParams,
1038 const QualType *Args,
unsigned NumArgs,
1052 = dyn_cast<PackExpansionType>(Params[
ParamIdx]);
1057 if (ArgIdx >= NumArgs)
1060 if (isa<PackExpansionType>(Args[ArgIdx])) {
1070 S, TemplateParams, Params[
ParamIdx].getUnqualifiedType(),
1071 Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
1088 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
1092 if (
ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) {
1093 for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) {
1102 PackScope.nextPackElement();
1123 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
1124 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs;
1126 PackScope.nextPackElement();
1132 if (
auto Result = PackScope.finish())
1143 isa<PackExpansionType>(Args[ArgIdx]))
1147 if (ArgIdx < NumArgs)
1162 if (ParamQs == ArgQs)
1215 if (!Guide || !Guide->isImplicit())
1217 return Guide->getDeducedTemplate()->getTemplateParameters()->size();
1227 if (ParamRef->getPointeeType().getQualifiers())
1230 return TypeParm && TypeParm->
getIndex() >= FirstInnerIndex;
1236 return cast<CXXRecordDecl>(
1293 assert(T->
isRecordType() &&
"Base class that isn't a record?");
1295 ToVisit.push_back(T);
1304 while (!ToVisit.empty()) {
1305 QualType NextT = ToVisit.pop_back_val();
1311 S, TemplateParams,
P, NextT, BaseInfo, DeducedCopy);
1317 Matches.insert({RD, DeducedCopy});
1328 if (Matches.size() > 1) {
1330 for (
const auto &Match : Matches)
1331 AddBases(Match.first);
1335 while (Matches.size() > 1 && !ToVisit.empty()) {
1345 if (Matches.empty())
1347 if (Matches.size() > 1)
1350 std::swap(Matches.front().second, Deduced);
1386 if (
const auto *AExp = dyn_cast<PackExpansionType>(A))
1387 A = AExp->getPattern();
1468 TDF &= ~TDF_TopLevelParameterTypeList;
1471 P =
P->getPointeeType();
1488 unsigned Index = TTP->getIndex();
1503 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1515 "saw template type parameter with wrong depth");
1517 "Unresolved overloaded function");
1537 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1557 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1602 if (!
P->isDependentType()) {
1618 switch (
P.getCanonicalType()->getTypeClass()) {
1620#define NON_CANONICAL_TYPE(Class, Base) \
1621 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1622#define TYPE(Class, Base)
1623#include "clang/AST/TypeNodes.inc"
1625 case Type::TemplateTypeParm:
1626 case Type::SubstTemplateTypeParmPack:
1627 llvm_unreachable(
"Type nodes handled above");
1635 if (
P->isDependentType())
1639 case Type::VariableArray:
1641 case Type::FunctionNoProto:
1644 case Type::ObjCObject:
1645 case Type::ObjCInterface:
1646 case Type::ObjCObjectPointer:
1656 case Type::Complex: {
1661 S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
1666 case Type::Atomic: {
1671 S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
1676 case Type::Pointer: {
1687 PointeeType, Info, Deduced,
1692 case Type::LValueReference: {
1699 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1704 case Type::RValueReference: {
1711 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1716 case Type::IncompleteArray: {
1722 assert(IAP &&
"Template parameter not of incomplete array type");
1725 S, TemplateParams, IAP->getElementType(), IAA->getElementType(), Info,
1730 case Type::ConstantArray: {
1734 if (!CAA || CAA->getSize() != CAP->getSize())
1738 S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info,
1743 case Type::DependentSizedArray: {
1752 S, TemplateParams, DAP->getElementType(), AA->getElementType(),
1765 "saw non-type template parameter with wrong depth");
1766 if (
const auto *CAA = dyn_cast<ConstantArrayType>(AA)) {
1767 llvm::APSInt Size(CAA->getSize());
1770 true, Info, Deduced);
1772 if (
const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
1773 if (DAA->getSizeExpr())
1775 S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced);
1784 case Type::FunctionProto: {
1790 if (FPP->getMethodQuals() != FPA->getMethodQuals() ||
1791 FPP->getRefQualifier() != FPA->getRefQualifier() ||
1792 FPP->isVariadic() != FPA->isVariadic())
1797 S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
1805 S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(),
1806 FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced,
1816 Expr *NoexceptExpr = FPP->getNoexceptExpr();
1821 "saw non-type template parameter with wrong depth");
1823 llvm::APSInt Noexcept(1);
1824 switch (FPA->canThrow()) {
1834 true, Info, Deduced);
1837 if (
Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
1839 S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
1852 case Type::InjectedClassName:
1861 case Type::TemplateSpecialization: {
1883 Deduced = DeducedOrig;
1887 TemplateParams,
P, Info, Deduced);
1900 case Type::MemberPointer: {
1917 S, TemplateParams, PPT, APT, Info, Deduced, SubTDF))
1920 S, TemplateParams,
QualType(MPP->getClass(), 0),
1921 QualType(MPA->getClass(), 0), Info, Deduced, SubTDF);
1929 case Type::BlockPointer: {
1935 S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info,
1942 case Type::ExtVector: {
1947 if (VP->getNumElements() != VA->getNumElements())
1949 ElementType = VA->getElementType();
1954 ElementType = VA->getElementType();
1960 S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
1964 case Type::DependentVector: {
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);
2013 case Type::DependentSizedExtVector: {
2019 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2020 Info, Deduced, TDF))
2030 ArgSize = VA->getNumElements();
2042 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2043 Info, Deduced, TDF))
2053 VA->getSizeExpr(), Info, Deduced);
2063 case Type::ConstantMatrix: {
2070 if (MP->getNumRows() != MA->getNumRows() ||
2071 MP->getNumColumns() != MA->getNumColumns()) {
2076 S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
2080 case Type::DependentSizedMatrix: {
2089 Info, Deduced, TDF))
2093 auto DeduceMatrixArg =
2094 [&S, &Info, &Deduced, &TemplateParams](
2098 const auto *ACM = dyn_cast<ConstantMatrixType>(A);
2099 const auto *ADM = dyn_cast<DependentSizedMatrixType>(A);
2100 if (!ParamExpr->isValueDependent()) {
2101 std::optional<llvm::APSInt> ParamConst =
2102 ParamExpr->getIntegerConstantExpr(S.
Context);
2107 if ((ACM->*GetArgDimension)() == *ParamConst)
2112 Expr *ArgExpr = (ADM->*GetArgDimensionExpr)();
2113 if (std::optional<llvm::APSInt> ArgConst =
2115 if (*ArgConst == *ParamConst)
2126 llvm::APSInt ArgConst(
2128 ArgConst = (ACM->*GetArgDimension)();
2131 true, Info, Deduced);
2135 (ADM->*GetArgDimensionExpr)(),
2139 if (
auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
2144 return DeduceMatrixArg(MP->getColumnExpr(), MA,
2152 case Type::DependentAddressSpace: {
2158 S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(),
2159 Info, Deduced, TDF))
2169 S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced);
2179 S, TemplateParams, ASP->getPointeeType(),
2191 true, Info, Deduced);
2196 case Type::DependentBitInt: {
2200 if (IP->isUnsigned() != IA->isUnsigned())
2209 ArgSize = IA->getNumBits();
2217 if (IP->isUnsigned() != IA->isUnsigned())
2225 case Type::TypeOfExpr:
2227 case Type::DependentName:
2228 case Type::UnresolvedUsing:
2229 case Type::Decltype:
2230 case Type::UnaryTransform:
2231 case Type::DeducedTemplateSpecialization:
2232 case Type::DependentTemplateSpecialization:
2233 case Type::PackExpansion:
2239 llvm_unreachable(
"Invalid Type Class!");
2253 switch (
P.getKind()) {
2255 llvm_unreachable(
"Null template argument in parameter list");
2260 S, TemplateParams,
P.getAsType(), A.
getAsType(), Info, Deduced, 0);
2274 llvm_unreachable(
"caller should handle pack expansions");
2309 false, Info, Deduced);
2329 llvm_unreachable(
"Argument packs should be expanded by the caller!");
2332 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2345 if (ArgIdx == Args.size())
2352 assert(ArgIdx == Args.size() - 1 &&
"Pack not at the end of argument list?");
2355 return ArgIdx < Args.size();
2361 bool FoundPackExpansion =
false;
2362 for (
const auto &A : Args) {
2363 if (FoundPackExpansion)
2371 if (A.isPackExpansion())
2372 FoundPackExpansion =
true;
2384 bool NumberOfArgumentsMustMatch) {
2399 if (!
P.isPackExpansion()) {
2404 return NumberOfArgumentsMustMatch
2411 if (As[ArgIdx].isPackExpansion())
2416 As[ArgIdx], Info, Deduced))
2434 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
2440 PackScope.hasNextElement();
2444 As[ArgIdx], Info, Deduced))
2447 PackScope.nextPackElement();
2452 if (
auto Result = PackScope.finish())
2466 ArgList.
asArray(), Info, Deduced,
2475 bool PackExpansionMatchesPack =
false) {
2478 if (PackExpansionMatchesPack &&
X.isPackExpansion() && !Y.
isPackExpansion())
2479 X =
X.getPackExpansionPattern();
2484 switch (
X.getKind()) {
2486 llvm_unreachable(
"Comparing NULL template argument");
2509 llvm::FoldingSetNodeID XID, YID;
2510 X.getAsExpr()->Profile(XID, Context,
true);
2516 unsigned PackIterationSize =
X.pack_size();
2525 bool XHasMoreArg =
X.pack_size() > Y.
pack_size();
2526 if (!(XHasMoreArg &&
X.pack_elements().back().isPackExpansion()) &&
2527 !(!XHasMoreArg && Y.
pack_elements().back().isPackExpansion()))
2536 for (
unsigned i = 0; i < PackIterationSize; ++i)
2538 PackExpansionMatchesPack))
2544 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2565 llvm_unreachable(
"Can't get a NULL template argument here");
2599 Builder.MakeTrivial(
Context, DTN->getQualifier(), Loc);
2602 Builder.MakeTrivial(
Context, QTN->getQualifier(), Loc);
2606 Builder.getWithLocInContext(
Context), Loc);
2619 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2637 unsigned ArgumentPackIndex) {
2659 CanonicalPackedArgsBuilder;
2667 "deduced nested pack");
2674 diag::err_template_arg_deduced_incomplete_pack)
2678 if (ConvertArg(InnerArg, SugaredPackedArgsBuilder.size()))
2682 SugaredPackedArgsBuilder.push_back(SugaredOutput.pop_back_val());
2683 CanonicalPackedArgsBuilder.push_back(CanonicalOutput.pop_back_val());
2688 if (SugaredPackedArgsBuilder.empty()) {
2693 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2695 NTTP, SugaredOutput,
2698 S.
SubstType(NTTP->getType(), Args, NTTP->getLocation(),
2699 NTTP->getDeclName()).isNull())
2701 }
else if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) {
2712 SugaredOutput.push_back(
2715 S.
Context, CanonicalPackedArgsBuilder));
2719 return ConvertArg(Arg, 0);
2725template <
typename TemplateDeclT>
2727 Sema &S, TemplateDeclT *Template,
bool IsDeduced,
2733 unsigned NumAlreadyConverted = 0,
bool PartialOverloading =
false) {
2736 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
2745 PackDeductionScope(S, TemplateParams, Deduced, Info, I).finish())
2749 if (!Deduced[I].isNull()) {
2750 if (I < NumAlreadyConverted) {
2755 CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) {
2758 CurrentInstantiationScope->ResetPartiallySubstitutedPack();
2765 SugaredBuilder.push_back(Deduced[I]);
2766 CanonicalBuilder.push_back(
2775 IsDeduced, SugaredBuilder,
2776 CanonicalBuilder)) {
2789 bool HasDefaultArg =
false;
2792 assert(isa<ClassTemplatePartialSpecializationDecl>(Template) ||
2793 isa<VarTemplatePartialSpecializationDecl>(Template));
2802 if (Rec->isLambda())
2803 if (
auto *Method = dyn_cast<CXXMethodDecl>(Rec->getDeclContext())) {
2805 ThisTypeQuals = Method->getMethodQualifiers();
2813 SugaredBuilder, CanonicalBuilder, HasDefaultArg);
2822 if (PartialOverloading)
break;
2847 if (
auto *DC = dyn_cast<DeclContext>(D))
2853 static constexpr bool value =
false;
2857 static constexpr bool value =
true;
2861 static constexpr bool value =
true;
2863template <
typename TemplateDeclT>
2878template <
typename TemplateDeclT>
2885 Template->getAssociatedConstraints(AssociatedConstraints);
2889 CanonicalDeducedArgs};
2893 NeedsReplacement ?
nullptr : &DeducedTAL,
2901 if (NeedsReplacement)
2917template <
typename T>
2918static std::enable_if_t<IsPartialSpecialization<T>::value,
2921 Sema &S, T *Partial,
bool IsPartialOrdering,
2937 S, Partial, IsPartialOrdering, Deduced, Info, SugaredBuilder,
2947 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
2955 auto *Template = Partial->getSpecializedTemplate();
2957 Partial->getTemplateArgsAsWritten();
2968 if (
ParamIdx >= Partial->getTemplateParameters()->size())
2969 ParamIdx = Partial->getTemplateParameters()->size() - 1;
2972 Partial->getTemplateParameters()->getParam(
ParamIdx));
2974 Info.
FirstArg = (*PartialTemplArgInfo)[ArgIdx].getArgument();
2978 bool ConstraintsNotSatisfied;
2980 CanonicalConvertedInstArgs;
2982 Template, Partial->getLocation(), InstArgs,
false,
2983 SugaredConvertedInstArgs, CanonicalConvertedInstArgs,
2984 true, &ConstraintsNotSatisfied))
2989 for (
unsigned I = 0, E = TemplateParams->
size(); I != E; ++I) {
2992 IsPartialOrdering)) {
3004 CanonicalBuilder, Info))
3031 SugaredBuilder, CanonicalBuilder,
3038 for (
unsigned I = 0, E = TemplateParams->
size(); I != E; ++I) {
3053 CanonicalBuilder, Info))
3090 TemplateArgs, Info, Deduced))
3104 Result = ::FinishTemplateArgumentDeduction(*this, Partial,
3106 TemplateArgs, Deduced, Info);
3140 TemplateArgs, Info, Deduced))
3154 Result = ::FinishTemplateArgumentDeduction(*this, Partial,
3156 TemplateArgs, Deduced, Info);
3165 return Spec->getTemplateName().getAsTemplateDecl() !=
nullptr;
3215 if (ExplicitTemplateArgs.
size() == 0) {
3218 for (
auto *
P : Function->parameters())
3219 ParamTypes.push_back(
P->getType());
3249 ExplicitTemplateArgs,
true, SugaredBuilder,
3253 unsigned Index = SugaredBuilder.size();
3254 if (Index >= TemplateParams->
size())
3267 CanonicalExplicitArgumentList);
3279 unsigned PartiallySubstitutedPackIndex = -1u;
3280 if (!CanonicalBuilder.empty()) {
3283 auto *Param = TemplateParams->
getParam(CanonicalBuilder.size() - 1);
3287 if (!Expansions || Arg.
pack_size() < *Expansions) {
3288 PartiallySubstitutedPackIndex = CanonicalBuilder.size() - 1;
3297 assert(Proto &&
"Function template does not have a prototype?");
3305 SugaredExplicitArgumentList->
asArray(),
3313 if (
SubstParmTypes(Function->getLocation(), Function->parameters(),
3315 nullptr, ExtParamInfos))
3330 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
3332 ThisTypeQuals = Method->getMethodQualifiers();
3340 Function->getTypeSpecStartLoc(), Function->getDeclName());
3345 if (Function->hasAttr<CUDAGlobalAttr>() && !ResultType->
isVoidType()) {
3346 Diag(Function->getLocation(), diag::err_kern_type_not_void_return)
3347 << Function->getType() << Function->getSourceRange();
3357 nullptr, ExtParamInfos))
3370 ExceptionStorage, MLTAL))
3374 Function->getLocation(),
3375 Function->getDeclName(),
3391 Deduced.reserve(TemplateParams->
size());
3392 for (
unsigned I = 0, N = SugaredExplicitArgumentList->
size(); I != N; ++I) {
3394 if (I == PartiallySubstitutedPackIndex)
3397 Deduced.push_back(Arg);
3465 if (AQuals == DeducedAQuals) {
3483 bool ObjCLifetimeConversion =
false;
3487 ObjCLifetimeConversion) ||
3533 if (PD->isParameterPack()) {
3534 unsigned NumExpansions =
3536 if (Idx + NumExpansions >
ParamIdx)
3538 Idx += NumExpansions;
3546 llvm_unreachable(
"parameter index would not be produced from template");
3561 bool PartialOverloading, llvm::function_ref<
bool()> CheckNonDependent) {
3585 NumExplicitlySpecified, PartialOverloading))
3597 if (CheckNonDependent())
3605 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
3637 assert(
Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
3643 CanonicalDeducedArgumentList &&
3663 if (!PartialOverloading ||
3664 (CanonicalBuilder.size() ==
3678 if (OriginalCallArgs) {
3683 llvm::SmallDenseMap<std::pair<unsigned, QualType>,
QualType> DeducedATypes;
3684 for (
unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
3705 if (CacheEntry.
isNull()) {
3714 DeducedA = CacheEntry;
3728 SuppressedDiagnosticsMap::iterator
3748 if (Method->isInstance()) {
3769 bool ParamWasReference,
3778 if (ParamWasReference)
3795 nullptr, FailedTSC))
3835 if (ArgType.
isNull())
continue;
3855 Deduced(TemplateParams->
size());
3859 ArgType, Info, Deduced, TDF);
3896 ParamRefType !=
nullptr, FailedTSC);
3957 (isa<PointerType>(ParamType) &&
3974 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF,
3999 ElTy = ArrTy->getElementType();
4009 if (isa<DesignatedInitExpr>(E))
4016 S, TemplateParams, 0, ElTy, E, Info, Deduced, OriginalCallArgs,
true,
4024 if (
auto *DependentArrTy = dyn_cast_or_null<DependentSizedArrayType>(ArrTy)) {
4035 S, TemplateParams, NTTP, llvm::APSInt(Size), T,
4036 true, Info, Deduced))
4051 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF,
4054 QualType OrigParamType = ParamType;
4059 FirstInnerIndex, ParamType,
4060 ArgType, Arg, TDF, FailedTSC))
4066 Deduced, OriginalCallArgs, ArgIdx, TDF);
4073 OriginalCallArgs.push_back(
4076 ArgType, Info, Deduced, TDF);
4108 bool PartialOverloading,
bool AggregateDeductionCandidate,
4114 unsigned NumParams = Function->getNumParams();
4122 if (Args.size() < Function->getMinRequiredArguments() && !PartialOverloading)
4126 if (Proto->isTemplateVariadic())
4128 else if (!Proto->isVariadic())
4139 unsigned NumExplicitlySpecified = 0;
4140 if (ExplicitTemplateArgs) {
4143 Result = SubstituteExplicitTemplateArguments(
4144 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, nullptr,
4150 NumExplicitlySpecified = Deduced.size();
4153 for (
unsigned I = 0; I != NumParams; ++I)
4154 ParamTypes.push_back(Function->getParamDecl(I)->getType());
4160 auto DeduceCallArgument = [&](
QualType ParamType,
unsigned ArgIdx) {
4170 *
this, TemplateParams, FirstInnerIndex, ParamType, Args[ArgIdx], Info, Deduced,
4171 OriginalCallArgs,
false, ArgIdx, 0);
4175 Deduced.resize(TemplateParams->
size());
4177 for (
unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0;
4182 dyn_cast<PackExpansionType>(ParamType);
4183 if (!ParamExpansion) {
4185 if (ArgIdx >= Args.size())
4188 ParamTypesForArgChecking.push_back(ParamType);
4189 if (
auto Result = DeduceCallArgument(ParamType, ArgIdx++))
4195 bool IsTrailingPack =
ParamIdx + 1 == NumParamTypes;
4198 PackDeductionScope PackScope(*
this, TemplateParams, Deduced, Info,
4200 AggregateDeductionCandidate && IsTrailingPack);
4218 if (IsTrailingPack || PackScope.hasFixedArity()) {
4219 for (; ArgIdx < Args.size() && PackScope.hasNextElement();
4220 PackScope.nextPackElement(), ++ArgIdx) {
4221 ParamTypesForArgChecking.push_back(ParamPattern);
4222 if (
auto Result = DeduceCallArgument(ParamPattern, ArgIdx))
4229 std::optional<unsigned> NumExpansions =
4231 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
4232 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
4234 ParamTypesForArgChecking.push_back(ParamPattern);
4237 PackScope.nextPackElement();
4244 if (
auto Result = PackScope.finish())
4254 Result = FinishTemplateArgumentDeduction(
4255 FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
4256 &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() {
4257 ContextRAII SavedContext(*this, CallingCtx);
4258 return CheckNonDependent(ParamTypesForArgChecking);
4266 bool AdjustExceptionSpec) {
4267 if (ArgFunctionType.
isNull())
4268 return ArgFunctionType;
4273 bool Rebuild =
false;
4276 if (EPI.ExtInfo.getCC() != CC) {
4277 EPI.
ExtInfo = EPI.ExtInfo.withCallingConv(CC);
4281 bool NoReturn = FunctionTypeP->getNoReturnAttr();
4282 if (EPI.ExtInfo.getNoReturn() != NoReturn) {
4283 EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn);
4287 if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() ||
4289 EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec;
4294 return ArgFunctionType;
4332 bool IsAddressOfFunction) {
4344 unsigned NumExplicitlySpecified = 0;
4346 if (ExplicitTemplateArgs) {
4349 Result = SubstituteExplicitTemplateArguments(
4350 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes,
4351 &FunctionType, Info);
4356 NumExplicitlySpecified = Deduced.size();
4362 if (!IsAddressOfFunction)
4371 Deduced.resize(TemplateParams->
size());
4375 bool HasDeducedReturnType =
false;
4377 Function->getReturnType()->getContainedAutoType()) {
4379 HasDeducedReturnType =
true;
4389 Info, Deduced, TDF))
4395 Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
4396 NumExplicitlySpecified,
4397 Specialization, Info);
4404 if (HasDeducedReturnType && IsAddressOfFunction &&
4417 auto *SpecializationFPT =
4429 if (!IsAddressOfFunction) {
4435 if (HasDeducedReturnType) {
4444 if (!ArgFunctionType.
isNull()) {
4445 if (IsAddressOfFunction
4483 P = PRef->getPointeeType();
4495 P =
P.getUnqualifiedType();
4502 assert(!A->
isReferenceType() &&
"Reference types were handled above");
4507 if (
P->isArrayType())
4512 else if (
P->isFunctionType())
4517 P =
P.getUnqualifiedType();
4539 Deduced.resize(TemplateParams->
size());
4563 P, A, Info, Deduced, TDF))
4572 Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
4573 ConversionSpecialized, Info);
4575 Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
4607 bool IsAddressOfFunction) {
4610 IsAddressOfFunction);
4614 struct DependentAuto {
bool IsPack; };
4618 class SubstituteDeducedTypeTransform :
4621 bool ReplacementIsPack;
4625 SubstituteDeducedTypeTransform(
Sema &SemaRef, DependentAuto DA)
4627 ReplacementIsPack(DA.IsPack), UseTypeSugar(
true) {}
4629 SubstituteDeducedTypeTransform(
Sema &SemaRef,
QualType Replacement,
4630 bool UseTypeSugar =
true)
4632 Replacement(Replacement), ReplacementIsPack(
false),
4633 UseTypeSugar(UseTypeSugar) {}
4636 assert(isa<TemplateTypeParmType>(Replacement) &&
4637 "unexpected unsugared replacement kind");
4655 return TransformDesugared(TLB, TL);
4657 QualType Result = SemaRef.Context.getAutoType(
4666 QualType TransformDeducedTemplateSpecializationType(
4669 return TransformDesugared(TLB, TL);
4671 QualType Result = SemaRef.Context.getDeducedTemplateSpecializationType(
4673 Replacement, Replacement.
isNull());
4689 return TransformType(TLB, TL);
4705 Deduced,
TypeLoc.getNameLoc())));
4706 for (
unsigned I = 0,
C =
TypeLoc.getNumArgs(); I !=
C; ++I)
4712 SugaredConverted, CanonicalConverted))
4722 llvm::raw_string_ostream OS(Buf);
4723 OS <<
"'" << Concept->getName();
4724 if (
TypeLoc.hasExplicitTemplateArgs()) {
4727 Type.getTypeConstraintConcept()->getTemplateParameters());
4732 diag::err_placeholder_constraints_not_satisfied)
4761 bool IgnoreConstraints,
4764 if (Init->containsErrors())
4770 if (Init->getType()->isNonOverloadPlaceholderType() || AT->
isDecltypeAuto()) {
4774 Init = NonPlaceholder.
get();
4777 DependentAuto DependentResult = {
4780 if (!DependentDeduction &&
4782 Init->containsUnexpandedParameterPack())) {
4783 Result = SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
4784 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
4788 auto *InitList = dyn_cast<InitListExpr>(Init);
4790 Diag(Init->getBeginLoc(), diag::err_auto_init_list_from_c);
4801 if (Init->isTypeDependent()) {
4803 SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
4804 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
4816 Diag(Init->getBeginLoc(), diag::err_decltype_auto_initializer_list);
4829 nullptr,
false,
false,
false);
4833 Context, Loc, Loc, TemplParamPtr, Loc,
nullptr);
4843 for (
Expr *Init : InitList->inits()) {
4846 if (isa<DesignatedInitExpr>(Init))
4849 *
this, TemplateParamsSt.get(), 0, TemplArg, Init, Info, Deduced,
4850 OriginalCallArgs,
true,
4855 << Init->getSourceRange();
4858 return DeductionFailed(TDK);
4863 DeducedFromInitRange = Init->getSourceRange();
4867 Diag(Loc, diag::err_auto_bitfield);
4871 SubstituteDeducedTypeTransform(*
this, TemplArg).Apply(
Type);
4872 assert(!FuncParam.
isNull() &&
4873 "substituting template parameter for 'auto' failed");
4875 *
this, TemplateParamsSt.get(), 0, FuncParam, Init, Info, Deduced,
4876 OriginalCallArgs,
false, 0, 0,
4878 return DeductionFailed(TDK);
4915 assert((
bool)InitList == OriginalArg.DecomposedParam &&
4916 "decomposed non-init-list in auto deduction?");
4920 return DeductionFailed(TDK);
4930 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
4931 .TransformType(TypeWithAuto);
4937 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
4938 .TransformType(TypeWithAuto);
4942 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
4943 .TransformType(TypeWithAuto);
4948 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
4949 .TransformType(TypeWithAuto);
4954 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
4956 .TransformType(TypeWithAuto);
4961 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
4963 .TransformType(TypeWithAuto);
4967 if (isa<InitListExpr>(Init))
4970 ? diag::err_init_capture_deduction_failure_from_init_list
4971 : diag::err_auto_var_deduction_failure_from_init_list)