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/SmallBitVector.h"
49#include "llvm/ADT/SmallPtrSet.h"
50#include "llvm/ADT/SmallVector.h"
51#include "llvm/Support/Casting.h"
52#include "llvm/Support/Compiler.h"
53#include "llvm/Support/ErrorHandling.h"
111using namespace clang;
117 if (Y.getBitWidth() >
X.getBitWidth())
118 X =
X.extend(Y.getBitWidth());
119 else if (Y.getBitWidth() <
X.getBitWidth())
120 Y = Y.extend(
X.getBitWidth());
123 if (
X.isSigned() != Y.isSigned()) {
125 if ((Y.isSigned() && Y.isNegative()) || (
X.isSigned() &&
X.isNegative()))
147 bool NumberOfArgumentsMustMatch);
151 bool OnlyDeduced,
unsigned Depth,
152 llvm::SmallBitVector &
Used);
155 bool OnlyDeduced,
unsigned Level,
156 llvm::SmallBitVector &Deduced);
166 if (
const auto *IC = dyn_cast<ImplicitCastExpr>(E))
167 E = IC->getSubExpr();
168 else if (
const auto *CE = dyn_cast<ConstantExpr>(E))
169 E = CE->getSubExpr();
170 else if (
const auto *Subst = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
171 E = Subst->getReplacement();
172 else if (
const auto *CCE = dyn_cast<CXXConstructExpr>(E)) {
174 if (CCE->getParenOrBraceRange().isValid())
177 assert(CCE->getNumArgs() >= 1 &&
"implicit construct expr should have 1 arg");
183 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
184 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
185 if (NTTP->getDepth() == Depth)
200 X = NX->getUnderlyingDecl();
201 if (
NamedDecl *NY = dyn_cast<NamedDecl>(Y))
202 Y = NY->getUnderlyingDecl();
227 QualType XType =
X.getNonTypeTemplateArgumentType();
235 switch (
X.getKind()) {
237 llvm_unreachable(
"Non-deduced template arguments handled above");
244 X.wasDeducedFromArrayBound() ||
250 return X.wasDeducedFromArrayBound() ? Y :
X;
264 return X.wasDeducedFromArrayBound() ? Y :
X;
291 llvm::FoldingSetNodeID ID1, ID2;
292 X.getAsExpr()->Profile(ID1, Context,
true);
295 return X.wasDeducedFromArrayBound() ? Y :
X;
302 assert(!
X.wasDeducedFromArrayBound());
315 X.getParamTypeForDecl());
357 XAEnd =
X.pack_end(),
359 XA != XAEnd; ++XA, ++YA) {
363 if (Merged.isNull() && !(XA->isNull() && YA->isNull()))
365 NewPack.push_back(Merged);
374 llvm_unreachable(
"Invalid TemplateArgument Kind!");
386 "deducing non-type template argument with wrong depth");
390 if (Result.isNull()) {
411 if (
auto *Expansion = dyn_cast<PackExpansionType>(ParamType))
412 ParamType = Expansion->getPattern();
426 S, TemplateParams, ParamType, ValueType, Info, Deduced,
439 S, TemplateParams, NTTP,
441 DeducedFromArrayBound),
442 ValueType, Info, Deduced);
461 Value->getType(), Info, Deduced);
474 Value->getType(), Info, Deduced);
507 = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
514 Deduced[TempParam->getIndex()],
516 if (Result.isNull()) {
517 Info.
Param = TempParam;
518 Info.
FirstArg = Deduced[TempParam->getIndex()];
523 Deduced[TempParam->getIndex()] = Result;
562 UP = IP->getInjectedSpecializationType();
569 if (
const auto *TD = TNP.getAsTemplateDecl(); TD && TD->isTypeAlias())
577 UA = Injected->getInjectedSpecializationType();
597 SA->template_arguments(), Info, Deduced,
606 RA ? dyn_cast<ClassTemplateSpecializationDecl>(RA->getDecl()) :
nullptr;
615 S, TemplateParams, TP->getTemplateName(),
616 TemplateName(SA->getSpecializedTemplate()), Info, Deduced))
621 SA->getTemplateArgs().asArray(), Info, Deduced,
629 case Type::TypeOfExpr:
631 case Type::DependentName:
633 case Type::UnresolvedUsing:
634 case Type::TemplateTypeParm:
637 case Type::ConstantArray:
638 case Type::IncompleteArray:
639 case Type::VariableArray:
640 case Type::DependentSizedArray:
642 cast<ArrayType>(T)->getElementType().getTypePtr());
691class PackDeductionScope {
697 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
698 unsigned NumNamedPacks = addPacks(Pattern);
699 finishConstruction(NumNamedPacks);
706 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
708 finishConstruction(1);
712 void addPack(
unsigned Index) {
716 Pack.Saved = Deduced[Index];
722 if (std::optional<unsigned> ExpandedPackExpansions =
724 FixedNumExpansions = ExpandedPackExpansions;
726 Packs.push_back(Pack);
732 llvm::SmallBitVector SawIndices(TemplateParams->size());
735 auto AddPack = [&](
unsigned Index) {
736 if (SawIndices[Index])
738 SawIndices[Index] =
true;
745 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
746 TemplateParams->getParam(Index))) {
747 if (!NTTP->isExpandedParameterPack())
748 if (
auto *Expansion = dyn_cast<PackExpansionType>(NTTP->getType()))
749 ExtraDeductions.push_back(Expansion->getPattern());
758 for (
unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
759 unsigned Depth, Index;
761 if (Depth == Info.getDeducedDepth())
768 assert(!Packs.empty() &&
"Pack expansion without unexpanded packs?");
770 unsigned NumNamedPacks = Packs.size();
774 while (!ExtraDeductions.empty())
775 Collect(ExtraDeductions.pop_back_val());
777 return NumNamedPacks;
780 void finishConstruction(
unsigned NumNamedPacks) {
783 unsigned NumPartialPackArgs = 0;
784 std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u);
786 if (
auto *Partial =
Scope->getPartiallySubstitutedPack(
787 &PartialPackArgs, &NumPartialPackArgs))
793 bool IsExpanded =
true;
794 for (
unsigned I = 0; I != NumNamedPacks; ++I) {
795 if (Packs[I].Index >= Info.getNumExplicitArgs()) {
797 IsPartiallyExpanded =
false;
800 if (PartialPackDepthIndex ==
801 std::make_pair(Info.getDeducedDepth(), Packs[I].Index)) {
802 IsPartiallyExpanded =
true;
808 if (IsPartiallyExpanded)
809 PackElements += NumPartialPackArgs;
811 PackElements += *FixedNumExpansions;
813 for (
auto &Pack : Packs) {
814 if (Info.PendingDeducedPacks.size() > Pack.Index)
815 Pack.Outer = Info.PendingDeducedPacks[Pack.Index];
817 Info.PendingDeducedPacks.resize(Pack.Index + 1);
818 Info.PendingDeducedPacks[Pack.Index] = &Pack;
820 if (PartialPackDepthIndex ==
821 std::make_pair(Info.getDeducedDepth(), Pack.Index)) {
822 Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs);
831 if (!IsPartiallyExpanded)
832 Deduced[Pack.Index] = Pack.New[PackElements];
838 ~PackDeductionScope() {
839 for (
auto &Pack : Packs)
840 Info.PendingDeducedPacks[Pack.Index] = Pack.Outer;
845 bool isPartiallyExpanded() {
return IsPartiallyExpanded; }
850 bool hasFixedArity() {
return FixedNumExpansions.has_value(); }
855 bool hasNextElement() {
856 return !FixedNumExpansions || *FixedNumExpansions > PackElements;
860 void nextPackElement() {
864 for (
auto &Pack : Packs) {
866 if (!Pack.New.empty() || !DeducedArg.
isNull()) {
867 while (Pack.New.size() < PackElements)
869 if (Pack.New.size() == PackElements)
870 Pack.New.push_back(DeducedArg);
872 Pack.New[PackElements] = DeducedArg;
873 DeducedArg = Pack.New.size() > PackElements + 1
874 ? Pack.New[PackElements + 1]
887 for (
auto &Pack : Packs) {
889 Deduced[Pack.Index] = Pack.Saved;
904 Pack.New.resize(PackElements);
908 if (Pack.New.empty()) {
914 std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
922 Pack.New[0].wasDeducedFromArrayBound());
928 if (Pack.Outer->DeferredDeduction.isNull()) {
931 Pack.Outer->DeferredDeduction = NewPack;
934 Loc = &Pack.Outer->DeferredDeduction;
936 Loc = &Deduced[Pack.Index];
945 if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) {
947 NewPack = Pack.DeferredDeduction;
951 NamedDecl *Param = TemplateParams->getParam(Pack.Index);
952 if (Result.isNull()) {
954 Info.FirstArg = OldPack;
955 Info.SecondArg = NewPack;
962 if (*Expansions != PackElements) {
964 Info.FirstArg = Result;
980 unsigned PackElements = 0;
981 bool IsPartiallyExpanded =
false;
983 std::optional<unsigned> FixedNumExpansions;
1023 const QualType *Params,
unsigned NumParams,
1024 const QualType *Args,
unsigned NumArgs,
1038 = dyn_cast<PackExpansionType>(Params[
ParamIdx]);
1043 if (ArgIdx >= NumArgs)
1046 if (isa<PackExpansionType>(Args[ArgIdx])) {
1056 S, TemplateParams, Params[
ParamIdx].getUnqualifiedType(),
1057 Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
1074 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
1078 if (
ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) {
1079 for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) {
1088 PackScope.nextPackElement();
1109 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
1110 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs;
1112 PackScope.nextPackElement();
1118 if (
auto Result = PackScope.finish())
1129 isa<PackExpansionType>(Args[ArgIdx]))
1133 if (ArgIdx < NumArgs)
1148 if (ParamQs == ArgQs)
1201 if (!Guide || !Guide->isImplicit())
1203 return Guide->getDeducedTemplate()->getTemplateParameters()->size();
1213 if (ParamRef->getPointeeType().getQualifiers())
1216 return TypeParm && TypeParm->
getIndex() >= FirstInnerIndex;
1222 return cast<CXXRecordDecl>(
1276 auto AddBases = [&Visited, &ToVisit](
const CXXRecordDecl *RD) {
1279 assert(T->
isRecordType() &&
"Base class that isn't a record?");
1281 ToVisit.push_back(T);
1290 while (!ToVisit.empty()) {
1291 QualType NextT = ToVisit.pop_back_val();
1297 S, TemplateParams,
P, NextT, BaseInfo, DeducedCopy);
1303 Matches.insert({RD, DeducedCopy});
1314 if (Matches.size() > 1) {
1316 for (
const auto &Match : Matches)
1317 AddBases(Match.first);
1321 while (Matches.size() > 1 && !ToVisit.empty()) {
1331 if (Matches.empty())
1333 if (Matches.size() > 1)
1336 std::swap(Matches.front().second, Deduced);
1372 if (
const auto *AExp = dyn_cast<PackExpansionType>(A))
1373 A = AExp->getPattern();
1454 TDF &= ~TDF_TopLevelParameterTypeList;
1457 P =
P->getPointeeType();
1474 unsigned Index = TTP->getIndex();
1489 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1501 "saw template type parameter with wrong depth");
1503 "Unresolved overloaded function");
1523 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1543 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1588 if (!
P->isDependentType()) {
1604 switch (
P.getCanonicalType()->getTypeClass()) {
1606#define NON_CANONICAL_TYPE(Class, Base) \
1607 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1608#define TYPE(Class, Base)
1609#include "clang/AST/TypeNodes.inc"
1611 case Type::TemplateTypeParm:
1612 case Type::SubstTemplateTypeParmPack:
1613 llvm_unreachable(
"Type nodes handled above");
1617 if (
P->isDependentType())
1621 case Type::VariableArray:
1623 case Type::FunctionNoProto:
1626 case Type::ObjCObject:
1627 case Type::ObjCInterface:
1628 case Type::ObjCObjectPointer:
1638 case Type::Complex: {
1643 S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
1648 case Type::Atomic: {
1653 S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
1658 case Type::Pointer: {
1669 PointeeType, Info, Deduced,
1674 case Type::LValueReference: {
1681 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1686 case Type::RValueReference: {
1693 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1698 case Type::IncompleteArray: {
1710 case Type::ConstantArray: {
1714 if (!CAA || CAA->getSize() != CAP->getSize())
1718 S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info,
1723 case Type::DependentSizedArray: {
1732 S, TemplateParams, DAP->getElementType(), AA->getElementType(),
1745 "saw non-type template parameter with wrong depth");
1746 if (
const auto *CAA = dyn_cast<ConstantArrayType>(AA)) {
1747 llvm::APSInt Size(CAA->getSize());
1750 true, Info, Deduced);
1752 if (
const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
1753 if (DAA->getSizeExpr())
1755 S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced);
1764 case Type::FunctionProto: {
1770 if (FPP->getMethodQuals() != FPA->getMethodQuals() ||
1771 FPP->getRefQualifier() != FPA->getRefQualifier() ||
1772 FPP->isVariadic() != FPA->isVariadic())
1777 S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
1785 S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(),
1786 FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced,
1796 Expr *NoexceptExpr = FPP->getNoexceptExpr();
1801 "saw non-type template parameter with wrong depth");
1803 llvm::APSInt Noexcept(1);
1804 switch (FPA->canThrow()) {
1814 true, Info, Deduced);
1817 if (
Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
1819 S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
1832 case Type::InjectedClassName:
1841 case Type::TemplateSpecialization: {
1863 Deduced = DeducedOrig;
1867 TemplateParams,
P, Info, Deduced);
1880 case Type::MemberPointer: {
1897 S, TemplateParams, PPT, APT, Info, Deduced, SubTDF))
1900 S, TemplateParams,
QualType(MPP->getClass(), 0),
1901 QualType(MPA->getClass(), 0), Info, Deduced, SubTDF);
1909 case Type::BlockPointer: {
1915 S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info,
1922 case Type::ExtVector: {
1927 if (VP->getNumElements() != VA->getNumElements())
1929 ElementType = VA->getElementType();
1934 ElementType = VA->getElementType();
1940 S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
1944 case Type::DependentVector: {
1950 S, TemplateParams, VP->getElementType(), VA->getElementType(),
1951 Info, Deduced, TDF))
1961 ArgSize = VA->getNumElements();
1973 S, TemplateParams, VP->getElementType(), VA->getElementType(),
1974 Info, Deduced, TDF))
1984 VA->getSizeExpr(), Info, Deduced);
1993 case Type::DependentSizedExtVector: {
1999 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2000 Info, Deduced, TDF))
2010 ArgSize = VA->getNumElements();
2022 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2023 Info, Deduced, TDF))
2033 VA->getSizeExpr(), Info, Deduced);
2043 case Type::ConstantMatrix: {
2050 if (MP->getNumRows() != MA->getNumRows() ||
2051 MP->getNumColumns() != MA->getNumColumns()) {
2056 S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
2060 case Type::DependentSizedMatrix: {
2069 Info, Deduced, TDF))
2073 auto DeduceMatrixArg =
2074 [&S, &Info, &Deduced, &TemplateParams](
2078 const auto *ACM = dyn_cast<ConstantMatrixType>(A);
2079 const auto *ADM = dyn_cast<DependentSizedMatrixType>(A);
2080 if (!ParamExpr->isValueDependent()) {
2081 std::optional<llvm::APSInt> ParamConst =
2082 ParamExpr->getIntegerConstantExpr(S.
Context);
2087 if ((ACM->*GetArgDimension)() == *ParamConst)
2092 Expr *ArgExpr = (ADM->*GetArgDimensionExpr)();
2093 if (std::optional<llvm::APSInt> ArgConst =
2095 if (*ArgConst == *ParamConst)
2106 llvm::APSInt ArgConst(
2108 ArgConst = (ACM->*GetArgDimension)();
2111 true, Info, Deduced);
2115 (ADM->*GetArgDimensionExpr)(),
2119 if (
auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
2124 return DeduceMatrixArg(MP->getColumnExpr(), MA,
2132 case Type::DependentAddressSpace: {
2138 S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(),
2139 Info, Deduced, TDF))
2149 S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced);
2159 S, TemplateParams, ASP->getPointeeType(),
2171 true, Info, Deduced);
2176 case Type::DependentBitInt: {
2180 if (IP->isUnsigned() != IA->isUnsigned())
2189 ArgSize = IA->getNumBits();
2197 if (IP->isUnsigned() != IA->isUnsigned())
2205 case Type::TypeOfExpr:
2207 case Type::DependentName:
2208 case Type::UnresolvedUsing:
2209 case Type::Decltype:
2210 case Type::UnaryTransform:
2211 case Type::DeducedTemplateSpecialization:
2212 case Type::DependentTemplateSpecialization:
2213 case Type::PackExpansion:
2219 llvm_unreachable(
"Invalid Type Class!");
2233 switch (
P.getKind()) {
2235 llvm_unreachable(
"Null template argument in parameter list");
2240 S, TemplateParams,
P.getAsType(), A.
getAsType(), Info, Deduced, 0);
2254 llvm_unreachable(
"caller should handle pack expansions");
2289 false, Info, Deduced);
2309 llvm_unreachable(
"Argument packs should be expanded by the caller!");
2312 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2325 if (ArgIdx == Args.size())
2332 assert(ArgIdx == Args.size() - 1 &&
"Pack not at the end of argument list?");
2335 return ArgIdx < Args.size();
2341 bool FoundPackExpansion =
false;
2342 for (
const auto &A : Args) {
2343 if (FoundPackExpansion)
2351 if (A.isPackExpansion())
2352 FoundPackExpansion =
true;
2364 bool NumberOfArgumentsMustMatch) {
2379 if (!
P.isPackExpansion()) {
2384 return NumberOfArgumentsMustMatch
2391 if (As[ArgIdx].isPackExpansion())
2396 As[ArgIdx], Info, Deduced))
2414 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
2420 PackScope.hasNextElement();
2424 As[ArgIdx], Info, Deduced))
2427 PackScope.nextPackElement();
2432 if (
auto Result = PackScope.finish())
2446 ArgList.
asArray(), Info, Deduced,
2455 bool PackExpansionMatchesPack =
false) {
2458 if (PackExpansionMatchesPack &&
X.isPackExpansion() && !Y.
isPackExpansion())
2459 X =
X.getPackExpansionPattern();
2464 switch (
X.getKind()) {
2466 llvm_unreachable(
"Comparing NULL template argument");
2489 llvm::FoldingSetNodeID XID, YID;
2490 X.getAsExpr()->Profile(XID, Context,
true);
2496 unsigned PackIterationSize =
X.pack_size();
2505 bool XHasMoreArg =
X.pack_size() > Y.
pack_size();
2506 if (!(XHasMoreArg &&
X.pack_elements().back().isPackExpansion()) &&
2507 !(!XHasMoreArg && Y.
pack_elements().back().isPackExpansion()))
2516 for (
unsigned i = 0; i < PackIterationSize; ++i)
2518 PackExpansionMatchesPack))
2524 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2545 llvm_unreachable(
"Can't get a NULL template argument here");
2579 Builder.MakeTrivial(
Context, DTN->getQualifier(), Loc);
2582 Builder.MakeTrivial(
Context, QTN->getQualifier(), Loc);
2586 Builder.getWithLocInContext(
Context), Loc);
2599 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2617 unsigned ArgumentPackIndex) {
2639 CanonicalPackedArgsBuilder;
2647 "deduced nested pack");
2654 diag::err_template_arg_deduced_incomplete_pack)
2658 if (ConvertArg(InnerArg, SugaredPackedArgsBuilder.size()))
2662 SugaredPackedArgsBuilder.push_back(SugaredOutput.pop_back_val());
2663 CanonicalPackedArgsBuilder.push_back(CanonicalOutput.pop_back_val());
2668 if (SugaredPackedArgsBuilder.empty()) {
2673 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2675 NTTP, SugaredOutput,
2678 S.
SubstType(NTTP->getType(), Args, NTTP->getLocation(),
2679 NTTP->getDeclName()).isNull())
2681 }
else if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) {
2692 SugaredOutput.push_back(
2695 S.
Context, CanonicalPackedArgsBuilder));
2699 return ConvertArg(Arg, 0);
2705template <
typename TemplateDeclT>
2707 Sema &S, TemplateDeclT *Template,
bool IsDeduced,
2713 unsigned NumAlreadyConverted = 0,
bool PartialOverloading =
false) {
2716 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
2725 PackDeductionScope(S, TemplateParams, Deduced, Info, I).finish())
2729 if (!Deduced[I].isNull()) {
2730 if (I < NumAlreadyConverted) {
2735 CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) {
2738 CurrentInstantiationScope->ResetPartiallySubstitutedPack();
2745 SugaredBuilder.push_back(Deduced[I]);
2746 CanonicalBuilder.push_back(
2755 IsDeduced, SugaredBuilder,
2756 CanonicalBuilder)) {
2769 bool HasDefaultArg =
false;
2772 assert(isa<ClassTemplatePartialSpecializationDecl>(Template) ||
2773 isa<VarTemplatePartialSpecializationDecl>(Template));
2782 if (Rec->isLambda())
2783 if (
auto *Method = dyn_cast<CXXMethodDecl>(Rec->getDeclContext())) {
2785 ThisTypeQuals = Method->getMethodQualifiers();
2793 SugaredBuilder, CanonicalBuilder, HasDefaultArg);
2802 if (PartialOverloading)
break;
2827 if (
auto *DC = dyn_cast<DeclContext>(D))
2833 static constexpr bool value =
false;
2837 static constexpr bool value =
true;
2841 static constexpr bool value =
true;
2843template <
typename TemplateDeclT>
2858template <
typename TemplateDeclT>
2865 Template->getAssociatedConstraints(AssociatedConstraints);
2869 CanonicalDeducedArgs};
2873 NeedsReplacement ?
nullptr : &DeducedTAL,
2881 if (NeedsReplacement)
2897template <
typename T>
2898static std::enable_if_t<IsPartialSpecialization<T>::value,
2901 Sema &S, T *Partial,
bool IsPartialOrdering,
2917 S, Partial, IsPartialOrdering, Deduced, Info, SugaredBuilder,
2927 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
2935 auto *Template = Partial->getSpecializedTemplate();
2937 Partial->getTemplateArgsAsWritten();
2948 if (
ParamIdx >= Partial->getTemplateParameters()->size())
2949 ParamIdx = Partial->getTemplateParameters()->size() - 1;
2952 Partial->getTemplateParameters()->getParam(
ParamIdx));
2954 Info.
FirstArg = (*PartialTemplArgInfo)[ArgIdx].getArgument();
2958 bool ConstraintsNotSatisfied;
2960 CanonicalConvertedInstArgs;
2962 Template, Partial->getLocation(), InstArgs,
false,
2963 SugaredConvertedInstArgs, CanonicalConvertedInstArgs,
2964 true, &ConstraintsNotSatisfied))
2969 for (
unsigned I = 0, E = TemplateParams->
size(); I != E; ++I) {
2972 IsPartialOrdering)) {
2984 CanonicalBuilder, Info))
3011 SugaredBuilder, CanonicalBuilder,
3018 for (
unsigned I = 0, E = TemplateParams->
size(); I != E; ++I) {
3033 CanonicalBuilder, Info))
3070 TemplateArgs, Info, Deduced))
3084 Result = ::FinishTemplateArgumentDeduction(*this, Partial,
3086 TemplateArgs, Deduced, Info);
3120 TemplateArgs, Info, Deduced))
3134 Result = ::FinishTemplateArgumentDeduction(*this, Partial,
3136 TemplateArgs, Deduced, Info);
3145 return Spec->getTemplateName().getAsTemplateDecl() !=
nullptr;
3195 if (ExplicitTemplateArgs.
size() == 0) {
3198 for (
auto *
P : Function->parameters())
3199 ParamTypes.push_back(
P->getType());
3229 ExplicitTemplateArgs,
true, SugaredBuilder,
3233 unsigned Index = SugaredBuilder.size();
3234 if (Index >= TemplateParams->
size())
3247 CanonicalExplicitArgumentList);
3259 unsigned PartiallySubstitutedPackIndex = -1u;
3260 if (!CanonicalBuilder.empty()) {
3263 auto *Param = TemplateParams->
getParam(CanonicalBuilder.size() - 1);
3267 if (!Expansions || Arg.
pack_size() < *Expansions) {
3268 PartiallySubstitutedPackIndex = CanonicalBuilder.size() - 1;
3277 assert(Proto &&
"Function template does not have a prototype?");
3285 SugaredExplicitArgumentList->
asArray(),
3293 if (
SubstParmTypes(Function->getLocation(), Function->parameters(),
3295 nullptr, ExtParamInfos))
3310 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
3312 ThisTypeQuals = Method->getMethodQualifiers();
3320 Function->getTypeSpecStartLoc(), Function->getDeclName());
3325 if (Function->hasAttr<CUDAGlobalAttr>() && !ResultType->
isVoidType()) {
3326 Diag(Function->getLocation(), diag::err_kern_type_not_void_return)
3327 << Function->getType() << Function->getSourceRange();
3337 nullptr, ExtParamInfos))
3350 ExceptionStorage, MLTAL))
3354 Function->getLocation(),
3355 Function->getDeclName(),
3371 Deduced.reserve(TemplateParams->
size());
3372 for (
unsigned I = 0, N = SugaredExplicitArgumentList->
size(); I != N; ++I) {
3374 if (I == PartiallySubstitutedPackIndex)
3377 Deduced.push_back(Arg);
3445 if (AQuals == DeducedAQuals) {
3463 bool ObjCLifetimeConversion =
false;
3467 ObjCLifetimeConversion) ||
3513 if (PD->isParameterPack()) {
3514 unsigned NumExpansions =
3516 if (Idx + NumExpansions >
ParamIdx)
3518 Idx += NumExpansions;
3526 llvm_unreachable(
"parameter index would not be produced from template");
3541 bool PartialOverloading, llvm::function_ref<
bool()> CheckNonDependent) {
3565 NumExplicitlySpecified, PartialOverloading))
3577 if (CheckNonDependent())
3585 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
3600 assert(
Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
3606 CanonicalDeducedArgumentList &&
3626 if (!PartialOverloading ||
3627 (CanonicalBuilder.size() ==
3641 if (OriginalCallArgs) {
3646 llvm::SmallDenseMap<std::pair<unsigned, QualType>,
QualType> DeducedATypes;
3647 for (
unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
3668 if (CacheEntry.
isNull()) {
3677 DeducedA = CacheEntry;
3691 SuppressedDiagnosticsMap::iterator
3711 if (Method->isInstance()) {
3732 bool ParamWasReference) {
3740 if (ParamWasReference)
3795 if (ArgType.
isNull())
continue;
3815 Deduced(TemplateParams->
size());
3819 ArgType, Info, Deduced, TDF);
3856 ParamRefType !=
nullptr);
3917 (isa<PointerType>(ParamType) &&
3934 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF);
3958 ElTy = ArrTy->getElementType();
3968 if (isa<DesignatedInitExpr>(E))
3975 S, TemplateParams, 0, ElTy, E, Info, Deduced, OriginalCallArgs,
true,
3983 if (
auto *DependentArrTy = dyn_cast_or_null<DependentSizedArrayType>(ArrTy)) {
3994 S, TemplateParams, NTTP, llvm::APSInt(Size), T,
3995 true, Info, Deduced))
4010 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF) {
4012 QualType OrigParamType = ParamType;
4017 S, TemplateParams, FirstInnerIndex, ParamType, ArgType, Arg, TDF))
4023 Deduced, OriginalCallArgs, ArgIdx, TDF);
4030 OriginalCallArgs.push_back(
4033 ArgType, Info, Deduced, TDF);
4065 bool PartialOverloading,
4071 unsigned NumParams = Function->getNumParams();
4079 if (Args.size() < Function->getMinRequiredArguments() && !PartialOverloading)
4083 if (Proto->isTemplateVariadic())
4085 else if (!Proto->isVariadic())
4096 unsigned NumExplicitlySpecified = 0;
4097 if (ExplicitTemplateArgs) {
4100 Result = SubstituteExplicitTemplateArguments(
4101 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, nullptr,
4107 NumExplicitlySpecified = Deduced.size();
4110 for (
unsigned I = 0; I != NumParams; ++I)
4111 ParamTypes.push_back(Function->getParamDecl(I)->getType());
4117 auto DeduceCallArgument = [&](
QualType ParamType,
unsigned ArgIdx) {
4127 *
this, TemplateParams, FirstInnerIndex, ParamType, Args[ArgIdx], Info, Deduced,
4128 OriginalCallArgs,
false, ArgIdx, 0);
4132 Deduced.resize(TemplateParams->
size());
4134 for (
unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0;
4139 dyn_cast<PackExpansionType>(ParamType);
4140 if (!ParamExpansion) {
4142 if (ArgIdx >= Args.size())
4145 ParamTypesForArgChecking.push_back(ParamType);
4146 if (
auto Result = DeduceCallArgument(ParamType, ArgIdx++))
4153 PackDeductionScope PackScope(*
this, TemplateParams, Deduced, Info,
4172 if (
ParamIdx + 1 == NumParamTypes || PackScope.hasFixedArity()) {
4173 for (; ArgIdx < Args.size() && PackScope.hasNextElement();
4174 PackScope.nextPackElement(), ++ArgIdx) {
4175 ParamTypesForArgChecking.push_back(ParamPattern);
4176 if (
auto Result = DeduceCallArgument(ParamPattern, ArgIdx))
4183 std::optional<unsigned> NumExpansions =
4185 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
4186 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
4188 ParamTypesForArgChecking.push_back(ParamPattern);
4191 PackScope.nextPackElement();
4198 if (
auto Result = PackScope.finish())
4208 Result = FinishTemplateArgumentDeduction(
4209 FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
4210 &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() {
4211 ContextRAII SavedContext(*this, CallingCtx);
4212 return CheckNonDependent(ParamTypesForArgChecking);
4220 bool AdjustExceptionSpec) {
4221 if (ArgFunctionType.
isNull())
4222 return ArgFunctionType;
4227 bool Rebuild =
false;
4230 if (EPI.ExtInfo.getCC() != CC) {
4231 EPI.
ExtInfo = EPI.ExtInfo.withCallingConv(CC);
4235 bool NoReturn = FunctionTypeP->getNoReturnAttr();
4236 if (EPI.ExtInfo.getNoReturn() != NoReturn) {
4237 EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn);
4241 if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() ||
4243 EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec;
4248 return ArgFunctionType;
4286 bool IsAddressOfFunction) {
4298 unsigned NumExplicitlySpecified = 0;
4300 if (ExplicitTemplateArgs) {
4303 Result = SubstituteExplicitTemplateArguments(
4304 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes,
4305 &FunctionType, Info);
4310 NumExplicitlySpecified = Deduced.size();
4316 if (!IsAddressOfFunction)
4325 Deduced.resize(TemplateParams->
size());
4331 bool HasDeducedReturnType =
false;
4333 Function->getReturnType()->getContainedAutoType()) {
4335 HasDeducedReturnType =
true;
4345 Info, Deduced, TDF))
4351 Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
4352 NumExplicitlySpecified,
4353 Specialization, Info);
4360 if (HasDeducedReturnType &&
4367 auto *SpecializationFPT =
4379 if (!IsAddressOfFunction)
4386 if (!ArgFunctionType.
isNull()) {
4387 if (IsAddressOfFunction &&
4393 if (!IsAddressOfFunction &&
4425 P = PRef->getPointeeType();
4437 P =
P.getUnqualifiedType();
4444 assert(!A->
isReferenceType() &&
"Reference types were handled above");
4449 if (
P->isArrayType())
4454 else if (
P->isFunctionType())
4459 P =
P.getUnqualifiedType();
4481 Deduced.resize(TemplateParams->
size());
4505 P, A, Info, Deduced, TDF))
4514 Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
4515 ConversionSpecialized, Info);
4517 Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
4549 bool IsAddressOfFunction) {
4552 IsAddressOfFunction);
4556 struct DependentAuto {
bool IsPack; };
4560 class SubstituteDeducedTypeTransform :
4563 bool ReplacementIsPack;
4567 SubstituteDeducedTypeTransform(
Sema &SemaRef, DependentAuto DA)
4569 ReplacementIsPack(DA.IsPack), UseTypeSugar(
true) {}
4571 SubstituteDeducedTypeTransform(
Sema &SemaRef,
QualType Replacement,
4572 bool UseTypeSugar =
true)
4574 Replacement(Replacement), ReplacementIsPack(
false),
4575 UseTypeSugar(UseTypeSugar) {}
4578 assert(isa<TemplateTypeParmType>(Replacement) &&
4579 "unexpected unsugared replacement kind");
4597 return TransformDesugared(TLB, TL);
4599 QualType Result = SemaRef.Context.getAutoType(
4608 QualType TransformDeducedTemplateSpecializationType(
4611 return TransformDesugared(TLB, TL);
4613 QualType Result = SemaRef.Context.getDeducedTemplateSpecializationType(
4615 Replacement, Replacement.
isNull());
4631 return TransformType(TLB, TL);
4647 Deduced,
TypeLoc.getNameLoc())));
4648 for (
unsigned I = 0,
C =
TypeLoc.getNumArgs(); I !=
C; ++I)
4654 SugaredConverted, CanonicalConverted))
4664 llvm::raw_string_ostream
OS(Buf);
4665 OS <<
"'" << Concept->getName();
4666 if (
TypeLoc.hasExplicitTemplateArgs()) {
4669 Type.getTypeConstraintConcept()->getTemplateParameters());
4674 diag::err_placeholder_constraints_not_satisfied)
4703 bool DependentDeduction,
4704 bool IgnoreConstraints) {
4706 if (Init->containsErrors())
4712 if (Init->getType()->isNonOverloadPlaceholderType() || AT->
isDecltypeAuto()) {
4716 Init = NonPlaceholder.
get();
4719 DependentAuto DependentResult = {
4722 if (!DependentDeduction &&
4724 Init->containsUnexpandedParameterPack())) {
4725 Result = SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
4726 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
4730 auto *InitList = dyn_cast<InitListExpr>(Init);
4732 Diag(Init->getBeginLoc(), diag::err_auto_init_list_from_c);
4743 if (Init->isTypeDependent()) {
4745 SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
4746 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
4758 Diag(Init->getBeginLoc(), diag::err_decltype_auto_initializer_list);
4771 nullptr,
false,
false,
false);
4775 Context, Loc, Loc, TemplParamPtr, Loc,
nullptr);
4785 for (
Expr *Init : InitList->inits()) {
4788 if (isa<DesignatedInitExpr>(Init))
4791 *
this, TemplateParamsSt.get(), 0, TemplArg, Init, Info, Deduced,
4792 OriginalCallArgs,
true,
4797 << Init->getSourceRange();
4800 return DeductionFailed(TDK);
4805 DeducedFromInitRange = Init->getSourceRange();
4809 Diag(Loc, diag::err_auto_bitfield);
4813 SubstituteDeducedTypeTransform(*
this, TemplArg).Apply(
Type);
4814 assert(!FuncParam.
isNull() &&
4815 "substituting template parameter for 'auto' failed");
4817 *
this, TemplateParamsSt.get(), 0, FuncParam, Init, Info, Deduced,
4818 OriginalCallArgs,
false, 0, 0))
4819 return DeductionFailed(TDK);
4856 assert((
bool)InitList == OriginalArg.DecomposedParam &&
4857 "decomposed non-init-list in auto deduction?");
4861 return DeductionFailed(TDK);
4871 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
4872 .TransformType(TypeWithAuto);
4878 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
4879 .TransformType(TypeWithAuto);
4883 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
4884 .TransformType(TypeWithAuto);
4889 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
4890 .TransformType(TypeWithAuto);
4895 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
4897 .TransformType(TypeWithAuto);
4902 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
4904 .TransformType(TypeWithAuto);
4908 if (isa<InitListExpr>(Init))
4911 ? diag::err_init_capture_deduction_failure_from_init_list
4912 : diag::err_auto_var_deduction_failure_from_init_list)
4916 VDecl->
isInitCapture() ? diag::err_init_capture_deduction_failure
4917 : diag::err_auto_var_deduction_failure)
4919 << Init->getSourceRange();
4951 "failed to deduce lambda return type");