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()))
149 bool NumberOfArgumentsMustMatch,
154 bool OnlyDeduced,
unsigned Depth,
155 llvm::SmallBitVector &
Used);
158 bool OnlyDeduced,
unsigned Level,
159 llvm::SmallBitVector &Deduced);
169 if (
const auto *IC = dyn_cast<ImplicitCastExpr>(
E))
170 E = IC->getSubExpr();
171 else if (
const auto *CE = dyn_cast<ConstantExpr>(
E))
172 E = CE->getSubExpr();
173 else if (
const auto *Subst = dyn_cast<SubstNonTypeTemplateParmExpr>(
E))
174 E = Subst->getReplacement();
175 else if (
const auto *CCE = dyn_cast<CXXConstructExpr>(
E)) {
177 if (CCE->getParenOrBraceRange().isValid())
180 assert(CCE->getNumArgs() >= 1 &&
"implicit construct expr should have 1 arg");
186 if (
const auto *DRE = dyn_cast<DeclRefExpr>(
E))
187 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
188 if (NTTP->getDepth() == Depth)
203 X = NX->getUnderlyingDecl();
204 if (
NamedDecl *NY = dyn_cast<NamedDecl>(Y))
205 Y = NY->getUnderlyingDecl();
218 bool AggregateCandidateDeduction =
false) {
231 QualType XType =
X.getNonTypeTemplateArgumentType();
239 switch (
X.getKind()) {
241 llvm_unreachable(
"Non-deduced template arguments handled above");
248 X.wasDeducedFromArrayBound() ||
254 return X.wasDeducedFromArrayBound() ? Y :
X;
268 return X.wasDeducedFromArrayBound() ? Y :
X;
277 X.structurallyEquals(Y)))
305 llvm::FoldingSetNodeID ID1, ID2;
306 X.getAsExpr()->Profile(ID1, Context,
true);
309 return X.wasDeducedFromArrayBound() ? Y :
X;
316 assert(!
X.wasDeducedFromArrayBound());
329 X.getParamTypeForDecl());
366 (!AggregateCandidateDeduction &&
X.pack_size() != Y.
pack_size()))
373 XA != XAEnd; ++XA, ++YA) {
378 if (Merged.isNull() && !(XA->isNull() && YA->isNull()))
380 NewPack.push_back(Merged);
382 NewPack.push_back(*XA);
392 llvm_unreachable(
"Invalid TemplateArgument Kind!");
405 "deducing non-type template argument with wrong depth");
409 if (Result.isNull()) {
413 return TemplateDeductionResult::Inconsistent;
418 return TemplateDeductionResult::Success;
425 return TemplateDeductionResult::Success;
430 if (
auto *Expansion = dyn_cast<PackExpansionType>(ParamType))
431 ParamType = Expansion->getPattern();
445 S, TemplateParams, ParamType, ValueType, Info, Deduced,
458 S, TemplateParams, NTTP,
460 DeducedFromArrayBound),
461 ValueType, Info, Deduced);
519 case Decl::TemplateTypeParm: {
520 auto *
T = cast<TemplateTypeParmDecl>(A);
523 T->getDepth(),
T->getIndex(),
T->getIdentifier(),
524 T->wasDeclaredWithTypename(),
T->isParameterPack(),
525 T->hasTypeConstraint());
526 R->setDefaultArgument(
529 if (R->hasTypeConstraint()) {
530 auto *
C = R->getTypeConstraint();
531 R->setTypeConstraint(
C->getConceptReference(),
532 C->getImmediatelyDeclaredConstraint());
536 case Decl::NonTypeTemplateParm: {
537 auto *
T = cast<NonTypeTemplateParmDecl>(A);
540 T->getDepth(),
T->getIndex(),
T->getIdentifier(),
T->getType(),
541 T->isParameterPack(),
T->getTypeSourceInfo());
542 R->setDefaultArgument(S.
Context,
546 if (
auto *PTC =
T->getPlaceholderTypeConstraint())
547 R->setPlaceholderTypeConstraint(PTC);
550 case Decl::TemplateTemplateParm: {
551 auto *
T = cast<TemplateTemplateParmDecl>(A);
554 T->getIndex(),
T->isParameterPack(),
T->getIdentifier(),
555 T->wasDeclaredWithTypename(),
T->getTemplateParameters());
556 R->setDefaultArgument(
562 llvm_unreachable(
"Unexpected Decl Kind");
576 return TemplateDeductionResult::Success;
579 if (
auto *TempParam = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
582 return TemplateDeductionResult::Success;
589 if (
auto *TempArg = dyn_cast_or_null<TemplateTemplateParmDecl>(
591 assert(!TempArg->isExpandedParameterPack());
594 if (DefaultArguments.size() != 0) {
595 assert(DefaultArguments.size() <= As->
size());
597 for (
unsigned I = 0; I < DefaultArguments.size(); ++I)
599 DefaultArguments[I]);
600 for (
unsigned I = DefaultArguments.size(); I < As->size(); ++I)
605 auto *TPL = TemplateParameterList::Create(
611 TempArg->getDepth(), TempArg->getPosition(),
612 TempArg->isParameterPack(), TempArg->getIdentifier(),
613 TempArg->wasDeclaredWithTypename(), TPL)));
618 Deduced[TempParam->getIndex()],
620 if (Result.isNull()) {
621 Info.
Param = TempParam;
622 Info.
FirstArg = Deduced[TempParam->getIndex()];
624 return TemplateDeductionResult::Inconsistent;
627 Deduced[TempParam->getIndex()] = Result;
628 return TemplateDeductionResult::Success;
633 return TemplateDeductionResult::Success;
638 return TemplateDeductionResult::NonDeducedMismatch;
664 assert(TST &&
"Expected a TemplateSpecializationType");
678 UP = IP->getInjectedSpecializationType();
686 return TemplateDeductionResult::Success;
693 ->template_arguments();
696 std::optional<NestedNameSpecifier *> NNS;
699 NNS = Elaborated->getQualifier();
701 UA = Injected->getInjectedSpecializationType();
712 return TemplateDeductionResult::Success;
719 ->template_arguments();
724 Result != TemplateDeductionResult::Success)
740 RA ? dyn_cast<ClassTemplateSpecializationDecl>(RA->getDecl()) :
nullptr;
744 return TemplateDeductionResult::NonDeducedMismatch;
750 *NNS,
false,
TemplateName(SA->getSpecializedTemplate()));
755 SA->getTemplateArgs().asArray(), Deduced);
756 Result != TemplateDeductionResult::Success)
761 SA->getTemplateArgs().asArray(), Info, Deduced,
769 case Type::TypeOfExpr:
771 case Type::DependentName:
773 case Type::PackIndexing:
774 case Type::UnresolvedUsing:
775 case Type::TemplateTypeParm:
779 case Type::ConstantArray:
780 case Type::IncompleteArray:
781 case Type::VariableArray:
782 case Type::DependentSizedArray:
784 cast<ArrayType>(
T)->getElementType().getTypePtr());
833class PackDeductionScope {
839 bool DeducePackIfNotAlreadyDeduced =
false)
840 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info),
841 DeducePackIfNotAlreadyDeduced(DeducePackIfNotAlreadyDeduced){
842 unsigned NumNamedPacks = addPacks(Pattern);
843 finishConstruction(NumNamedPacks);
850 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
852 finishConstruction(1);
856 void addPack(
unsigned Index) {
859 DeducedFromEarlierParameter = !Deduced[Index].isNull();
861 Pack.Saved = Deduced[Index];
867 if (std::optional<unsigned> ExpandedPackExpansions =
869 FixedNumExpansions = ExpandedPackExpansions;
871 Packs.push_back(Pack);
877 llvm::SmallBitVector SawIndices(TemplateParams->size());
880 auto AddPack = [&](
unsigned Index) {
881 if (SawIndices[Index])
883 SawIndices[Index] =
true;
890 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
891 TemplateParams->getParam(Index))) {
892 if (!NTTP->isExpandedParameterPack())
893 if (
auto *Expansion = dyn_cast<PackExpansionType>(NTTP->getType()))
894 ExtraDeductions.push_back(Expansion->getPattern());
903 for (
unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
904 unsigned Depth, Index;
906 if (Depth == Info.getDeducedDepth())
913 assert(!Packs.empty() &&
"Pack expansion without unexpanded packs?");
915 unsigned NumNamedPacks = Packs.size();
919 while (!ExtraDeductions.empty())
920 Collect(ExtraDeductions.pop_back_val());
922 return NumNamedPacks;
925 void finishConstruction(
unsigned NumNamedPacks) {
928 unsigned NumPartialPackArgs = 0;
929 std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u);
931 if (
auto *Partial =
Scope->getPartiallySubstitutedPack(
932 &PartialPackArgs, &NumPartialPackArgs))
938 bool IsExpanded =
true;
939 for (
unsigned I = 0; I != NumNamedPacks; ++I) {
940 if (Packs[I].Index >= Info.getNumExplicitArgs()) {
942 IsPartiallyExpanded =
false;
945 if (PartialPackDepthIndex ==
946 std::make_pair(Info.getDeducedDepth(), Packs[I].Index)) {
947 IsPartiallyExpanded =
true;
955 if (IsPartiallyExpanded)
956 PackElements += NumPartialPackArgs;
957 else if (IsExpanded && FixedNumExpansions)
958 PackElements += *FixedNumExpansions;
960 for (
auto &Pack : Packs) {
961 if (Info.PendingDeducedPacks.size() > Pack.Index)
962 Pack.Outer = Info.PendingDeducedPacks[Pack.Index];
964 Info.PendingDeducedPacks.resize(Pack.Index + 1);
965 Info.PendingDeducedPacks[Pack.Index] = &Pack;
967 if (PartialPackDepthIndex ==
968 std::make_pair(Info.getDeducedDepth(), Pack.Index)) {
969 Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs);
978 if (!IsPartiallyExpanded)
979 Deduced[Pack.Index] = Pack.New[PackElements];
985 ~PackDeductionScope() {
986 for (
auto &Pack : Packs)
987 Info.PendingDeducedPacks[Pack.Index] = Pack.Outer;
991 std::optional<unsigned> getSavedPackSizeIfAllEqual()
const {
992 unsigned PackSize = Packs[0].Saved.pack_size();
994 if (std::all_of(Packs.begin() + 1, Packs.end(), [&PackSize](
const auto &
P) {
995 return P.Saved.pack_size() == PackSize;
1003 bool isDeducedFromEarlierParameter()
const {
1004 return DeducedFromEarlierParameter;
1009 bool isPartiallyExpanded() {
return IsPartiallyExpanded; }
1014 bool hasFixedArity() {
return FixedNumExpansions.has_value(); }
1019 bool hasNextElement() {
1020 return !FixedNumExpansions || *FixedNumExpansions > PackElements;
1024 void nextPackElement() {
1028 for (
auto &Pack : Packs) {
1030 if (!Pack.New.empty() || !DeducedArg.
isNull()) {
1031 while (Pack.New.size() < PackElements)
1033 if (Pack.New.size() == PackElements)
1034 Pack.New.push_back(DeducedArg);
1036 Pack.New[PackElements] = DeducedArg;
1037 DeducedArg = Pack.New.size() > PackElements + 1
1038 ? Pack.New[PackElements + 1]
1051 for (
auto &Pack : Packs) {
1053 Deduced[Pack.Index] = Pack.Saved;
1068 Pack.New.resize(PackElements);
1072 if (Pack.New.empty()) {
1078 std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
1086 Pack.New[0].wasDeducedFromArrayBound());
1092 if (Pack.Outer->DeferredDeduction.isNull()) {
1095 Pack.Outer->DeferredDeduction = NewPack;
1098 Loc = &Pack.Outer->DeferredDeduction;
1100 Loc = &Deduced[Pack.Index];
1106 S.
Context, OldPack, NewPack, DeducePackIfNotAlreadyDeduced);
1108 Info.AggregateDeductionCandidateHasMismatchedArity =
1114 if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) {
1116 NewPack = Pack.DeferredDeduction;
1120 NamedDecl *Param = TemplateParams->getParam(Pack.Index);
1121 if (Result.isNull()) {
1123 Info.FirstArg = OldPack;
1124 Info.SecondArg = NewPack;
1125 return TemplateDeductionResult::Inconsistent;
1131 if (*Expansions != PackElements) {
1133 Info.FirstArg = Result;
1134 return TemplateDeductionResult::IncompletePack;
1141 return TemplateDeductionResult::Success;
1149 unsigned PackElements = 0;
1150 bool IsPartiallyExpanded =
false;
1151 bool DeducePackIfNotAlreadyDeduced =
false;
1152 bool DeducedFromEarlierParameter =
false;
1154 std::optional<unsigned> FixedNumExpansions;
1193 const QualType *Params,
unsigned NumParams,
1194 const QualType *Args,
unsigned NumArgs,
1207 = dyn_cast<PackExpansionType>(Params[
ParamIdx]);
1212 if (ArgIdx >= NumArgs)
1213 return TemplateDeductionResult::MiscellaneousDeductionFailure;
1215 if (isa<PackExpansionType>(Args[ArgIdx])) {
1220 return TemplateDeductionResult::MiscellaneousDeductionFailure;
1224 S, TemplateParams, Params[
ParamIdx].getUnqualifiedType(),
1225 Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
1228 Result != TemplateDeductionResult::Success)
1243 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
1247 if (
ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) {
1248 for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) {
1254 Result != TemplateDeductionResult::Success)
1257 PackScope.nextPackElement();
1278 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
1279 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs;
1281 PackScope.nextPackElement();
1287 if (
auto Result = PackScope.finish();
1288 Result != TemplateDeductionResult::Success)
1299 isa<PackExpansionType>(Args[ArgIdx]))
1300 return TemplateDeductionResult::Success;
1303 if (ArgIdx < NumArgs)
1304 return TemplateDeductionResult::MiscellaneousDeductionFailure;
1306 return TemplateDeductionResult::Success;
1318 if (ParamQs == ArgQs)
1362 if (!Guide || !Guide->isImplicit())
1364 return Guide->getDeducedTemplate()->getTemplateParameters()->size();
1374 if (ParamRef->getPointeeType().getQualifiers())
1377 return TypeParm && TypeParm->
getIndex() >= FirstInnerIndex;
1435 assert(
T->
isRecordType() &&
"Base class that isn't a record?");
1437 ToVisit.push_back(
T);
1446 while (!ToVisit.empty()) {
1447 QualType NextT = ToVisit.pop_back_val();
1453 S, TemplateParams,
P, NextT, BaseInfo, DeducedCopy);
1459 Matches.insert({RD, DeducedCopy});
1470 if (Matches.size() > 1) {
1472 for (
const auto &Match : Matches)
1473 AddBases(Match.first);
1477 while (Matches.size() > 1 && !ToVisit.empty()) {
1478 const CXXRecordDecl *RD = ToVisit.pop_back_val()->getAsCXXRecordDecl();
1487 if (Matches.empty())
1489 if (Matches.size() > 1)
1492 std::swap(Matches.front().second, Deduced);
1528 if (
const auto *AExp = dyn_cast<PackExpansionType>(A))
1529 A = AExp->getPattern();
1610 TDF &= ~TDF_TopLevelParameterTypeList;
1613 P =
P->getPointeeType();
1630 unsigned Index = TTP->getIndex();
1645 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1657 "saw template type parameter with wrong depth");
1659 "Unresolved overloaded function");
1679 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1699 Info.
Param = cast<TemplateTypeParmDecl>(TemplateParams->
getParam(Index));
1744 if (!
P->isDependentType()) {
1760 switch (
P.getCanonicalType()->getTypeClass()) {
1762#define NON_CANONICAL_TYPE(Class, Base) \
1763 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1764#define TYPE(Class, Base)
1765#include "clang/AST/TypeNodes.inc"
1767 case Type::TemplateTypeParm:
1768 case Type::SubstTemplateTypeParmPack:
1769 llvm_unreachable(
"Type nodes handled above");
1777 if (
P->isDependentType())
1781 case Type::VariableArray:
1783 case Type::FunctionNoProto:
1786 case Type::ObjCObject:
1787 case Type::ObjCInterface:
1788 case Type::ObjCObjectPointer:
1798 case Type::Complex: {
1803 S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
1808 case Type::Atomic: {
1813 S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
1818 case Type::Pointer: {
1829 PointeeType, Info, Deduced,
1834 case Type::LValueReference: {
1841 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1846 case Type::RValueReference: {
1853 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1858 case Type::IncompleteArray: {
1864 assert(IAP &&
"Template parameter not of incomplete array type");
1867 S, TemplateParams, IAP->getElementType(), IAA->getElementType(), Info,
1872 case Type::ConstantArray: {
1876 if (!CAA || CAA->getSize() != CAP->getSize())
1880 S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info,
1885 case Type::DependentSizedArray: {
1894 S, TemplateParams, DAP->getElementType(), AA->getElementType(),
1908 "saw non-type template parameter with wrong depth");
1909 if (
const auto *CAA = dyn_cast<ConstantArrayType>(AA)) {
1910 llvm::APSInt Size(CAA->getSize());
1913 true, Info, Deduced);
1915 if (
const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
1916 if (DAA->getSizeExpr())
1918 S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced);
1927 case Type::FunctionProto: {
1933 if (FPP->getMethodQuals() != FPA->getMethodQuals() ||
1934 FPP->getRefQualifier() != FPA->getRefQualifier() ||
1935 FPP->isVariadic() != FPA->isVariadic())
1940 S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
1949 S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(),
1950 FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced,
1961 Expr *NoexceptExpr = FPP->getNoexceptExpr();
1966 "saw non-type template parameter with wrong depth");
1968 llvm::APSInt Noexcept(1);
1969 switch (FPA->canThrow()) {
1979 true, Info, Deduced);
1982 if (
Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
1984 S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
1997 case Type::InjectedClassName:
2006 case Type::TemplateSpecialization: {
2032 Deduced = DeducedOrig;
2050 case Type::MemberPointer: {
2067 S, TemplateParams, PPT, APT, Info, Deduced, SubTDF);
2071 S, TemplateParams,
QualType(MPP->getClass(), 0),
2072 QualType(MPA->getClass(), 0), Info, Deduced, SubTDF);
2080 case Type::BlockPointer: {
2086 S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info,
2093 case Type::ExtVector: {
2098 if (VP->getNumElements() != VA->getNumElements())
2100 ElementType = VA->getElementType();
2105 ElementType = VA->getElementType();
2111 S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
2115 case Type::DependentVector: {
2121 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2122 Info, Deduced, TDF);
2133 ArgSize = VA->getNumElements();
2145 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2146 Info, Deduced, TDF);
2157 VA->getSizeExpr(), Info, Deduced);
2166 case Type::DependentSizedExtVector: {
2172 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2173 Info, Deduced, TDF);
2184 ArgSize = VA->getNumElements();
2196 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2197 Info, Deduced, TDF);
2208 VA->getSizeExpr(), Info, Deduced);
2218 case Type::ConstantMatrix: {
2225 if (MP->getNumRows() != MA->getNumRows() ||
2226 MP->getNumColumns() != MA->getNumColumns()) {
2231 S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
2235 case Type::DependentSizedMatrix: {
2244 Info, Deduced, TDF);
2249 auto DeduceMatrixArg =
2250 [&S, &Info, &Deduced, &TemplateParams](
2254 const auto *ACM = dyn_cast<ConstantMatrixType>(A);
2255 const auto *ADM = dyn_cast<DependentSizedMatrixType>(A);
2256 if (!ParamExpr->isValueDependent()) {
2257 std::optional<llvm::APSInt> ParamConst =
2258 ParamExpr->getIntegerConstantExpr(S.
Context);
2263 if ((ACM->*GetArgDimension)() == *ParamConst)
2268 Expr *ArgExpr = (ADM->*GetArgDimensionExpr)();
2269 if (std::optional<llvm::APSInt> ArgConst =
2271 if (*ArgConst == *ParamConst)
2282 llvm::APSInt ArgConst(
2284 ArgConst = (ACM->*GetArgDimension)();
2287 true, Info, Deduced);
2291 (ADM->*GetArgDimensionExpr)(),
2295 if (
auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
2301 return DeduceMatrixArg(MP->getColumnExpr(), MA,
2309 case Type::DependentAddressSpace: {
2315 S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(),
2316 Info, Deduced, TDF);
2327 S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced);
2337 S, TemplateParams, ASP->getPointeeType(),
2350 true, Info, Deduced);
2355 case Type::DependentBitInt: {
2359 if (IP->isUnsigned() != IA->isUnsigned())
2368 ArgSize = IA->getNumBits();
2376 if (IP->isUnsigned() != IA->isUnsigned())
2384 case Type::TypeOfExpr:
2386 case Type::DependentName:
2387 case Type::UnresolvedUsing:
2388 case Type::Decltype:
2389 case Type::UnaryTransform:
2390 case Type::DeducedTemplateSpecialization:
2391 case Type::DependentTemplateSpecialization:
2392 case Type::PackExpansion:
2394 case Type::ArrayParameter:
2398 case Type::PackIndexing: {
2408 llvm_unreachable(
"Invalid Type Class!");
2422 switch (
P.getKind()) {
2424 llvm_unreachable(
"Null template argument in parameter list");
2429 S, TemplateParams,
P.getAsType(), A.
getAsType(), Info, Deduced, 0);
2444 llvm_unreachable(
"caller should handle pack expansions");
2511 llvm_unreachable(
"Unknown template argument kind");
2517 llvm_unreachable(
"Argument packs should be expanded by the caller!");
2520 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2533 if (ArgIdx == Args.size())
2540 assert(ArgIdx == Args.size() - 1 &&
"Pack not at the end of argument list?");
2543 return ArgIdx < Args.size();
2549 bool FoundPackExpansion =
false;
2550 for (
const auto &A : Args) {
2551 if (FoundPackExpansion)
2559 if (A.isPackExpansion())
2560 FoundPackExpansion =
true;
2573 if (
PackFold == PackFold::ArgumentToParameter)
2589 if (!
P.isPackExpansion()) {
2594 return NumberOfArgumentsMustMatch
2601 if (As[ArgIdx].isPackExpansion())
2606 if (
PackFold == PackFold::ArgumentToParameter)
2628 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
2634 PackScope.hasNextElement();
2637 if (
PackFold == PackFold::ArgumentToParameter)
2645 PackScope.nextPackElement();
2650 if (
auto Result = PackScope.finish();
2662 bool NumberOfArgumentsMustMatch) {
2663 return ::DeduceTemplateArguments(*
this, TemplateParams, Ps, As, Info, Deduced,
2664 NumberOfArgumentsMustMatch);
2672 bool PackExpansionMatchesPack =
false) {
2675 if (PackExpansionMatchesPack &&
X.isPackExpansion() && !Y.
isPackExpansion())
2676 X =
X.getPackExpansionPattern();
2681 switch (
X.getKind()) {
2683 llvm_unreachable(
"Comparing NULL template argument");
2706 return X.structurallyEquals(Y);
2709 llvm::FoldingSetNodeID XID, YID;
2710 X.getAsExpr()->Profile(XID, Context,
true);
2716 unsigned PackIterationSize =
X.pack_size();
2725 bool XHasMoreArg =
X.pack_size() > Y.
pack_size();
2726 if (!(XHasMoreArg &&
X.pack_elements().back().isPackExpansion()) &&
2727 !(!XHasMoreArg && Y.
pack_elements().back().isPackExpansion()))
2736 for (
unsigned i = 0; i < PackIterationSize; ++i)
2738 PackExpansionMatchesPack))
2744 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2753 llvm_unreachable(
"Can't get a NULL template argument here");
2788 Builder.MakeTrivial(
Context, DTN->getQualifier(),
Loc);
2791 Builder.MakeTrivial(
Context, QTN->getQualifier(),
Loc);
2808 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2826 unsigned ArgumentPackIndex) {
2848 CanonicalPackedArgsBuilder;
2856 "deduced nested pack");
2863 diag::err_template_arg_deduced_incomplete_pack)
2867 if (ConvertArg(InnerArg, SugaredPackedArgsBuilder.size()))
2871 SugaredPackedArgsBuilder.push_back(SugaredOutput.pop_back_val());
2872 CanonicalPackedArgsBuilder.push_back(CanonicalOutput.pop_back_val());
2877 if (SugaredPackedArgsBuilder.empty()) {
2882 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2884 NTTP, SugaredOutput,
2887 S.
SubstType(NTTP->getType(), Args, NTTP->getLocation(),
2888 NTTP->getDeclName()).isNull())
2890 }
else if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) {
2901 SugaredOutput.push_back(
2904 S.
Context, CanonicalPackedArgsBuilder));
2908 return ConvertArg(Arg, 0);
2914template <
typename TemplateDeclT>
2916 Sema &S, TemplateDeclT *Template,
bool IsDeduced,
2922 unsigned NumAlreadyConverted = 0,
bool PartialOverloading =
false) {
2925 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
2934 PackDeductionScope(S, TemplateParams, Deduced, Info, I).finish();
2939 if (!Deduced[I].isNull()) {
2940 if (I < NumAlreadyConverted) {
2945 CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) {
2948 CurrentInstantiationScope->ResetPartiallySubstitutedPack();
2955 SugaredBuilder.push_back(Deduced[I]);
2956 CanonicalBuilder.push_back(
2965 IsDeduced, SugaredBuilder,
2966 CanonicalBuilder)) {
2979 bool HasDefaultArg =
false;
2982 assert(isa<ClassTemplatePartialSpecializationDecl>(Template) ||
2983 isa<VarTemplatePartialSpecializationDecl>(Template));
2992 if (Rec->isLambda())
2993 if (
auto *Method = dyn_cast<CXXMethodDecl>(Rec->getDeclContext())) {
2995 ThisTypeQuals = Method->getMethodQualifiers();
3003 SugaredBuilder, CanonicalBuilder, HasDefaultArg);
3012 if (PartialOverloading)
break;
3037 if (
auto *DC = dyn_cast<DeclContext>(
D))
3043 static constexpr bool value =
false;
3047 static constexpr bool value =
true;
3051 static constexpr bool value =
true;
3053template <
typename TemplateDeclT>
3068template <
typename TemplateDeclT>
3075 Template->getAssociatedConstraints(AssociatedConstraints);
3077 std::optional<ArrayRef<TemplateArgument>> Innermost;
3081 Innermost = CanonicalDeducedArgs;
3084 Template, Template->getDeclContext(),
false, Innermost,
3108template <
typename T>
3109static std::enable_if_t<IsPartialSpecialization<T>::value,
3112 Sema &S,
T *Partial,
bool IsPartialOrdering,
3128 S, Partial, IsPartialOrdering, Deduced, Info, SugaredBuilder,
3139 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
3147 auto *Template = Partial->getSpecializedTemplate();
3149 Partial->getTemplateArgsAsWritten();
3160 if (
ParamIdx >= Partial->getTemplateParameters()->size())
3161 ParamIdx = Partial->getTemplateParameters()->size() - 1;
3164 Partial->getTemplateParameters()->getParam(
ParamIdx));
3166 Info.
FirstArg = (*PartialTemplArgInfo)[ArgIdx].getArgument();
3172 CanonicalConvertedInstArgs;
3174 Template, Partial->getLocation(), InstArgs,
false,
3175 SugaredConvertedInstArgs, CanonicalConvertedInstArgs,
3182 for (
unsigned I = 0,
E = TemplateParams->
size(); I !=
E; ++I) {
3185 IsPartialOrdering)) {
3197 CanonicalBuilder, Info);
3225 SugaredBuilder, CanonicalBuilder,
3233 for (
unsigned I = 0,
E = TemplateParams->
size(); I !=
E; ++I) {
3248 CanonicalBuilder, Info);
3273 S, TD,
false, Deduced, Info, SugaredBuilder,
3282 CanonicalBuilder, Info);
3292template <
typename T>
3293static std::enable_if_t<IsPartialSpecialization<T>::value,
3298 if (Partial->isInvalidDecl())
3317 Deduced.resize(Partial->getTemplateParameters()->size());
3319 S, Partial->getTemplateParameters(),
3320 Partial->getTemplateArgs().asArray(), TemplateArgs, Info, Deduced,
3336 Result = ::FinishTemplateArgumentDeduction(S, Partial,
3338 TemplateArgs, Deduced, Info);
3347 return ::DeduceTemplateArguments(*
this, Partial, TemplateArgs, Info);
3353 return ::DeduceTemplateArguments(*
this, Partial, TemplateArgs, Info);
3363 if (
const auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
3366 }
else if (
const auto *
AliasTemplate = dyn_cast<TypeAliasTemplateDecl>(TD)) {
3367 PType =
AliasTemplate->getTemplatedDecl()->getUnderlyingType();
3369 assert(
false &&
"Expected a class or alias template");
3388 return DeducedResult;
3401 Result = ::FinishTemplateArgumentDeduction(*this, TD, Deduced, Info);
3410 return Spec->getTemplateName().getAsTemplateDecl() !=
nullptr;
3436 if (ExplicitTemplateArgs.
size() == 0) {
3440 ParamTypes.push_back(
P->getType());
3470 ExplicitTemplateArgs,
true, SugaredBuilder,
3474 unsigned Index = SugaredBuilder.size();
3475 if (Index >= TemplateParams->
size())
3488 CanonicalExplicitArgumentList);
3500 unsigned PartiallySubstitutedPackIndex = -1u;
3501 if (!SugaredBuilder.empty()) {
3504 auto *Param = TemplateParams->
getParam(SugaredBuilder.size() - 1);
3508 if (!Expansions || Arg.
pack_size() < *Expansions) {
3509 PartiallySubstitutedPackIndex = SugaredBuilder.size() - 1;
3518 assert(Proto &&
"Function template does not have a prototype?");
3526 SugaredExplicitArgumentList->
asArray(),
3536 nullptr, ExtParamInfos))
3553 ThisTypeQuals = Method->getMethodQualifiers();
3567 Diag(
Function->getLocation(), diag::err_kern_type_not_void_return)
3578 nullptr, ExtParamInfos))
3602 Deduced.reserve(TemplateParams->
size());
3603 for (
unsigned I = 0, N = SugaredExplicitArgumentList->
size(); I != N; ++I) {
3605 if (I == PartiallySubstitutedPackIndex)
3608 Deduced.push_back(Arg);
3677 if (AQuals == DeducedAQuals) {
3695 bool ObjCLifetimeConversion =
false;
3699 ObjCLifetimeConversion) ||
3745 if (PD->isParameterPack()) {
3746 unsigned NumExpansions =
3748 if (Idx + NumExpansions >
ParamIdx)
3750 Idx += NumExpansions;
3758 llvm_unreachable(
"parameter index would not be produced from template");
3770 return isa<CXXConstructorDecl>(
D)
3771 ? cast<CXXConstructorDecl>(
D)->getExplicitSpecifier()
3772 : cast<CXXConversionDecl>(
D)->getExplicitSpecifier();
3775 isa<CXXConstructorDecl>(
D)
3776 ? cast<CXXConstructorDecl>(
D)->setExplicitSpecifier(ES)
3777 : cast<CXXConversionDecl>(
D)->setExplicitSpecifier(ES);
3788 S, Info.
getLocation(), FunctionTemplate, DeducedArgs,
3809 bool PartialOverloading, llvm::function_ref<
bool()> CheckNonDependent) {
3833 NumExplicitlySpecified, PartialOverloading);
3846 if (CheckNonDependent())
3854 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
3892 CanonicalDeducedArgumentList &&
3912 if (!PartialOverloading ||
3913 (CanonicalBuilder.size() ==
3930 if (isa<CXXConstructorDecl, CXXConversionDecl>(
Specialization)) {
3939 if (OriginalCallArgs) {
3944 llvm::SmallDenseMap<std::pair<unsigned, QualType>,
QualType> DeducedATypes;
3945 for (
unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
3949 unsigned ExplicitOffset =
3969 if (CacheEntry.
isNull()) {
3978 DeducedA = CacheEntry;
3993 SuppressedDiagnosticsMap::iterator
4008 if (S.
getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
4013 if (Method->isImplicitObjectMemberFunction()) {
4034 bool ParamWasReference,
4043 if (ParamWasReference)
4060 nullptr, FailedTSC))
4101 if (ArgType.
isNull())
continue;
4121 Deduced(TemplateParams->
size());
4124 S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF);
4162 assert(Arg &&
"expected a non-null arg expression");
4164 ParamRefType !=
nullptr, FailedTSC);
4172 assert(Arg &&
"expected a non-null arg expression");
4227 (isa<PointerType>(ParamType) &&
4246 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF,
4271 ElTy = ArrTy->getElementType();
4281 if (isa<DesignatedInitExpr>(
E))
4288 S, TemplateParams, 0, ElTy,
E->
getType(),
4290 OriginalCallArgs,
true, ArgIdx, TDF);
4298 if (
auto *DependentArrTy = dyn_cast_or_null<DependentSizedArrayType>(ArrTy)) {
4309 S, TemplateParams, NTTP, llvm::APSInt(Size),
T,
4310 true, Info, Deduced);
4328 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF,
4331 QualType OrigParamType = ParamType;
4336 S, TemplateParams, FirstInnerIndex, ParamType, ArgType,
4337 ArgClassification, Arg, TDF, FailedTSC))
4341 if (
InitListExpr *ILE = dyn_cast_if_present<InitListExpr>(Arg))
4343 Deduced, OriginalCallArgs, ArgIdx, TDF);
4351 OriginalCallArgs.push_back(
4354 ArgType, Info, Deduced, TDF);
4361 bool PartialOverloading,
bool AggregateDeductionCandidate,
4368 unsigned NumParams =
Function->getNumParams();
4369 bool HasExplicitObject =
false;
4370 int ExplicitObjectOffset = 0;
4371 if (
Function->hasCXXExplicitFunctionObjectParameter()) {
4372 HasExplicitObject =
true;
4373 ExplicitObjectOffset = 1;
4382 if (Args.size() <
Function->getMinRequiredExplicitArguments() &&
4383 !PartialOverloading)
4386 PartialOverloading)) {
4388 if (Proto->isTemplateVariadic())
4390 else if (!Proto->isVariadic())
4401 unsigned NumExplicitlySpecified = 0;
4402 if (ExplicitTemplateArgs) {
4405 Result = SubstituteExplicitTemplateArguments(
4406 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, nullptr,
4412 NumExplicitlySpecified = Deduced.size();
4415 for (
unsigned I = 0; I != NumParams; ++I)
4416 ParamTypes.push_back(
Function->getParamDecl(I)->getType());
4422 auto DeduceCallArgument = [&](
QualType ParamType,
unsigned ArgIdx,
4423 bool ExplicitObjectArgument) {
4431 if (ExplicitObjectArgument) {
4434 *
this, TemplateParams, FirstInnerIndex, ParamType, ObjectType,
4435 ObjectClassification,
4436 nullptr, Info, Deduced, OriginalCallArgs,
4442 *
this, TemplateParams, FirstInnerIndex, ParamType,
4443 Args[ArgIdx]->getType(), Args[ArgIdx]->Classify(
getASTContext()),
4444 Args[ArgIdx], Info, Deduced, OriginalCallArgs,
false,
4449 Deduced.resize(TemplateParams->
size());
4451 for (
unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0;
4456 dyn_cast<PackExpansionType>(ParamType);
4457 if (!ParamExpansion) {
4459 if (ArgIdx >= Args.size() && !(HasExplicitObject &&
ParamIdx == 0))
4462 ParamTypesForArgChecking.push_back(ParamType);
4464 if (
ParamIdx == 0 && HasExplicitObject) {
4468 if (
auto Result = DeduceCallArgument(ParamType, 0,
4475 if (
auto Result = DeduceCallArgument(ParamType, ArgIdx++,
4483 bool IsTrailingPack =
ParamIdx + 1 == NumParamTypes;
4486 PackDeductionScope PackScope(*
this, TemplateParams, Deduced, Info,
4488 AggregateDeductionCandidate && IsTrailingPack);
4506 if (IsTrailingPack || PackScope.hasFixedArity()) {
4507 for (; ArgIdx < Args.size() && PackScope.hasNextElement();
4508 PackScope.nextPackElement(), ++ArgIdx) {
4509 ParamTypesForArgChecking.push_back(ParamPattern);
4510 if (
auto Result = DeduceCallArgument(ParamPattern, ArgIdx,
4519 std::optional<unsigned> NumExpansions =
4521 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
4522 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
4524 ParamTypesForArgChecking.push_back(ParamPattern);
4527 PackScope.nextPackElement();
4529 }
else if (!IsTrailingPack && !PackScope.isPartiallyExpanded() &&
4530 PackScope.isDeducedFromEarlierParameter()) {
4543 std::optional<unsigned> ArgPosAfterSubstitution =
4544 PackScope.getSavedPackSizeIfAllEqual();
4545 if (!ArgPosAfterSubstitution)
4548 unsigned PackArgEnd = ArgIdx + *ArgPosAfterSubstitution;
4549 for (; ArgIdx < PackArgEnd && ArgIdx < Args.size(); ArgIdx++) {
4550 ParamTypesForArgChecking.push_back(ParamPattern);
4552 DeduceCallArgument(ParamPattern, ArgIdx,
4557 PackScope.nextPackElement();
4564 if (
auto Result = PackScope.finish();
4575 Result = FinishTemplateArgumentDeduction(
4576 FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
4577 &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() {
4578 ContextRAII SavedContext(*this, CallingCtx);
4579 return CheckNonDependent(ParamTypesForArgChecking);
4587 bool AdjustExceptionSpec) {
4588 if (ArgFunctionType.
isNull())
4589 return ArgFunctionType;
4594 bool Rebuild =
false;
4597 if (EPI.ExtInfo.getCC() != CC) {
4598 EPI.
ExtInfo = EPI.ExtInfo.withCallingConv(CC);
4602 bool NoReturn = FunctionTypeP->getNoReturnAttr();
4603 if (EPI.ExtInfo.getNoReturn() != NoReturn) {
4604 EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn);
4608 if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() ||
4610 EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec;
4615 return ArgFunctionType;
4625 bool IsAddressOfFunction) {
4637 unsigned NumExplicitlySpecified = 0;
4639 if (ExplicitTemplateArgs) {
4642 Result = SubstituteExplicitTemplateArguments(
4643 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes,
4644 &FunctionType, Info);
4649 NumExplicitlySpecified = Deduced.size();
4655 if (!IsAddressOfFunction)
4664 Deduced.resize(TemplateParams->
size());
4668 bool HasDeducedReturnType =
false;
4670 Function->getReturnType()->getContainedAutoType()) {
4672 HasDeducedReturnType =
true;
4680 *
this, TemplateParams,
FunctionType, ArgFunctionType, Info, Deduced,
4688 Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
4689 NumExplicitlySpecified,
4690 Specialization, Info);
4697 if (HasDeducedReturnType && IsAddressOfFunction &&
4718 if (!IsAddressOfFunction) {
4724 if (HasDeducedReturnType) {
4733 if (!ArgFunctionType.
isNull()) {
4735 SpecializationType, ArgFunctionType)
4737 SpecializationType, ArgFunctionType)) {
4758 bool IsReferenceP =
P->isReferenceType();
4765 P = PRef->getPointeeType();
4775 if (!IsReferenceP) {
4777 P =
P.getUnqualifiedType();
4784 assert(!A->
isReferenceType() &&
"Reference types were handled above");
4789 if (
P->isArrayType())
4794 else if (
P->isFunctionType())
4799 P =
P.getUnqualifiedType();
4821 Deduced.resize(TemplateParams->
size());
4850 ParamType, ObjectType, ObjectClassification,
4851 nullptr, Info, Deduced, OriginalCallArgs,
4858 *
this, TemplateParams,
P, A, Info, Deduced, TDF);
4868 Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
4869 ConversionSpecialized, Info,
4872 Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
4881 bool IsAddressOfFunction) {
4884 IsAddressOfFunction);
4888 struct DependentAuto {
bool IsPack; };
4892 class SubstituteDeducedTypeTransform :
4895 bool ReplacementIsPack;
4900 SubstituteDeducedTypeTransform(
Sema &SemaRef, DependentAuto DA)
4902 ReplacementIsPack(DA.IsPack), UseTypeSugar(
true) {}
4904 SubstituteDeducedTypeTransform(
Sema &SemaRef,
QualType Replacement,
4905 bool UseTypeSugar =
true)
4907 Replacement(Replacement), ReplacementIsPack(
false),
4908 UseTypeSugar(UseTypeSugar) {}
4911 assert(isa<TemplateTypeParmType>(Replacement) &&
4912 "unexpected unsugared replacement kind");
4930 return TransformDesugared(TLB, TL);
4932 QualType Result = SemaRef.Context.getAutoType(
4941 QualType TransformDeducedTemplateSpecializationType(
4944 return TransformDesugared(TLB, TL);
4946 QualType Result = SemaRef.Context.getDeducedTemplateSpecializationType(
4948 Replacement, Replacement.isNull());
4966 return inherited::TransformExceptionSpec(
Loc, ESI, Exceptions, Changed);
4974 return TransformType(TLB, TL);
4990 Deduced,
TypeLoc.getNameLoc())));
4991 for (
unsigned I = 0,
C =
TypeLoc.getNumArgs(); I !=
C; ++I)
4997 SugaredConverted, CanonicalConverted))
5013 S.
getASTContext(), Concept->getDeclContext(), Concept->getLocation(),
5014 CanonicalConverted));
5021 llvm::raw_string_ostream OS(Buf);
5022 OS <<
"'" << Concept->getName();
5023 if (
TypeLoc.hasExplicitTemplateArgs()) {
5026 Type.getTypeConstraintConcept()->getTemplateParameters());
5031 diag::err_placeholder_constraints_not_satisfied)
5042 bool IgnoreConstraints,
5045 if (
Init->containsErrors())
5058 DependentAuto DependentResult = {
5061 if (!DependentDeduction &&
5063 Init->containsUnexpandedParameterPack())) {
5064 Result = SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
5065 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
5070 auto *String = dyn_cast<StringLiteral>(
Init);
5072 Diag(
Type.getBeginLoc(), diag::ext_c23_auto_non_plain_identifier);
5074 Result = SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(TL);
5075 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
5081 Diag(
Type.getBeginLoc(), diag::ext_c23_auto_non_plain_identifier);
5084 auto *InitList = dyn_cast<InitListExpr>(
Init);
5086 Diag(
Init->getBeginLoc(), diag::err_auto_init_list_from_c)
5098 if (
Init->isTypeDependent()) {
5100 SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
5101 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
5113 Diag(
Init->getBeginLoc(), diag::err_decltype_auto_initializer_list);
5126 nullptr,
false,
false,
false);
5140 for (
Expr *
Init : InitList->inits()) {
5143 if (isa<DesignatedInitExpr>(
Init))
5146 *
this, TemplateParamsSt.get(), 0, TemplArg,
Init->getType(),
5148 OriginalCallArgs,
true,
5154 <<
Init->getSourceRange();
5157 return DeductionFailed(TDK);
5162 DeducedFromInitRange =
Init->getSourceRange();
5166 Diag(
Loc, diag::err_auto_bitfield);
5170 SubstituteDeducedTypeTransform(*
this, TemplArg).Apply(
Type);
5171 assert(!FuncParam.
isNull() &&
5172 "substituting template parameter for 'auto' failed");
5174 *
this, TemplateParamsSt.get(), 0, FuncParam,
Init->getType(),
5176 OriginalCallArgs,
false, 0, 0,
5179 return DeductionFailed(TDK);
5216 assert((
bool)InitList == OriginalArg.DecomposedParam &&
5217 "decomposed non-init-list in auto deduction?");
5222 return DeductionFailed(TDK);
5232 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
5233 .TransformType(TypeWithAuto);
5239 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
5240 .TransformType(TypeWithAuto);
5244 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
5245 .TransformType(TypeWithAuto);
5250 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
5251 .TransformType(TypeWithAuto);
5256 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
5258 .TransformType(TypeWithAuto);
5263 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
5265 .TransformType(TypeWithAuto);
5270 if (isa<InitListExpr>(
Init))
5273 ? diag::err_init_capture_deduction_failure_from_init_list
5274 : diag::err_auto_var_deduction_failure_from_init_list)
5278 VDecl->
isInitCapture() ? diag::err_init_capture_deduction_failure
5279 : diag::err_auto_var_deduction_failure)
5281 <<
Init->getSourceRange();
5313 "failed to deduce lambda return type");
5340 Diag(
Loc, diag::err_auto_fn_used_before_defined) << FD;
5344 return StillUndeduced;
5388 "expected a member function with no explicit object parameter");
5413 assert(Proto1 && Proto2 &&
"Function templates must have prototypes");
5416 Deduced.resize(TemplateParams->
size());
5425 Args1.data(), Args1.size(), Info, Deduced,
5436 S, TemplateParams, Proto2->getReturnType(), Proto1->
getReturnType(),
5446 S, TemplateParams, FD2->
getType(), FD1->
getType(), Info, Deduced,
5459 unsigned ArgIdx = 0, NumArgs = Deduced.size();
5460 for (; ArgIdx != NumArgs; ++ArgIdx)
5461 if (Deduced[ArgIdx].isNull())
5468 if (ArgIdx == NumArgs) {
5475 llvm::SmallBitVector UsedParameters(TemplateParams->
size());
5478 for (
unsigned I = 0, N = Args2.size(); I != N; ++I)
5480 TemplateParams->
getDepth(), UsedParameters);
5486 TemplateParams->
getDepth(), UsedParameters);
5512 false, TemplateParams->
getDepth(), UsedParameters);
5516 for (; ArgIdx != NumArgs; ++ArgIdx)
5519 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
5533 bool ShouldConvert1 =
false;
5534 bool ShouldConvert2 =
false;
5545 const CXXMethodDecl *Method1 = dyn_cast<CXXMethodDecl>(FD1);
5546 const CXXMethodDecl *Method2 = dyn_cast<CXXMethodDecl>(FD2);
5556 ShouldConvert1 = Method1 && !Method1->isExplicitObjectMemberFunction();
5558 if (ShouldConvert1) {
5562 : Proto2->param_type_begin()[0]->isRValueReferenceType();
5566 Args1.push_back(Obj1Ty);
5568 if (ShouldConvert2) {
5571 ? Method1->getRefQualifier() ==
RQ_RValue
5576 Args2.push_back(Obj2Ty);
5578 size_t NumComparedArguments = NumCallArguments1;
5582 ++NumComparedArguments;
5586 Args2.insert(Args2.end(), Proto2->param_type_begin(),
5587 Proto2->param_type_end());
5592 Args1.resize(std::min(Args1.size(), NumComparedArguments));
5593 Args2.resize(std::min(Args2.size(), NumComparedArguments));
5596 std::reverse(Args2.begin(), Args2.end());
5605 if (Better1 != Better2)
5606 return Better1 ? FT1 : FT2;
5608 if (!Better1 && !Better2)
5617 Param1.reserve(FD1->
param_size() + ShouldConvert1);
5619 Param1.push_back(Obj1Ty);
5621 Param1.push_back(
P->getType());
5624 Param2.reserve(FD2->
param_size() + ShouldConvert2);
5626 Param2.push_back(Obj2Ty);
5628 Param2.push_back(
P->getType());
5630 unsigned NumParams1 = Param1.size();
5631 unsigned NumParams2 = Param2.size();
5637 if (Variadic1 != Variadic2) {
5638 if (Variadic1 && NumParams1 > NumParams2)
5640 if (Variadic2 && NumParams2 > NumParams1)
5646 for (
int i = 0, e = std::min(NumParams1, NumParams2); i < e; ++i) {
5647 QualType T1 = Param1[i].getCanonicalType();
5648 QualType T2 = Param2[i].getCanonicalType();
5649 auto *TST1 = dyn_cast<TemplateSpecializationType>(T1);
5650 auto *TST2 = dyn_cast<TemplateSpecializationType>(T2);
5655 assert(TST1->template_arguments().size() ==
5656 TST2->template_arguments().size());
5661 bool IsPackExpansion1 =
5663 bool IsPackExpansion2 =
5665 if (PackSize1 != PackSize2 && IsPackExpansion1 != IsPackExpansion2) {
5666 if (PackSize1 > PackSize2 && IsPackExpansion1)
5668 if (PackSize1 < PackSize2 && IsPackExpansion2)
5690 if (TPL1->
size() != TPL2->
size() || NumParams1 != NumParams2)
5706 for (
unsigned i = 0; i < NumParams1; ++i)
5722 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
5727 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
5729 return AtLeastAsConstrained1 ? FT1 : FT2;
5737 bool Complain,
QualType TargetType) {
5738 if (SpecBegin == SpecEnd) {
5746 if (SpecBegin + 1 == SpecEnd)
5753 = cast<FunctionDecl>(*Best)->getPrimaryTemplate();
5754 assert(BestTemplate &&
"Not a function template specialization?");
5757 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
5758 assert(Challenger &&
"Not a function template specialization?");
5763 BestTemplate = Challenger;
5769 bool Ambiguous =
false;
5772 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
5794 const auto *FD = cast<FunctionDecl>(*I);
5796 FD->getPrimaryTemplate()->getTemplateParameters(),
5797 *FD->getTemplateSpecializationArgs());
5798 if (!TargetType.
isNull())
5800 Diag((*I)->getLocation(), PD);
5810 "not for function templates");
5812 isa<CXXConversionDecl>(FD1));
5814 isa<CXXConversionDecl>(FD2));
5827 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
5832 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
5834 return AtLeastAsConstrained1 ? FD1 : FD2;
5844template<
typename TemplateLikeDecl>
5846 TemplateLikeDecl *P2,
5875 Deduced.resize(P2->getTemplateParameters()->size());
5877 S, P2->getTemplateParameters(), T2, T1, Info, Deduced,
TDF_None,
5888 const auto *TST1 = cast<TemplateSpecializationType>(T1);
5889 bool AtLeastAsSpecialized;
5891 AtLeastAsSpecialized =
5892 FinishTemplateArgumentDeduction(
5893 S, P2, true, TST1->template_arguments(),
5894 Deduced, Info) == TemplateDeductionResult::Success;
5896 return AtLeastAsSpecialized;
5903 template <
typename T1,
typename T2,
5904 std::enable_if_t<std::is_same_v<T1, T2>,
bool> =
true>
5905 T2 *operator()(T1 *, T2 *P2) {
5908 template <
typename T1,
typename T2,
5909 std::enable_if_t<!std::is_same_v<T1, T2>,
bool> =
true>
5910 T1 *operator()(T1 *, T2 *) {
5916struct TemplateArgumentListAreEqual {
5918 TemplateArgumentListAreEqual(
ASTContext &Ctx) : Ctx(Ctx) {}
5920 template <
typename T1,
typename T2,
5921 std::enable_if_t<std::is_same_v<T1, T2>,
bool> =
true>
5922 bool operator()(T1 *PS1, T2 *PS2) {
5924 Args2 = PS2->getTemplateArgs().asArray();
5926 for (
unsigned I = 0,
E = Args1.size(); I <
E; ++I) {
5930 llvm::FoldingSetNodeID IDA, IDB;
5931 Args1[I].Profile(IDA, Ctx);
5932 Args2[I].Profile(IDB, Ctx);
5939 template <
typename T1,
typename T2,
5940 std::enable_if_t<!std::is_same_v<T1, T2>,
bool> =
true>
5941 bool operator()(T1 *Spec, T2 *Primary) {
5943 Args2 = Primary->getInjectedTemplateArgs();
5945 for (
unsigned I = 0,
E = Args1.size(); I <
E; ++I) {
5949 llvm::FoldingSetNodeID IDA, IDB;
5950 Args1[I].Profile(IDA, Ctx);
5984template <
typename TemplateLikeDecl,
typename PrimaryDel>
5985static TemplateLikeDecl *
5988 constexpr bool IsMoreSpecialThanPrimaryCheck =
5989 !std::is_same_v<TemplateLikeDecl, PrimaryDel>;
5992 if (IsMoreSpecialThanPrimaryCheck && !Better1)
5996 if (IsMoreSpecialThanPrimaryCheck && !Better2)
6002 if (Better1 != Better2)
6003 return Better1 ? P1 : GetP2()(P1, P2);
6005 if (!Better1 && !Better2)
6010 auto *TST1 = cast<TemplateSpecializationType>(T1);
6011 auto *TST2 = cast<TemplateSpecializationType>(T2);
6014 assert(TST1->template_arguments().size() ==
6015 TST2->template_arguments().size());
6020 bool IsPackExpansion1 =
6022 bool IsPackExpansion2 =
6024 if (PackSize1 != PackSize2 && IsPackExpansion1 != IsPackExpansion2) {
6025 if (PackSize1 > PackSize2 && IsPackExpansion1)
6026 return GetP2()(P1, P2);
6027 if (PackSize1 < PackSize2 && IsPackExpansion2)
6056 if (!TemplateArgumentListAreEqual(S.
getASTContext())(P1, P2))
6060 P1->getAssociatedConstraints(AC1);
6061 P2->getAssociatedConstraints(AC2);
6062 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
6064 (IsMoreSpecialThanPrimaryCheck && !AtLeastAsConstrained1))
6068 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
6070 return AtLeastAsConstrained1 ? P1 : GetP2()(P1, P2);
6105 "the partial specializations being compared should specialize"
6106 " the same template.");
6166 for (
unsigned I = 0, N =
P->size(); I != N; ++I) {
6175 Arg,
QualType(),
P->getParam(I)->getLocation()));
6194 Deduced.resize(A->
size());
6209 IsDeduced ? PackFold::ArgumentToParameter
6210 : PackFold::ParameterToArgument) !=
6220 bool AtLeastAsSpecialized;
6222 AtLeastAsSpecialized =
6223 ::FinishTemplateArgumentDeduction(
6224 *this, AArg, true, PArgs, Deduced, Info) ==
6225 TemplateDeductionResult::Success;
6227 return AtLeastAsSpecialized;
6231struct MarkUsedTemplateParameterVisitor :
6233 llvm::SmallBitVector &
Used;
6236 MarkUsedTemplateParameterVisitor(llvm::SmallBitVector &
Used,
6241 if (
T->getDepth() == Depth)
6242 Used[
T->getIndex()] =
true;
6247 if (
auto *TTP = llvm::dyn_cast_or_null<TemplateTemplateParmDecl>(
6249 if (TTP->getDepth() == Depth)
6250 Used[TTP->getIndex()] =
true;
6257 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
E->getDecl()))
6258 if (NTTP->getDepth() == Depth)
6259 Used[NTTP->getIndex()] =
true;
6272 llvm::SmallBitVector &
Used) {
6274 MarkUsedTemplateParameterVisitor(
Used, Depth)
6275 .TraverseStmt(
const_cast<Expr *
>(
E));
6281 E = Expansion->getPattern();
6303 llvm::SmallBitVector &
Used) {
6310 OnlyDeduced, Depth,
Used);
6320 llvm::SmallBitVector &
Used) {
6321 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
6323 = dyn_cast<TemplateTemplateParmDecl>(Template)) {
6324 if (TTP->getDepth() == Depth)
6325 Used[TTP->getIndex()] =
true;
6344 llvm::SmallBitVector &
Used) {
6362 case Type::BlockPointer:
6370 case Type::LValueReference:
6371 case Type::RValueReference:
6379 case Type::MemberPointer: {
6384 OnlyDeduced, Depth,
Used);
6388 case Type::DependentSizedArray:
6390 cast<DependentSizedArrayType>(
T)->getSizeExpr(),
6391 OnlyDeduced, Depth,
Used);
6395 case Type::ConstantArray:
6396 case Type::IncompleteArray:
6397 case Type::ArrayParameter:
6399 cast<ArrayType>(
T)->getElementType(),
6400 OnlyDeduced, Depth,
Used);
6403 case Type::ExtVector:
6405 cast<VectorType>(
T)->getElementType(),
6406 OnlyDeduced, Depth,
Used);
6409 case Type::DependentVector: {
6410 const auto *VecType = cast<DependentVectorType>(
T);
6417 case Type::DependentSizedExtVector: {
6419 = cast<DependentSizedExtVectorType>(
T);
6427 case Type::DependentAddressSpace: {
6429 cast<DependentAddressSpaceType>(
T);
6431 OnlyDeduced, Depth,
Used);
6434 OnlyDeduced, Depth,
Used);
6438 case Type::ConstantMatrix: {
6445 case Type::DependentSizedMatrix: {
6456 case Type::FunctionProto: {
6460 for (
unsigned I = 0, N = Proto->
getNumParams(); I != N; ++I) {
6465 if (!OnlyDeduced || I + 1 == N ||
6483 case Type::TemplateTypeParm: {
6490 case Type::SubstTemplateTypeParmPack: {
6492 = cast<SubstTemplateTypeParmPackType>(
T);
6496 OnlyDeduced, Depth,
Used);
6500 case Type::InjectedClassName:
6501 T = cast<InjectedClassNameType>(
T)->getInjectedSpecializationType();
6504 case Type::TemplateSpecialization: {
6506 = cast<TemplateSpecializationType>(
T);
6526 cast<ComplexType>(
T)->getElementType(),
6527 OnlyDeduced, Depth,
Used);
6533 cast<AtomicType>(
T)->getValueType(),
6534 OnlyDeduced, Depth,
Used);
6537 case Type::DependentName:
6540 cast<DependentNameType>(
T)->getQualifier(),
6541 OnlyDeduced, Depth,
Used);
6544 case Type::DependentTemplateSpecialization: {
6558 = cast<DependentTemplateSpecializationType>(
T);
6561 OnlyDeduced, Depth,
Used);
6571 OnlyDeduced, Depth,
Used);
6574 case Type::TypeOfExpr:
6577 cast<TypeOfExprType>(
T)->getUnderlyingExpr(),
6578 OnlyDeduced, Depth,
Used);
6581 case Type::Decltype:
6584 cast<DecltypeType>(
T)->getUnderlyingExpr(),
6585 OnlyDeduced, Depth,
Used);
6588 case Type::PackIndexing:
6591 OnlyDeduced, Depth,
Used);
6593 OnlyDeduced, Depth,
Used);
6597 case Type::UnaryTransform:
6601 OnlyDeduced, Depth,
Used);
6604 case Type::PackExpansion:
6606 cast<PackExpansionType>(
T)->getPattern(),
6607 OnlyDeduced, Depth,
Used);
6611 case Type::DeducedTemplateSpecialization:
6613 cast<DeducedType>(
T)->getDeducedType(),
6614 OnlyDeduced, Depth,
Used);
6616 case Type::DependentBitInt:
6618 cast<DependentBitIntType>(
T)->getNumBitsExpr(),
6619 OnlyDeduced, Depth,
Used);
6624 case Type::VariableArray:
6625 case Type::FunctionNoProto:
6628 case Type::ObjCInterface:
6629 case Type::ObjCObject:
6630 case Type::ObjCObjectPointer:
6631 case Type::UnresolvedUsing:
6634#define TYPE(Class, Base)
6635#define ABSTRACT_TYPE(Class, Base)
6636#define DEPENDENT_TYPE(Class, Base)
6637#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
6638#include "clang/AST/TypeNodes.inc"
6650 llvm::SmallBitVector &
Used) {
6668 OnlyDeduced, Depth,
Used);
6686 llvm::SmallBitVector &
Used) {
6692 bool OnlyDeduced,
unsigned Depth,
6693 llvm::SmallBitVector &
Used) {
6702 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
6709 llvm::SmallBitVector &Deduced) {
6713 Deduced.resize(TemplateParams->
size());
6716 for (
unsigned I = 0, N =
Function->getNumParams(); I != N; ++I)
6718 true, TemplateParams->
getDepth(), Deduced);
6729 llvm::SmallBitVector Deduced(TemplateParams->
size());
6733 return Deduced.any();
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Provides definitions for the various language-specific address spaces.
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::Expr interface and subclasses for C++ expressions.
llvm::DenseSet< const void * > Visited
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static QualType getUnderlyingType(const SubRegion *R)
static bool isSameTemplateArg(ASTContext &Context, TemplateArgument X, const TemplateArgument &Y, bool PartialOrdering, bool PackExpansionMatchesPack=false)
Determine whether two template arguments are the same.
static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc, const FunctionTemplateDecl *FT1, const FunctionTemplateDecl *FT2, TemplatePartialOrderingContext TPOC, bool Reversed, const SmallVector< QualType > &Args1, const SmallVector< QualType > &Args2)
Determine whether the function template FT1 is at least as specialized as FT2.
static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y)
Compare two APSInts, extending and switching the sign as necessary to compare their values regardless...
static TemplateLikeDecl * getMoreSpecialized(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P1, PrimaryDel *P2, TemplateDeductionInfo &Info)
Returns the more specialized template specialization between T1/P1 and T2/P2.
static DeducedTemplateArgument checkDeducedTemplateArguments(ASTContext &Context, const DeducedTemplateArgument &X, const DeducedTemplateArgument &Y, bool AggregateCandidateDeduction=false)
Verify that the given, deduced template arguments are compatible.
static bool isSameDeclaration(Decl *X, Decl *Y)
Determine whether two declaration pointers refer to the same declaration.
static bool hasTemplateArgumentForDeduction(ArrayRef< TemplateArgument > &Args, unsigned &ArgIdx)
Determine whether there is a template argument to be used for deduction.
static DeclContext * getAsDeclContextOrEnclosing(Decl *D)
static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, QualType ArgType)
Determine whether the parameter has qualifiers that the argument lacks.
static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)
Mark the template parameters that are used by this template argument.
static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R, FunctionDecl *Fn)
Gets the type of a function for template-argument-deducton purposes when it's considered as part of a...
static TemplateDeductionResult CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template, ArrayRef< TemplateArgument > SugaredDeducedArgs, ArrayRef< TemplateArgument > CanonicalDeducedArgs, TemplateDeductionInfo &Info)
static TemplateDeductionResult DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD, TemplateParameterList *TemplateParams, QualType P, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
Attempt to deduce the template arguments by checking the base types according to (C++20 [temp....
static const NonTypeTemplateParmDecl * getDeducedParameterFromExpr(const Expr *E, unsigned Depth)
If the given expression is of a form that permits the deduction of a non-type template parameter,...
static TemplateDeductionResult DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams, const QualType P, QualType A, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
static bool hasPackExpansionBeforeEnd(ArrayRef< TemplateArgument > Args)
Determine whether the given set of template arguments has a pack expansion that is not the last templ...
static bool isSimpleTemplateIdType(QualType T)
Determine whether the given type T is a simple-template-id type.
static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, DeducedTemplateArgument Arg, NamedDecl *Template, TemplateDeductionInfo &Info, bool IsDeduced, SmallVectorImpl< TemplateArgument > &SugaredOutput, SmallVectorImpl< TemplateArgument > &CanonicalOutput)
Convert the given deduced template argument and add it to the set of fully-converted template argumen...
static TemplateParameter makeTemplateParameter(Decl *D)
Helper function to build a TemplateParameter when we don't know its type statically.
static TemplateDeductionResult CheckOriginalCallArgDeduction(Sema &S, TemplateDeductionInfo &Info, Sema::OriginalCallArg OriginalArg, QualType DeducedA)
Check whether the deduced argument type for a call to a function template matches the actual argument...
static TemplateDeductionResult DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams, const NonTypeTemplateParmDecl *NTTP, QualType NullPtrType, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
Deduce the value of the given non-type template parameter from the given null pointer template argume...
static unsigned getPackIndexForParam(Sema &S, FunctionTemplateDecl *FunctionTemplate, const MultiLevelTemplateArgumentList &Args, unsigned ParamIdx)
Find the pack index for a particular parameter index in an instantiation of a function template with ...
static TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, ArrayRef< TemplateArgument > Ps, ArrayRef< TemplateArgument > As, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, bool NumberOfArgumentsMustMatch, PackFold PackFold=PackFold::ParameterToArgument)
static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex, QualType &ParamType, QualType &ArgType, Expr::Classification ArgClassification, Expr *Arg, unsigned &TDF, TemplateSpecCandidateSet *FailedTSC=nullptr)
Perform the adjustments to the parameter and argument types described in C++ [temp....
static TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument(Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex, QualType ParamType, QualType ArgType, Expr::Classification ArgClassification, Expr *Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, SmallVectorImpl< Sema::OriginalCallArg > &OriginalCallArgs, bool DecomposedParam, unsigned ArgIdx, unsigned TDF, TemplateSpecCandidateSet *FailedTSC=nullptr)
Perform template argument deduction per [temp.deduct.call] for a single parameter / argument pair.
static QualType GetImplicitObjectParameterType(ASTContext &Context, const CXXMethodDecl *Method, QualType RawType, bool IsOtherRvr)
static TemplateDeductionResult DeduceFromInitializerList(Sema &S, TemplateParameterList *TemplateParams, QualType AdjustedParamType, InitListExpr *ILE, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, SmallVectorImpl< Sema::OriginalCallArg > &OriginalCallArgs, unsigned ArgIdx, unsigned TDF)
Attempt template argument deduction from an initializer list deemed to be an argument in a function c...
static unsigned getFirstInnerIndex(FunctionTemplateDecl *FTD)
Get the index of the first template parameter that was originally from the innermost template-paramet...
static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, unsigned TDF, bool PartialOrdering=false, bool DeducedFromArrayBound=false)
Deduce the template arguments by comparing the parameter type and the argument type (C++ [temp....
static TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams, const NonTypeTemplateParmDecl *NTTP, const DeducedTemplateArgument &NewDeduced, QualType ValueType, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
Deduce the value of the given non-type template parameter as the given deduced template argument.
static TemplateDeductionResult ConvertDeducedTemplateArguments(Sema &S, TemplateDeclT *Template, bool IsDeduced, SmallVectorImpl< DeducedTemplateArgument > &Deduced, TemplateDeductionInfo &Info, SmallVectorImpl< TemplateArgument > &SugaredBuilder, SmallVectorImpl< TemplateArgument > &CanonicalBuilder, LocalInstantiationScope *CurrentInstantiationScope=nullptr, unsigned NumAlreadyConverted=0, bool PartialOverloading=false)
static bool DeducedArgsNeedReplacement(TemplateDeclT *Template)
static QualType ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, Expr *Arg, QualType ParamType, bool ParamWasReference, TemplateSpecCandidateSet *FailedTSC=nullptr)
Apply the deduction rules for overload sets.
static bool IsPossiblyOpaquelyQualifiedType(QualType T)
Determines whether the given type is an opaque type that might be more qualified when instantiated.
static const TemplateSpecializationType * getLastTemplateSpecType(QualType QT)
Deduce the template arguments by comparing the template parameter type (which is a template-id) with ...
static std::enable_if_t< IsPartialSpecialization< T >::value, TemplateDeductionResult > FinishTemplateArgumentDeduction(Sema &S, T *Partial, bool IsPartialOrdering, ArrayRef< TemplateArgument > TemplateArgs, SmallVectorImpl< DeducedTemplateArgument > &Deduced, TemplateDeductionInfo &Info)
Complete template argument deduction for a partial specialization.
static TemplateDeductionResult instantiateExplicitSpecifierDeferred(Sema &S, FunctionDecl *Specialization, const MultiLevelTemplateArgumentList &SubstArgs, TemplateDeductionInfo &Info, FunctionTemplateDecl *FunctionTemplate, ArrayRef< TemplateArgument > DeducedArgs)
static bool CheckDeducedPlaceholderConstraints(Sema &S, const AutoType &Type, AutoTypeLoc TypeLoc, QualType Deduced)
static bool IsPossiblyOpaquelyQualifiedTypeInternal(const Type *T)
static bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T)
static NamedDecl * getTemplateParameterWithDefault(Sema &S, NamedDecl *A, TemplateArgument Default)
Create a shallow copy of a given template parameter declaration, with empty source locations and usin...
static bool isForwardingReference(QualType Param, unsigned FirstInnerIndex)
Determine whether a type denotes a forwarding reference.
bool DeducedArgsNeedReplacement< VarTemplatePartialSpecializationDecl >(VarTemplatePartialSpecializationDecl *Spec)
bool DeducedArgsNeedReplacement< ClassTemplatePartialSpecializationDecl >(ClassTemplatePartialSpecializationDecl *Spec)
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
unsigned getIntWidth(QualType T) const
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
TemplateName getCanonicalTemplateName(const TemplateName &Name) const
Retrieves the "canonical" template name that refers to a given template.
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
void getInjectedTemplateArgs(const TemplateParameterList *Params, SmallVectorImpl< TemplateArgument > &Args)
Get a template argument list with one argument per template parameter in a template parameter list,...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
const LangOptions & getLangOpts() const
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl)
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y) const
Determine whether the given template names refer to the same template.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
LangAS getDefaultOpenCLPointeeAddrSpace()
Returns default address space based on OpenCL version and enabled features.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CanQualType UnsignedIntTy
QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false)
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
const DependentSizedArrayType * getAsDependentSizedArrayType(QualType T) const
The result of parsing/analyzing an expression, statement etc.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
bool isDecltypeAuto() const
ConceptDecl * getTypeConstraintConcept() const
AutoTypeKeyword getKeyword() const
bool isConstrained() const
A fixed int type of a specified bitwidth.
Represents a C++ conversion function within a class.
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a static or instance method of a struct/union/class.
bool isExplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An explicit object member function is a non-static member function with an explic...
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
Qualifiers getMethodQualifiers() const
The null pointer literal (C++11 [lex.nullptr])
Represents a C++ struct/union/class.
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Declaration of a class template.
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
QualType getInjectedSpecializationType() const
Retrieves the injected specialization type for this partial specialization.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isClassScopeExplicitSpecialization() const
Is this an explicit specialization at class scope (within the class that owns the primary template)?...
Complex values, per C99 6.2.5p11.
Declaration of a C++20 concept.
const TypeClass * getTypePtr() const
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumColumns() const
Returns the number of columns in the matrix.
unsigned getNumRows() const
Returns the number of rows in the matrix.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
A POD class for pairing a NamedDecl* with an access specifier.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration.
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
bool isParameterPack() const
Whether this declaration is a parameter pack.
@ FOK_None
Not a friend object.
bool isInvalidDecl() const
SourceLocation getLocation() const
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Captures a template argument whose value has been deduced via c++ template argument deduction.
void setDeducedFromArrayBound(bool Deduced)
Specify whether the given non-type template argument was deduced from an array bound.
bool wasDeducedFromArrayBound() const
For a non-type template argument, determine whether the template argument was deduced from an array b...
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Represents an extended address space qualifier where the input address space value is dependent.
Expr * getAddrSpaceExpr() const
QualType getPointeeType() const
Represents an extended vector type where either the type or size is dependent.
Expr * getSizeExpr() const
QualType getElementType() const
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Expr * getColumnExpr() const
Expr * getRowExpr() const
Represents a dependent template name that cannot be resolved prior to template instantiation.
Represents a template specialization type whose template cannot be resolved, e.g.
ArrayRef< TemplateArgument > template_arguments() const
NestedNameSpecifier * getQualifier() const
Represents a vector type where either the type or size is dependent.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
RAII object that enters a new expression evaluation context.
Store information needed for an explicit specifier.
bool isInvalid() const
Determine if the explicit specifier is invalid.
const Expr * getExpr() const
The return type of classify().
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
ExtVectorType - Extended vector type.
Stores a list of template parameters and the associated requires-clause (if any) for a TemplateDecl a...
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
bool isImmediateEscalating() const
void getAssociatedConstraints(SmallVectorImpl< const Expr * > &AC) const
Get the associated-constraints of this function declaration.
size_t param_size() const
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Represents a prototype with parameter type info, e.g.
param_type_iterator param_type_begin() const
const ExtParameterInfo * getExtParameterInfosOrNull() const
Return a pointer to the beginning of the array of extra parameter information, if present,...
unsigned getNumParams() const
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
QualType getParamType(unsigned i) const
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
ExtProtoInfo getExtProtoInfo() const
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
param_type_iterator param_type_end() const
ArrayRef< QualType > getParamTypes() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getReturnType() const
static ImplicitConceptSpecializationDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation SL, ArrayRef< TemplateArgument > ConvertedArgs)
const TypeClass * getTypePtr() const
Describes an C or C++ initializer list.
unsigned getNumInits() const
ArrayRef< Expr * > inits()
The injected class name of a C++ class template or class template partial specialization.
An lvalue reference type, per C++11 [dcl.ref].
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
A stack-allocated class that identifies which local variable declaration instantiations are present i...
void SetPartiallySubstitutedPack(NamedDecl *Pack, const TemplateArgument *ExplicitArgs, unsigned NumExplicitArgs)
Note that the given parameter pack has been partially substituted via explicit specification of templ...
Represents a matrix type, as defined in the Matrix Types clang extensions.
QualType getElementType() const
Returns type of the elements being stored in the matrix.
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
const Type * getClass() const
Data structure that captures multiple levels of template argument lists for use in template instantia...
void replaceInnermostTemplateArguments(Decl *AssociatedDecl, ArgList Args)
Replaces the current 'innermost' level with the provided argument list.
This represents a decl that may have a name.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Class that aids in the construction of nested-name-specifiers along with source-location information ...
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
unsigned getDepth() const
Get the nesting depth of the template parameter.
Represents a pointer to an Objective C object.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
SourceLocation getNameLoc() const
Gets the location of the name.
decls_iterator decls_begin() const
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments into the given structure.
decls_iterator decls_end() const
Represents a C++11 pack expansion that produces a sequence of expressions.
Represents a pack expansion of types.
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
std::optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
bool hasSelectedType() const
QualType getSelectedType() const
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
A (possibly-)qualified type.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Represents a template name as written in source code.
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
void removeCVRQualifiers(unsigned mask)
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
void removeObjCLifetime()
bool isStrictSupersetOf(Qualifiers Other) const
Determine whether this set of qualifiers is a strict superset of another set of qualifiers,...
bool hasNonTrivialObjCLifetime() const
True if the lifetime is neither None or ExplicitNone.
bool hasAddressSpace() const
void removeAddressSpace()
bool hasObjCGCAttr() const
void setCVRQualifiers(unsigned mask)
bool hasObjCLifetime() const
ObjCLifetime getObjCLifetime() const
Qualifiers withoutObjCLifetime() const
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
LangAS getAddressSpace() const
void setObjCLifetime(ObjCLifetime type)
An rvalue reference type, per C++11 [dcl.ref].
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
bool TraverseTemplateName(TemplateName Template)
Recursively visit a template name and dispatch to the appropriate method.
ArrayRef< TemplateArgument > getInjectedTemplateArgs()
Retrieve the "injected" template arguments that correspond to the template parameters of this templat...
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
Scope - A scope is a transient data structure that is used while parsing the program.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
RAII object used to change the argument pack substitution index within a Sema object.
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
A helper class for building up ExtParameterInfos.
const FunctionProtoType::ExtParameterInfo * getPointerOrNull(unsigned numParams)
Return a pointer (suitable for setting in an ExtProtoInfo) to the ExtParameterInfo array we've built ...
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Sema - This implements semantic analysis and AST building for C.
bool CheckInstantiatedFunctionTemplateConstraints(SourceLocation PointOfInstantiation, FunctionDecl *Decl, ArrayRef< TemplateArgument > TemplateArgs, ConstraintSatisfaction &Satisfaction)
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
TemplateDeductionResult DeduceTemplateArgumentsFromType(TemplateDecl *TD, QualType FromType, sema::TemplateDeductionInfo &Info)
Deduce the template arguments of the given template from FromType.
QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement)
Completely replace the auto in TypeWithAuto by Replacement.
bool TemplateParameterListsAreEqual(const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New, const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, Decl *Param, ArrayRef< TemplateArgument > SugaredConverted, ArrayRef< TemplateArgument > CanonicalConverted, bool &HasDefaultArg)
If the given template parameter has a default template argument, substitute into that default templat...
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
FunctionDecl * getMoreConstrainedFunction(FunctionDecl *FD1, FunctionDecl *FD2)
Returns the more constrained function according to the rules of partial ordering by constraints (C++ ...
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc, CodeSynthesisContext::SynthesisKind CSC=CodeSynthesisContext::ExplicitTemplateArgumentSubstitution)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
QualType BuildStdInitializerList(QualType Element, SourceLocation Loc)
Looks for the std::initializer_list template and instantiates it with Element, or emits an error if i...
ExpressionEvaluationContextRecord & parentEvaluationContext()
@ CTAK_DeducedFromArrayBound
The template argument was deduced from an array bound via template argument deduction.
@ CTAK_Specified
The template argument was specified in the code or was instantiated with some deduced template argume...
@ CTAK_Deduced
The template argument was deduced via template argument deduction.
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
ExprResult BuildExpressionFromNonTypeTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
ASTContext & getASTContext() const
UnresolvedSetIterator getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain=true, QualType TargetType=QualType())
Retrieve the most specialized of the given function template specializations.
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)
Perform substitution on the type T with a given set of template arguments.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr, TemplateSpecCandidateSet *FailedTSC=nullptr)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc, bool IsDeduced)
@ TPL_TemplateParamsEquivalent
We are determining whether the template-parameters are equivalent according to C++ [temp....
bool isSameOrCompatibleFunctionType(QualType Param, QualType Arg)
Compare types for equality with respect to possibly compatible function types (noreturn adjustment,...
const LangOptions & getLangOpts() const
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr, bool PartialOrderingTTP=false)
Check that the given template arguments can be provided to the given template, converting the argumen...
FunctionTemplateDecl * getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, QualType RawObj1Ty={}, QualType RawObj2Ty={}, bool Reversed=false)
Returns the more specialized function template according to the rules of function template partial or...
std::optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
ExplicitSpecifier instantiateExplicitSpecifier(const MultiLevelTemplateArgumentList &TemplateArgs, ExplicitSpecifier ES)
TemplateDeductionResult SubstituteExplicitTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo &ExplicitTemplateArgs, SmallVectorImpl< DeducedTemplateArgument > &Deduced, SmallVectorImpl< QualType > &ParamTypes, QualType *FunctionType, sema::TemplateDeductionInfo &Info)
Substitute the explicitly-provided template arguments into the given function template according to C...
bool SubstParmTypes(SourceLocation Loc, ArrayRef< ParmVarDecl * > Params, const FunctionProtoType::ExtParameterInfo *ExtParamInfos, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< QualType > &ParamTypes, SmallVectorImpl< ParmVarDecl * > *OutParams, ExtParameterInfoBuilder &ParamInfos)
Substitute the given template arguments into the given set of parameters, producing the set of parame...
FunctionDecl * resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult)
Given an expression that refers to an overloaded function, try to resolve that function to a single f...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
SuppressedDiagnosticsMap SuppressedDiagnostics
QualType getDecltypeForExpr(Expr *E)
getDecltypeForExpr - Given an expr, will return the decltype for that expression, according to the ru...
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
TypeSourceInfo * SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto)
bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef< const Expr * > AC1, NamedDecl *D2, MutableArrayRef< const Expr * > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
TypeSourceInfo * ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType Replacement)
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL,...
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)
Mark which template parameters are used in a given expression.
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
QualType getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType, CallingConv CC)
Get the return type to use for a lambda's conversion function(s) to function pointer type,...
QualType getCompletedType(Expr *E)
Get the type of expression E, triggering instantiation to complete the type if necessary – that is,...
TypeSourceInfo * SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
void DiagnoseAutoDeductionFailure(const VarDecl *VDecl, const Expr *Init)
TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param, SourceLocation Location)
Get a template argument mapping the given template parameter to itself, e.g.
bool CheckIfFunctionSpecializationIsImmediate(FunctionDecl *FD, SourceLocation Loc)
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
TemplateDeductionResult FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl< DeducedTemplateArgument > &Deduced, unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info, SmallVectorImpl< OriginalCallArg > const *OriginalCallArgs=nullptr, bool PartialOverloading=false, llvm::function_ref< bool()> CheckNonDependent=[] { return false;})
Finish template argument deduction for a function template, checking the deduced template arguments f...
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T, sema::TemplateDeductionInfo &Info)
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
void adjustMemberFunctionCC(QualType &T, bool HasThisPointer, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly.
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
void MarkDeducedTemplateParameters(const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced)
Encodes a location in the source.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
Represents the result of substituting a set of types for a template type parameter pack.
TemplateArgument getArgumentPack() const
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
const TemplateTypeParmDecl * getReplacedParameter() const
Gets the template parameter declaration that was substituted for.
A convenient class for passing around template argument information.
void addArgument(const TemplateArgumentLoc &Loc)
A template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Location wrapper for a TemplateArgument.
const TemplateArgument & getArgument() const
Represents a template argument.
QualType getParamTypeForDecl() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const
Used to insert TemplateArguments into FoldingSets.
QualType getAsType() const
Retrieve the type for a type template argument.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool isNull() const
Determine whether this template argument has no value.
static TemplateArgument getEmptyPack()
unsigned pack_size() const
The number of template arguments in the given template argument pack.
bool structurallyEquals(const TemplateArgument &Other) const
Determines whether two template arguments are superficially the same.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
The base class of all kinds of template declarations (e.g., class, function, etc.).
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const
Get the total constraint-expression associated with this template, including constraint-expressions d...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
void * getAsVoidPointer() const
Retrieve the template name as a void pointer.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
Represents a type template specialization; the template must be a class template, a type alias templa...
ArrayRef< TemplateArgument > template_arguments() const
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)
Declaration of a template type parameter.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
unsigned getDepth() const
Retrieve the depth of the template parameter.
Wrapper for template type parameters.
unsigned getIndex() const
unsigned getDepth() const
const Type * getTypeForDecl() const
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
Base wrapper for a particular "section" of type source info.
SourceRange getLocalSourceRange() const
Get the local source range.
unsigned getFullDataSize() const
Returns the size of the type source info data block.
void copy(TypeLoc other)
Copies the other type loc into this one.
A container of type source information.
SourceLocation getNameLoc() const
void setNameLoc(SourceLocation Loc)
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isIncompleteArrayType() const
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isRValueReferenceType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool isFunctionPointerType() const
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isLValueReferenceType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
QualType getCanonicalTypeInternal() const
bool isMemberPointerType() const
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isMemberFunctionPointerType() const
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
The iterator over UnresolvedSets.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Declaration of a variable template.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
bool isClassScopeExplicitSpecialization() const
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Represents a GCC generic vector type.
Provides information about an attempted template argument deduction, whose success or failure was des...
void setExplicitArgs(TemplateArgumentList *NewDeducedSugared, TemplateArgumentList *NewDeducedCanonical)
Provide an initial template argument list that contains the explicitly-specified arguments.
TemplateArgumentList * takeCanonical()
TemplateArgumentList * takeSugared()
Take ownership of the deduced template argument lists.
SourceLocation getLocation() const
Returns the location at which template argument is occurring.
void clearSFINAEDiagnostic()
Discard any SFINAE diagnostics.
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
diag_iterator diag_end() const
Returns an iterator at the end of the sequence of suppressed diagnostics.
void reset(TemplateArgumentList *NewDeducedSugared, TemplateArgumentList *NewDeducedCanonical)
Provide a new template argument list that contains the results of template argument deduction.
unsigned getDeducedDepth() const
The depth of template parameters for which deduction is being performed.
diag_iterator diag_begin() const
Returns an iterator at the beginning of the sequence of suppressed diagnostics.
TemplateArgument FirstArg
The first template argument to which the template argument deduction failure refers.
ConstraintSatisfaction AssociatedConstraintsSatisfaction
The constraint satisfaction details resulting from the associated constraints satisfaction tests.
unsigned CallArgIndex
The index of the function argument that caused a deduction failure.
The JSON file list parser is used to communicate input to InstallAPI.
bool isTargetAddressSpace(LangAS AS)
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
@ RQ_None
No ref-qualifier was provided.
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
unsigned toTargetAddressSpace(LangAS AS)
@ Result
The result type of a method or function.
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a template parameter.
std::optional< unsigned > getExpandedPackSize(const NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
bool isLambdaConversionOperator(CXXConversionDecl *C)
const FunctionProtoType * T
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
TPOC
The context in which partial ordering of function templates occurs.
@ TPOC_Conversion
Partial ordering of function templates for a call to a conversion function.
@ TPOC_Other
Partial ordering of function templates in other contexts, e.g., taking the address of a function temp...
@ TPOC_Call
Partial ordering of function templates for a function call.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
TemplateDeductionResult
Describes the result of template argument deduction.
@ MiscellaneousDeductionFailure
Deduction failed; that's all we know.
@ NonDependentConversionFailure
Checking non-dependent argument conversions failed.
@ ConstraintsNotSatisfied
The deduced arguments did not satisfy the constraints associated with the template.
@ Underqualified
Template argument deduction failed due to inconsistent cv-qualifiers on a template parameter type tha...
@ InstantiationDepth
Template argument deduction exceeded the maximum template instantiation depth (which has already been...
@ InvalidExplicitArguments
The explicitly-specified template arguments were not valid template arguments for the given template.
@ TooFewArguments
When performing template argument deduction for a function template, there were too few call argument...
@ Incomplete
Template argument deduction did not deduce a value for every template parameter.
@ Invalid
The declaration was invalid; do nothing.
@ Success
Template argument deduction was successful.
@ SubstitutionFailure
Substitution of the deduced template argument values resulted in an error.
@ IncompletePack
Template argument deduction did not deduce a value for every expansion of an expanded template parame...
@ DeducedMismatch
After substituting deduced template arguments, a dependent parameter type did not match the correspon...
@ Inconsistent
Template argument deduction produced inconsistent deduced values for the given template parameter.
@ TooManyArguments
When performing template argument deduction for a function template, there were too many call argumen...
@ AlreadyDiagnosed
Some error which was already diagnosed.
@ DeducedMismatchNested
After substituting deduced template arguments, an element of a dependent parameter type did not match...
@ NonDeducedMismatch
A non-depnedent component of the parameter did not match the corresponding component of the argument.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ EST_Uninstantiated
not instantiated yet
@ EST_None
no exception specification
TemplateDeductionFlags
Various flags that control template argument deduction.
@ TDF_None
No template argument deduction flags, which indicates the strictest results for template argument ded...
@ TDF_DerivedClass
Within template argument deduction from a function call, we are matching in a case where we can perfo...
@ TDF_TopLevelParameterTypeList
Whether we are performing template argument deduction for parameters and arguments in a top-level tem...
@ TDF_IgnoreQualifiers
Within template argument deduction from a function call, we are matching in a case where we ignore cv...
@ TDF_ParamWithReferenceType
Within template argument deduction from a function call, we are matching with a parameter type for wh...
@ TDF_SkipNonDependent
Allow non-dependent types to differ, e.g., when performing template argument deduction from a functio...
@ TDF_AllowCompatibleFunctionType
Within template argument deduction from overload resolution per C++ [over.over] allow matching functi...
@ TDF_ArgWithReferenceType
Within template argument deduction for a conversion function, we are matching with an argument type f...
ActionResult< CXXBaseSpecifier * > BaseResult
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
A pack that we're currently deducing.
DeducedPack(unsigned Index)
SmallVector< DeducedTemplateArgument, 4 > New
DeducedTemplateArgument Saved
DeducedTemplateArgument DeferredDeduction
Holds information about the various types of exception specification.
ExceptionSpecificationType Type
The kind of exception specification this is.
Extra information about a function prototype.
const ExtParameterInfo * ExtParameterInfos
FunctionType::ExtInfo ExtInfo
bool HasFormOfMemberPointer
OverloadExpr * Expression
@ ExplicitTemplateArgumentSubstitution
We are substituting explicit template arguments provided for a function template.
@ DeducedTemplateArgumentSubstitution
We are substituting template argument determined as part of template argument deduction for either a ...
A stack object to be created when performing template instantiation.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
brief A function argument from which we performed template argument
QualType OriginalParamType
Location information for a TemplateArgument.