46#include "llvm/ADT/APInt.h"
47#include "llvm/ADT/APSInt.h"
48#include "llvm/ADT/ArrayRef.h"
49#include "llvm/ADT/DenseMap.h"
50#include "llvm/ADT/FoldingSet.h"
51#include "llvm/ADT/SmallBitVector.h"
52#include "llvm/ADT/SmallPtrSet.h"
53#include "llvm/ADT/SmallVector.h"
54#include "llvm/Support/Casting.h"
55#include "llvm/Support/Compiler.h"
56#include "llvm/Support/ErrorHandling.h"
57#include "llvm/Support/SaveAndRestore.h"
115using namespace clang;
127 bool *HasDeducedAnyParam);
143 bool OnlyDeduced,
unsigned Depth,
144 llvm::SmallBitVector &
Used);
147 bool OnlyDeduced,
unsigned Level,
148 llvm::SmallBitVector &Deduced);
154 if (
const auto *IC = dyn_cast<ImplicitCastExpr>(E))
155 E = IC->getSubExpr();
156 else if (
const auto *CE = dyn_cast<ConstantExpr>(E))
157 E = CE->getSubExpr();
158 else if (
const auto *Subst = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
159 E = Subst->getReplacement();
160 else if (
const auto *CCE = dyn_cast<CXXConstructExpr>(E)) {
162 if (CCE->getParenOrBraceRange().isValid())
165 assert(CCE->getNumArgs() >= 1 &&
"implicit construct expr should have 1 arg");
186 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
187 return NTTP->getType();
194 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
195 return NTTP->getDepth();
200 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
201 return NTTP->getIndex();
214 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
220 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
221 return NTTP->isExpandedParameterPack();
226 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
227 return NTTP->getLocation();
231 operator bool()
const {
return Template; }
245 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
246 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
247 if (NTTP->getDepth() == Depth)
250 if (
const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E);
251 ULE && (ULE->isConceptReference() || ULE->isVarDeclReference())) {
252 if (
auto *TTP = ULE->getTemplateTemplateDecl()) {
254 if (TTP->getDepth() == Depth)
270 X = NX->getUnderlyingDecl();
271 if (
NamedDecl *NY = dyn_cast<NamedDecl>(Y))
272 Y = NY->getUnderlyingDecl();
285 bool AggregateCandidateDeduction =
false) {
298 QualType XType =
X.getNonTypeTemplateArgumentType();
301 if (YType.
isNull() || !Context.hasSameType(XType, YType))
306 switch (
X.getKind()) {
308 llvm_unreachable(
"Non-deduced template arguments handled above");
315 X.wasDeducedFromArrayBound() ||
321 return X.wasDeducedFromArrayBound() ? Y :
X;
335 return X.wasDeducedFromArrayBound() ? Y :
X;
344 X.structurallyEquals(Y)))
352 Context.hasSameTemplateName(
X.getAsTemplate(), Y.
getAsTemplate()))
360 Context.hasSameTemplateName(
X.getAsTemplateOrTemplatePattern(),
372 llvm::FoldingSetNodeID ID1, ID2;
373 X.getAsExpr()->Profile(ID1, Context,
true);
376 return X.wasDeducedFromArrayBound() ? Y :
X;
383 assert(!
X.wasDeducedFromArrayBound());
396 X.getParamTypeForDecl());
433 (!AggregateCandidateDeduction &&
X.pack_size() != Y.
pack_size()))
445 if (Merged.isNull() && !(XA->isNull() && YA->isNull()))
447 NewPack.push_back(Merged);
450 NewPack.push_back(*XA);
460 llvm_unreachable(
"Invalid TemplateArgument Kind!");
473 bool *HasDeducedAnyParam) {
475 "deducing non-type template argument with wrong depth");
479 if (Result.isNull()) {
499 if (
auto *Expansion = dyn_cast<PackExpansionType>(ParamType))
500 ParamType = Expansion->getPattern();
514 S, TemplateParams, ParamType, ValueType, Info, Deduced,
528 bool *HasDeducedAnyParam) {
530 S, TemplateParams, NTTP,
532 DeducedFromArrayBound),
544 bool *HasDeducedAnyParam) {
566 bool *HasDeducedAnyParam) {
582 bool *HasDeducedAnyParam) {
594 bool *HasDeducedAnyParam) {
602 if (
auto *TempParam = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
609 unsigned StartPos = 0;
626 Arg, {StartPos, DefaultArguments.drop_front(StartPos)}))
630 S.
Context, Deduced[TempParam->getIndex()], NewDeduced);
631 if (Result.isNull()) {
632 Info.
Param = TempParam;
633 Info.
FirstArg = Deduced[TempParam->getIndex()];
638 Deduced[TempParam->getIndex()] = Result;
639 if (HasDeducedAnyParam)
640 *HasDeducedAnyParam =
true;
675 const TemplateSpecializationType *LastTST =
nullptr;
677 const TemplateSpecializationType *TST =
678 T->getAs<TemplateSpecializationType>();
681 if (!TST->isSugared())
684 T = TST->desugar().getTypePtr();
693 bool *HasDeducedAnyParam) {
698 TNP = TP->getTemplateName();
707 TP->castAsCanonical<TemplateSpecializationType>()->template_arguments();
709 const auto *TT = P->
castAs<InjectedClassNameType>();
710 TNP = TT->getTemplateName(S.
Context);
711 PResolved = TT->getTemplateArgs(S.
Context);
733 SA->getCanonicalTypeInternal()
734 ->castAs<TemplateSpecializationType>()
735 ->template_arguments();
749 S, TemplateParams, PResolved, AResolved, Info, Deduced,
757 const auto *TA = A->
getAs<TagType>();
763 TNA = TST->getTemplateName();
765 TNA = TA->getTemplateName(S.
Context);
784 S, TemplateParams, PResolved, AResolved, Info, Deduced,
790 assert(
T->isCanonicalUnqualified());
792 switch (
T->getTypeClass()) {
793 case Type::TypeOfExpr:
795 case Type::DependentName:
797 case Type::PackIndexing:
798 case Type::UnresolvedUsing:
799 case Type::TemplateTypeParm:
803 case Type::ConstantArray:
804 case Type::IncompleteArray:
805 case Type::VariableArray:
806 case Type::DependentSizedArray:
819 T->getCanonicalTypeInternal().getTypePtr());
857class PackDeductionScope {
865 bool DeducePackIfNotAlreadyDeduced =
false,
866 bool FinishingDeduction =
false)
867 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info),
868 DeducePackIfNotAlreadyDeduced(DeducePackIfNotAlreadyDeduced),
869 FinishingDeduction(FinishingDeduction) {
870 unsigned NumNamedPacks = addPacks(Pattern);
871 finishConstruction(NumNamedPacks);
875 PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams,
876 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
877 TemplateDeductionInfo &Info,
unsigned Index)
878 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
880 finishConstruction(1);
884 void addPack(
unsigned Index) {
887 DeducedFromEarlierParameter = !Deduced[Index].isNull();
888 DeducedPack Pack(Index);
889 if (!FinishingDeduction) {
890 Pack.Saved = Deduced[Index];
891 Deduced[Index] = TemplateArgument();
897 if (UnsignedOrNone ExpandedPackExpansions =
899 FixedNumExpansions = ExpandedPackExpansions;
901 Packs.push_back(Pack);
904 unsigned addPacks(TemplateArgument Pattern) {
907 llvm::SmallBitVector SawIndices(TemplateParams->size());
908 llvm::SmallVector<TemplateArgument, 4> ExtraDeductions;
910 auto AddPack = [&](
unsigned Index) {
911 if (SawIndices[Index])
913 SawIndices[Index] =
true;
920 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
921 TemplateParams->getParam(Index))) {
922 if (!NTTP->isExpandedParameterPack())
925 if (
auto *Expansion = dyn_cast<PackExpansionType>(
926 S.Context.getUnconstrainedType(NTTP->getType())))
927 ExtraDeductions.push_back(Expansion->getPattern());
933 auto Collect = [&](TemplateArgument Pattern) {
934 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
935 S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
936 for (
unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
937 unsigned Depth, Index;
939 std::tie(Depth, Index) = *DI;
943 if (Depth == Info.getDeducedDepth())
951 unsigned NumNamedPacks = Packs.size();
955 while (!ExtraDeductions.empty())
956 Collect(ExtraDeductions.pop_back_val());
958 return NumNamedPacks;
961 void finishConstruction(
unsigned NumNamedPacks) {
963 const TemplateArgument *PartialPackArgs =
nullptr;
964 unsigned NumPartialPackArgs = 0;
965 std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u);
966 if (
auto *Scope = S.CurrentInstantiationScope)
967 if (
auto *Partial = Scope->getPartiallySubstitutedPack(
968 &PartialPackArgs, &NumPartialPackArgs))
974 bool IsExpanded =
true;
975 for (
unsigned I = 0; I != NumNamedPacks; ++I) {
976 if (Packs[I].Index >= Info.getNumExplicitArgs()) {
978 IsPartiallyExpanded =
false;
981 if (PartialPackDepthIndex ==
982 std::make_pair(Info.getDeducedDepth(), Packs[I].Index)) {
983 IsPartiallyExpanded =
true;
991 if (IsPartiallyExpanded)
992 PackElements += NumPartialPackArgs;
993 else if (IsExpanded && FixedNumExpansions)
994 PackElements += *FixedNumExpansions;
996 for (
auto &Pack : Packs) {
997 if (Info.PendingDeducedPacks.size() > Pack.Index)
998 Pack.Outer = Info.PendingDeducedPacks[Pack.Index];
1000 Info.PendingDeducedPacks.resize(Pack.Index + 1);
1001 Info.PendingDeducedPacks[Pack.Index] = &Pack;
1003 if (PartialPackDepthIndex ==
1004 std::make_pair(Info.getDeducedDepth(), Pack.Index)) {
1005 Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs);
1014 if (!FinishingDeduction && !IsPartiallyExpanded)
1015 Deduced[Pack.Index] = Pack.New[PackElements];
1021 ~PackDeductionScope() {
1022 for (
auto &Pack : Packs)
1023 Info.PendingDeducedPacks[Pack.Index] = Pack.Outer;
1027 UnsignedOrNone getSavedPackSizeIfAllEqual()
const {
1028 unsigned PackSize = Packs[0].Saved.pack_size();
1030 if (std::all_of(Packs.begin() + 1, Packs.end(), [&PackSize](
const auto &P) {
1031 return P.Saved.pack_size() == PackSize;
1034 return std::nullopt;
1039 bool isDeducedFromEarlierParameter()
const {
1040 return DeducedFromEarlierParameter;
1045 bool isPartiallyExpanded() {
return IsPartiallyExpanded; }
1050 bool hasFixedArity() {
return static_cast<bool>(FixedNumExpansions); }
1055 bool hasNextElement() {
1056 return !FixedNumExpansions || *FixedNumExpansions > PackElements;
1060 void nextPackElement() {
1064 if (!FinishingDeduction) {
1065 for (
auto &Pack : Packs) {
1066 DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index];
1067 if (!Pack.New.empty() || !DeducedArg.
isNull()) {
1068 while (Pack.New.size() < PackElements)
1069 Pack.New.push_back(DeducedTemplateArgument());
1070 if (Pack.New.size() == PackElements)
1071 Pack.New.push_back(DeducedArg);
1073 Pack.New[PackElements] = DeducedArg;
1074 DeducedArg = Pack.New.size() > PackElements + 1
1075 ? Pack.New[PackElements + 1]
1076 : DeducedTemplateArgument();
1087 if (FinishingDeduction)
1088 return TemplateDeductionResult::Success;
1091 for (
auto &Pack : Packs) {
1093 if (!FinishingDeduction)
1094 Deduced[Pack.Index] = Pack.Saved;
1109 Pack.New.resize(PackElements);
1112 DeducedTemplateArgument NewPack;
1113 if (Pack.New.empty()) {
1117 TemplateArgument *ArgumentPack =
1118 new (S.Context) TemplateArgument[Pack.New.size()];
1119 std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
1120 NewPack = DeducedTemplateArgument(
1121 TemplateArgument(llvm::ArrayRef(ArgumentPack, Pack.New.size())),
1127 Pack.New[0].wasDeducedFromArrayBound());
1131 DeducedTemplateArgument *Loc;
1133 if (Pack.Outer->DeferredDeduction.isNull()) {
1136 Pack.Outer->DeferredDeduction = NewPack;
1139 Loc = &Pack.Outer->DeferredDeduction;
1141 Loc = &Deduced[Pack.Index];
1145 DeducedTemplateArgument OldPack = *Loc;
1147 S.Context, OldPack, NewPack, DeducePackIfNotAlreadyDeduced);
1149 Info.AggregateDeductionCandidateHasMismatchedArity =
1155 if (!
Result.isNull() && !Pack.DeferredDeduction.isNull()) {
1157 NewPack = Pack.DeferredDeduction;
1161 NamedDecl *Param = TemplateParams->getParam(Pack.Index);
1164 Info.FirstArg = OldPack;
1165 Info.SecondArg = NewPack;
1166 return TemplateDeductionResult::Inconsistent;
1172 if (*Expansions != PackElements) {
1175 return TemplateDeductionResult::IncompletePack;
1182 return TemplateDeductionResult::Success;
1187 TemplateParameterList *TemplateParams;
1188 SmallVectorImpl<DeducedTemplateArgument> &Deduced;
1189 TemplateDeductionInfo &Info;
1190 unsigned PackElements = 0;
1191 bool IsPartiallyExpanded =
false;
1192 bool DeducePackIfNotAlreadyDeduced =
false;
1193 bool DeducedFromEarlierParameter =
false;
1194 bool FinishingDeduction =
false;
1196 UnsignedOrNone FixedNumExpansions = std::nullopt;
1198 SmallVector<DeducedPack, 2> Packs;
1208 bool FinishingDeduction,
T &&DeductFunc) {
1217 const PackExpansionType *Expansion
1218 = dyn_cast<PackExpansionType>(Params[
ParamIdx]);
1223 if (ArgIdx >= Args.size())
1235 DeductFunc(S, TemplateParams,
ParamIdx, ArgIdx,
1236 Params[
ParamIdx].getUnqualifiedType(),
1237 Args[ArgIdx].getUnqualifiedType(), Info, Deduced, POK);
1252 QualType Pattern = Expansion->getPattern();
1253 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern,
1255 FinishingDeduction);
1259 if (
ParamIdx + 1 == Params.size() || PackScope.hasFixedArity()) {
1260 for (; ArgIdx < Args.size() && PackScope.hasNextElement(); ++ArgIdx) {
1263 S, TemplateParams,
ParamIdx, ArgIdx,
1265 Info, Deduced, POK);
1268 PackScope.nextPackElement();
1289 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
1290 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
1292 PackScope.nextPackElement();
1298 if (
auto Result = PackScope.finish();
1314 if (ArgIdx < Args.size())
1357 llvm::SmallBitVector *HasDeducedParam) {
1358 return ::DeduceForEachType(
1359 S, TemplateParams, Params, Args, Info, Deduced, POK,
1365 bool HasDeducedAnyParamCopy =
false;
1367 S, TemplateParams, P, A, Info, Deduced, TDF, POK,
1368 false, &HasDeducedAnyParamCopy);
1369 if (HasDeducedAnyParam && HasDeducedAnyParamCopy)
1370 *HasDeducedAnyParam =
true;
1371 if (HasDeducedParam && HasDeducedAnyParamCopy)
1372 (*HasDeducedParam)[
ParamIdx] =
true;
1386 if (ParamQs == ArgQs)
1414 return Context.hasSameType(P, A);
1421 return Context.hasSameFunctionTypeIgnoringExceptionSpec(P, A);
1430 if (!Guide || !Guide->isImplicit())
1432 return Guide->getDeducedTemplate()->getTemplateParameters()->size();
1442 if (ParamRef->getPointeeType().getQualifiers())
1445 ParamRef->getPointeeType()->getAsCanonical<TemplateTypeParmType>();
1446 return TypeParm && TypeParm->getIndex() >= FirstInnerIndex;
1474 bool *HasDeducedAnyParam) {
1500 bool HasDeducedAnyParam;
1502 llvm::MapVector<const CXXRecordDecl *, MatchValue> Matches;
1504 auto AddBases = [&Visited, &ToVisit](
const CXXRecordDecl *RD) {
1507 assert(
T->isRecordType() &&
"Base class that isn't a record?");
1508 if (Visited.insert(
T->getAsCXXRecordDecl()).second)
1509 ToVisit.push_back(
T);
1518 while (!ToVisit.empty()) {
1519 QualType NextT = ToVisit.pop_back_val();
1524 bool HasDeducedAnyParamCopy =
false;
1527 &HasDeducedAnyParamCopy);
1533 Matches.insert({RD, {DeducedCopy, HasDeducedAnyParamCopy}});
1544 if (Matches.size() > 1) {
1546 for (
const auto &
Match : Matches)
1547 AddBases(
Match.first);
1551 while (Matches.size() > 1 && !ToVisit.empty()) {
1552 const CXXRecordDecl *RD = ToVisit.pop_back_val()->getAsCXXRecordDecl();
1561 if (Matches.empty())
1563 if (Matches.size() > 1)
1566 std::swap(Matches.front().second.Deduced, Deduced);
1567 if (
bool HasDeducedAnyParamCopy = Matches.front().second.HasDeducedAnyParam;
1568 HasDeducedAnyParamCopy && HasDeducedAnyParam)
1569 *HasDeducedAnyParam = HasDeducedAnyParamCopy;
1610 bool *HasDeducedAnyParam) {
1614 if (
const auto *AExp = dyn_cast<PackExpansionType>(A))
1615 A = AExp->getPattern();
1710 if (
const auto *TTP = P->
getAsCanonical<TemplateTypeParmType>()) {
1716 unsigned Index = TTP->getIndex();
1743 "saw template type parameter with wrong depth");
1745 "Unresolved overloaded function");
1784 if (Result.isNull()) {
1788 case Decl::TemplateTypeParm:
1791 case Decl::NonTypeTemplateParm:
1794 case Decl::TemplateTemplateParm:
1798 llvm_unreachable(
"unexpected kind");
1805 Deduced[Index] = Result;
1806 if (HasDeducedAnyParam)
1807 *HasDeducedAnyParam =
true;
1819 if (P->
getAs<SubstTemplateTypeParmPackType>())
1865#define NON_CANONICAL_TYPE(Class, Base) \
1866 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1867#define TYPE(Class, Base)
1868#include "clang/AST/TypeNodes.inc"
1870 case Type::TemplateTypeParm:
1871 case Type::SubstTemplateTypeParmPack:
1872 case Type::SubstBuiltinTemplatePack:
1873 llvm_unreachable(
"Type nodes handled above");
1885 case Type::VariableArray:
1887 case Type::FunctionNoProto:
1890 case Type::ObjCObject:
1891 case Type::ObjCInterface:
1892 case Type::ObjCObjectPointer:
1902 case Type::Complex: {
1907 S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
1909 false, HasDeducedAnyParam);
1913 case Type::Atomic: {
1918 S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
1920 false, HasDeducedAnyParam);
1924 case Type::Pointer: {
1935 PointeeType, Info, Deduced,
1938 false, HasDeducedAnyParam);
1942 case Type::LValueReference: {
1949 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1951 false, HasDeducedAnyParam);
1955 case Type::RValueReference: {
1962 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
1964 false, HasDeducedAnyParam);
1968 case Type::IncompleteArray: {
1974 assert(IAP &&
"Template parameter not of incomplete array type");
1977 S, TemplateParams, IAP->getElementType(), IAA->getElementType(), Info,
1980 false, HasDeducedAnyParam);
1984 case Type::ConstantArray: {
1988 if (!CAA || CAA->getSize() != CAP->getSize())
1992 S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info,
1995 false, HasDeducedAnyParam);
1999 case Type::DependentSizedArray: {
2008 S, TemplateParams, DAP->getElementType(), AA->getElementType(),
2011 false, HasDeducedAnyParam);
2024 "saw non-type template parameter with wrong depth");
2025 if (
const auto *CAA = dyn_cast<ConstantArrayType>(AA)) {
2026 llvm::APSInt Size(CAA->getSize());
2030 Deduced, HasDeducedAnyParam);
2032 if (
const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
2033 if (DAA->getSizeExpr())
2035 S, TemplateParams, NTTP, DAA->getSizeExpr(), Info,
2045 case Type::FunctionProto: {
2051 if (FPP->getMethodQuals() != FPA->getMethodQuals() ||
2052 FPP->getRefQualifier() != FPA->getRefQualifier() ||
2053 FPP->isVariadic() != FPA->isVariadic())
2058 S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
2060 false, HasDeducedAnyParam);
2066 S, TemplateParams, FPP->param_types(), FPA->param_types(), Info,
2079 Expr *NoexceptExpr = FPP->getNoexceptExpr();
2084 "saw non-type template parameter with wrong depth");
2087 switch (FPA->canThrow()) {
2101 if (
Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
2103 S, TemplateParams, NTTP, ArgNoexceptExpr, Info,
2117 case Type::InjectedClassName:
2126 case Type::TemplateSpecialization: {
2132 Deduced, HasDeducedAnyParam);
2139 Deduced, HasDeducedAnyParam);
2154 Deduced = DeducedOrig;
2159 Deduced, HasDeducedAnyParam);
2173 case Type::MemberPointer: {
2190 S, TemplateParams, PPT, APT, Info, Deduced, SubTDF,
2192 false, HasDeducedAnyParam);
2199 :
QualType(MPP->getQualifier().getAsType(), 0);
2200 assert(!TP.
isNull() &&
"member pointer with non-type class");
2205 :
QualType(MPA->getQualifier().getAsType(), 0)
2207 assert(!TA.
isNull() &&
"member pointer with non-type class");
2210 S, TemplateParams, TP, TA, Info, Deduced, SubTDF,
2212 false, HasDeducedAnyParam);
2220 case Type::BlockPointer: {
2226 S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info,
2228 false, HasDeducedAnyParam);
2234 case Type::ExtVector: {
2239 if (VP->getNumElements() != VA->getNumElements())
2241 ElementType = VA->getElementType();
2246 ElementType = VA->getElementType();
2252 S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
2254 false, HasDeducedAnyParam);
2257 case Type::DependentVector: {
2263 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2265 false, HasDeducedAnyParam);
2276 ArgSize = VA->getNumElements();
2283 HasDeducedAnyParam);
2289 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2291 false, HasDeducedAnyParam);
2302 S, TemplateParams, NTTP, VA->getSizeExpr(), Info,
2312 case Type::DependentSizedExtVector: {
2318 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2320 false, HasDeducedAnyParam);
2331 ArgSize = VA->getNumElements();
2336 S, TemplateParams, NTTP, ArgSize, S.
Context.
IntTy,
true, Info,
2343 S, TemplateParams, VP->getElementType(), VA->getElementType(),
2345 false, HasDeducedAnyParam);
2356 S, TemplateParams, NTTP, VA->getSizeExpr(), Info,
2367 case Type::ConstantMatrix: {
2374 if (MP->getNumRows() != MA->getNumRows() ||
2375 MP->getNumColumns() != MA->getNumColumns()) {
2380 S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
2382 false, HasDeducedAnyParam);
2385 case Type::DependentSizedMatrix: {
2395 false, HasDeducedAnyParam);
2400 auto DeduceMatrixArg =
2401 [&S, &Info, &Deduced, &TemplateParams, &HasDeducedAnyParam, POK](
2405 const auto *ACM = dyn_cast<ConstantMatrixType>(A);
2406 const auto *ADM = dyn_cast<DependentSizedMatrixType>(A);
2407 if (!ParamExpr->isValueDependent()) {
2408 std::optional<llvm::APSInt> ParamConst =
2409 ParamExpr->getIntegerConstantExpr(S.
Context);
2414 if ((ACM->*GetArgDimension)() == *ParamConst)
2419 Expr *ArgExpr = (ADM->*GetArgDimensionExpr)();
2420 if (std::optional<llvm::APSInt> ArgConst =
2422 if (*ArgConst == *ParamConst)
2433 llvm::APSInt ArgConst(
2435 ArgConst = (ACM->*GetArgDimension)();
2439 Deduced, HasDeducedAnyParam);
2443 S, TemplateParams, NTTP, (ADM->*GetArgDimensionExpr)(), Info,
2447 if (
auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
2453 return DeduceMatrixArg(MP->getColumnExpr(), MA,
2461 case Type::DependentAddressSpace: {
2467 S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(),
2469 false, HasDeducedAnyParam);
2480 S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info,
2491 S, TemplateParams, ASP->getPointeeType(),
2494 false, HasDeducedAnyParam);
2505 S, TemplateParams, NTTP, ArgAddressSpace, S.
Context.
IntTy,
true,
2507 HasDeducedAnyParam);
2512 case Type::DependentBitInt: {
2516 if (IP->isUnsigned() != IA->isUnsigned())
2525 ArgSize = IA->getNumBits();
2528 S, TemplateParams, NTTP, ArgSize, S.
Context.
IntTy,
true, Info,
2533 if (IP->isUnsigned() != IA->isUnsigned())
2541 case Type::TypeOfExpr:
2543 case Type::DependentName:
2544 case Type::UnresolvedUsing:
2545 case Type::Decltype:
2546 case Type::UnaryTransform:
2547 case Type::DeducedTemplateSpecialization:
2548 case Type::PackExpansion:
2550 case Type::ArrayParameter:
2551 case Type::HLSLAttributedResource:
2552 case Type::HLSLInlineSpirv:
2556 case Type::PackIndexing: {
2557 const PackIndexingType *PIT = P->
getAs<PackIndexingType>();
2558 if (PIT->hasSelectedType()) {
2560 S, TemplateParams, PIT->getSelectedType(), A, Info, Deduced, TDF,
2562 false, HasDeducedAnyParam);
2568 llvm_unreachable(
"Invalid Type Class!");
2576 bool *HasDeducedAnyParam) {
2585 llvm_unreachable(
"Null template argument in parameter list");
2593 false, HasDeducedAnyParam);
2605 HasDeducedAnyParam);
2611 llvm_unreachable(
"caller should handle pack expansions");
2666 HasDeducedAnyParam);
2671 Deduced, HasDeducedAnyParam);
2687 llvm_unreachable(
"Unknown template argument kind");
2692 llvm_unreachable(
"Argument packs should be expanded by the caller!");
2695 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2708 if (ArgIdx == Args.size())
2715 assert(ArgIdx == Args.size() - 1 &&
"Pack not at the end of argument list?");
2718 return ArgIdx < Args.size();
2724 bool FoundPackExpansion =
false;
2725 for (
const auto &A : Args) {
2726 if (FoundPackExpansion)
2734 if (A.isPackExpansion())
2735 FoundPackExpansion =
true;
2765 for (
unsigned ArgIdx = 0,
ParamIdx = 0; ; ) {
2771 if (!Ps[
ParamIdx].isPackExpansion()) {
2776 return !FoldPackArgument && NumberOfArgumentsMustMatch
2780 if (As[ArgIdx].isPackExpansion()) {
2785 if (!FoldPackArgument)
2792 S, TemplateParams, Ps[
ParamIdx], Pattern, Info,
2800 if (Ps[
ParamIdx].isPackExpansion())
2806 S, TemplateParams, Ps[
ParamIdx], As[ArgIdx], Info,
2827 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
2833 PackScope.hasNextElement();
2835 if (!As[ArgIdx].isPackExpansion()) {
2836 if (!FoldPackParameter)
2838 if (FoldPackArgument)
2844 Deduced, HasDeducedAnyParam);
2848 PackScope.nextPackElement();
2853 return PackScope.finish();
2861 bool NumberOfArgumentsMustMatch) {
2862 return ::DeduceTemplateArguments(
2863 *
this, TemplateParams, Ps, As, Info, Deduced, NumberOfArgumentsMustMatch,
2874 llvm_unreachable(
"Can't get a NULL template argument here");
2923 llvm_unreachable(
"Invalid TemplateArgument Kind!");
2941 unsigned ArgumentPackIndex) {
2953 Template->getSourceRange().getEnd(), ArgumentPackIndex, CTAI,
2967 CanonicalPackedArgsBuilder;
2975 "deduced nested pack");
2981 S.
Diag(Param->getLocation(),
2982 diag::err_template_arg_deduced_incomplete_pack)
2986 if (ConvertArg(InnerArg, SugaredPackedArgsBuilder.size()))
2991 CanonicalPackedArgsBuilder.push_back(
2997 if (SugaredPackedArgsBuilder.empty()) {
3003 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3008 S.
SubstType(NTTP->getType(), Args, NTTP->getLocation(),
3009 NTTP->getDeclName()).isNull())
3011 }
else if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) {
3025 S.
Context, CanonicalPackedArgsBuilder));
3029 return ConvertArg(Arg, 0);
3041 unsigned NumAlreadyConverted,
bool *IsIncomplete) {
3042 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
3049 if (Deduced[I].isNull() && Param->isTemplateParameterPack()) {
3051 PackDeductionScope(S, TemplateParams, Deduced, Info, I).finish();
3056 if (!Deduced[I].isNull()) {
3057 if (I < NumAlreadyConverted) {
3061 if (Param->isParameterPack() && CurrentInstantiationScope &&
3101 *IsIncomplete =
true;
3108 bool HasDefaultArg =
false;
3121 if (Rec->isLambda())
3122 if (
auto *Method = dyn_cast<CXXMethodDecl>(Rec->getDeclContext())) {
3124 ThisTypeQuals = Method->getMethodQualifiers();
3169 if (
auto *DC = dyn_cast<DeclContext>(D))
3192 bool DeducedArgsNeedReplacement =
false;
3193 if (
auto *TD = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Template)) {
3194 TD->getAssociatedConstraints(AssociatedConstraints);
3195 DeducedArgsNeedReplacement = !TD->isClassScopeExplicitSpecialization();
3196 }
else if (
auto *TD =
3197 dyn_cast<VarTemplatePartialSpecializationDecl>(
Template)) {
3198 TD->getAssociatedConstraints(AssociatedConstraints);
3199 DeducedArgsNeedReplacement = !TD->isClassScopeExplicitSpecialization();
3202 AssociatedConstraints);
3205 std::optional<ArrayRef<TemplateArgument>> Innermost;
3208 if (!DeducedArgsNeedReplacement)
3209 Innermost = CanonicalDeducedArgs;
3260 if (CopyDeducedArgs) {
3266 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
3282 Info.
FirstArg = Ps[ArgIdx].getArgument();
3289 {},
false, InstCTAI,
3302 while (!Stack.empty()) {
3303 auto &Xs = Stack.back();
3308 auto &
X = Xs.front();
3310 Stack.emplace_back(
X.getPackAsArray());
3311 Xs = Xs.drop_front();
3314 assert(!
X.isNull());
3321 auto [Ps, P] = take(PsStack);
3322 auto [As, A] = take(AsStack);
3323 if (P.isNull() && A.isNull())
3326 PA = A.isPackExpansion() ? A.getPackExpansionPattern() : A;
3328 if (!P.isPackExpansion() && !A.isPackExpansion()) {
3330 (AsStack.empty() ? As.end() : AsStack.back().begin()) -
3336 if (P.isPackExpansion()) {
3337 Ps = Ps.drop_front();
3340 if (A.isPackExpansion()) {
3341 As = As.drop_front();
3345 Ps = Ps.drop_front(P.isPackExpansion() ? 0 : 1);
3346 As = As.drop_front(A.isPackExpansion() && !P.isPackExpansion() ? 0 : 1);
3348 assert(PsStack.empty());
3349 assert(AsStack.empty());
3368 for (
unsigned I = 0, N = Ps.size(); I != N; ++I)
3373 Info, CopyDeducedArgs);
3408template <
typename T>
3409static std::enable_if_t<IsPartialSpecialization<T>::value,
3414 if (Partial->isInvalidDecl())
3433 Deduced.resize(Partial->getTemplateParameters()->size());
3435 S, Partial->getTemplateParameters(),
3436 Partial->getTemplateArgs().asArray(), TemplateArgs, Info, Deduced,
3451 Result = ::FinishTemplateArgumentDeduction(
3452 S, Partial, Partial->getTemplateParameters(),
3453 Partial->getSpecializedTemplate(),
3455 Partial->getTemplateArgsAsWritten()->arguments(), TemplateArgs, Deduced,
3472 return ::DeduceTemplateArguments(*
this, Partial, TemplateArgs, Info);
3478 return ::DeduceTemplateArguments(*
this, Partial, TemplateArgs, Info);
3488 if (
const auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
3490 PType =
Context.getCanonicalTagType(CTD->getTemplatedDecl());
3491 }
else if (
const auto *
AliasTemplate = dyn_cast<TypeAliasTemplateDecl>(TD)) {
3492 PType =
AliasTemplate->getTemplatedDecl()->getUnderlyingType();
3494 assert(
false &&
"Expected a class or alias template");
3513 return DeducedResult;
3523 Result = ::FinishTemplateArgumentDeduction(*this, TD, Deduced, Info);
3537 if (
const TemplateSpecializationType *Spec
3538 =
T->getAs<TemplateSpecializationType>())
3539 return Spec->getTemplateName().getAsTemplateDecl() !=
nullptr;
3565 if (ExplicitTemplateArgs.
size() == 0) {
3568 for (
auto *P :
Function->parameters())
3569 ParamTypes.push_back(P->getType());
3599 ExplicitTemplateArgs, {},
3604 if (Index >= TemplateParams->
size())
3617 CanonicalExplicitArgumentList);
3629 unsigned PartiallySubstitutedPackIndex = -1u;
3637 if (!Expansions || Arg.
pack_size() < *Expansions) {
3647 assert(Proto &&
"Function template does not have a prototype?");
3655 SugaredExplicitArgumentList->
asArray(),
3665 nullptr, ExtParamInfos))
3681 ThisContext =
Method->getParent();
3682 ThisTypeQuals =
Method->getMethodQualifiers();
3696 Diag(
Function->getLocation(), diag::err_kern_type_not_void_return)
3707 nullptr, ExtParamInfos))
3731 Deduced.reserve(TemplateParams->
size());
3732 for (
unsigned I = 0, N = SugaredExplicitArgumentList->
size(); I != N; ++I) {
3734 if (I == PartiallySubstitutedPackIndex)
3737 Deduced.push_back(Arg);
3764 if (Context.hasSameUnqualifiedType(A, DeducedA))
3805 if (AQuals == DeducedAQuals) {
3823 bool ObjCLifetimeConversion =
false;
3826 ObjCLifetimeConversion) ||
3848 if (Context.hasSameUnqualifiedType(A, DeducedA))
3872 if (PD->isParameterPack()) {
3875 unsigned NumExpansions = NumArgs ? *NumArgs : 1;
3876 if (Idx + NumExpansions >
ParamIdx)
3878 Idx += NumExpansions;
3881 return std::nullopt;
3886 llvm_unreachable(
"parameter index would not be produced from template");
3938 bool ForOverloadSetAddressResolution,
3939 llvm::function_ref<
bool(
bool)> CheckNonDependent) {
3959 bool IsIncomplete =
false;
3964 NumExplicitlySpecified, PartialOverloading ? &IsIncomplete :
nullptr);
3973 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
3982 if (CheckNonDependent(
true))
3994 if (!IsLambda && !IsIncomplete) {
4015 if (CheckNonDependent(
false))
4032 CanonicalDeducedArgumentList &&
4052 if (IsLambda && !IsIncomplete) {
4077 if (OriginalCallArgs) {
4082 llvm::SmallDenseMap<std::pair<unsigned, QualType>,
QualType> DeducedATypes;
4083 for (
unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
4087 unsigned ExplicitOffset =
4089 !ForOverloadSetAddressResolution)
4110 if (CacheEntry.
isNull()) {
4119 DeducedA = CacheEntry;
4134 auto [Pos, Inserted] =
4148 if (S.
getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
4153 if (Method->isImplicitObjectMemberFunction()) {
4160 Fn->getType(), std::nullopt, Method->getParent());
4174 bool ParamWasReference,
4183 if (ParamWasReference)
4242 if (ArgType.isNull())
continue;
4246 ArgType->isFunctionType())
4262 Deduced(TemplateParams->
size());
4265 S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF,
4309 assert(Arg &&
"expected a non-null arg expression");
4311 ParamRefType !=
nullptr, FailedTSC);
4312 if (ArgType.isNull())
4318 if (ArgType->isIncompleteArrayType()) {
4319 assert(Arg &&
"expected a non-null arg expression");
4328 if (S.
getLangOpts().OpenCL && !ArgType.hasAddressSpace())
4342 if (ArgType->canDecayToPointerType())
4347 ArgType = ArgType.getUnqualifiedType();
4365 if (ArgType->isPointerType() || ArgType->isMemberPointerType() ||
4366 ArgType->isObjCObjectPointerType())
4393 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF,
4418 ElTy = ArrTy->getElementType();
4435 S, TemplateParams, 0, ElTy, E->getType(),
4437 OriginalCallArgs,
true, ArgIdx, TDF);
4445 if (
auto *DependentArrTy = dyn_cast_or_null<DependentSizedArrayType>(ArrTy)) {
4448 Info, DependentArrTy->getSizeExpr())) {
4457 S, TemplateParams, NTTP, llvm::APSInt(Size),
T,
4458 true, Info,
false, Deduced,
4477 bool DecomposedParam,
unsigned ArgIdx,
unsigned TDF,
4480 QualType OrigParamType = ParamType;
4485 S, TemplateParams, FirstInnerIndex, ParamType, ArgType,
4486 ArgClassification, Arg, TDF, FailedTSC))
4490 if (
InitListExpr *ILE = dyn_cast_if_present<InitListExpr>(Arg))
4492 Deduced, OriginalCallArgs, ArgIdx, TDF);
4500 OriginalCallArgs.push_back(
4503 S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF,
4512 bool PartialOverloading,
bool AggregateDeductionCandidate,
4515 bool ForOverloadSetAddressResolution,
4521 unsigned NumParams =
Function->getNumParams();
4522 bool HasExplicitObject =
false;
4523 int ExplicitObjectOffset = 0;
4531 if (!ForOverloadSetAddressResolution &&
4532 Function->hasCXXExplicitFunctionObjectParameter()) {
4533 HasExplicitObject =
true;
4534 ExplicitObjectOffset = 1;
4543 if (Args.size() <
Function->getMinRequiredExplicitArguments() &&
4544 !PartialOverloading)
4547 PartialOverloading)) {
4549 if (Proto->isTemplateVariadic())
4551 else if (!Proto->isVariadic())
4562 unsigned NumExplicitlySpecified = 0;
4563 if (ExplicitTemplateArgs) {
4566 Result = SubstituteExplicitTemplateArguments(
4567 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, nullptr,
4573 NumExplicitlySpecified = Deduced.size();
4576 for (
unsigned I = 0; I != NumParams; ++I)
4577 ParamTypes.push_back(
Function->getParamDecl(I)->getType());
4583 auto DeduceCallArgument = [&](
QualType ParamType,
unsigned ArgIdx,
4584 bool ExplicitObjectArgument) {
4592 if (ExplicitObjectArgument) {
4595 *
this, TemplateParams, FirstInnerIndex, ParamType, ObjectType,
4596 ObjectClassification,
4597 nullptr, Info, Deduced, OriginalCallArgs,
4603 *
this, TemplateParams, FirstInnerIndex, ParamType,
4605 Args[ArgIdx], Info, Deduced, OriginalCallArgs,
false,
4610 Deduced.resize(TemplateParams->
size());
4612 for (
unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0;
4616 const PackExpansionType *ParamExpansion =
4617 dyn_cast<PackExpansionType>(ParamType);
4618 if (!ParamExpansion) {
4620 if (ArgIdx >= Args.size() && !(HasExplicitObject &&
ParamIdx == 0))
4623 ParamTypesForArgChecking.push_back(ParamType);
4625 if (
ParamIdx == 0 && HasExplicitObject) {
4629 if (
auto Result = DeduceCallArgument(ParamType, 0,
4636 if (
auto Result = DeduceCallArgument(ParamType, ArgIdx++,
4644 bool IsTrailingPack =
ParamIdx + 1 == NumParamTypes;
4646 QualType ParamPattern = ParamExpansion->getPattern();
4647 PackDeductionScope PackScope(*
this, TemplateParams, Deduced, Info,
4649 AggregateDeductionCandidate && IsTrailingPack);
4667 if (IsTrailingPack || PackScope.hasFixedArity()) {
4668 for (; ArgIdx < Args.size() && PackScope.hasNextElement();
4669 PackScope.nextPackElement(), ++ArgIdx) {
4670 ParamTypesForArgChecking.push_back(ParamPattern);
4671 if (
auto Result = DeduceCallArgument(ParamPattern, ArgIdx,
4680 UnsignedOrNone NumExpansions = ParamExpansion->getNumExpansions();
4681 if (NumExpansions && !PackScope.isPartiallyExpanded()) {
4682 for (
unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
4684 ParamTypesForArgChecking.push_back(ParamPattern);
4687 PackScope.nextPackElement();
4689 }
else if (!IsTrailingPack && !PackScope.isPartiallyExpanded() &&
4690 PackScope.isDeducedFromEarlierParameter()) {
4704 PackScope.getSavedPackSizeIfAllEqual();
4705 if (!ArgPosAfterSubstitution)
4708 unsigned PackArgEnd = ArgIdx + *ArgPosAfterSubstitution;
4709 for (; ArgIdx < PackArgEnd && ArgIdx < Args.size(); ArgIdx++) {
4710 ParamTypesForArgChecking.push_back(ParamPattern);
4712 DeduceCallArgument(ParamPattern, ArgIdx,
4717 PackScope.nextPackElement();
4724 if (
auto Result = PackScope.finish();
4735 Result = FinishTemplateArgumentDeduction(
4736 FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
4737 &OriginalCallArgs, PartialOverloading, PartialOrdering,
4738 ForOverloadSetAddressResolution,
4739 [&, CallingCtx](bool OnlyInitializeNonUserDefinedConversions) {
4740 ContextRAII SavedContext(*this, CallingCtx);
4741 return CheckNonDependent(ParamTypesForArgChecking,
4742 OnlyInitializeNonUserDefinedConversions);
4750 bool AdjustExceptionSpec) {
4751 if (ArgFunctionType.
isNull())
4752 return ArgFunctionType;
4757 bool Rebuild =
false;
4760 if (EPI.ExtInfo.getCC() != CC) {
4761 EPI.ExtInfo = EPI.ExtInfo.withCallingConv(CC);
4765 bool NoReturn = FunctionTypeP->getNoReturnAttr();
4766 if (EPI.ExtInfo.getNoReturn() != NoReturn) {
4767 EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn);
4771 if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() ||
4773 EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec;
4778 return ArgFunctionType;
4788 bool IsAddressOfFunction) {
4800 unsigned NumExplicitlySpecified = 0;
4802 if (ExplicitTemplateArgs) {
4805 Result = SubstituteExplicitTemplateArguments(
4806 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes,
4807 &FunctionType, Info);
4812 NumExplicitlySpecified = Deduced.size();
4818 if (!IsAddressOfFunction)
4823 std::optional<EnterExpressionEvaluationContext>
Unevaluated(
4827 Deduced.resize(TemplateParams->
size());
4831 bool HasDeducedReturnType =
false;
4833 Function->getReturnType()->getContainedAutoType()) {
4835 HasDeducedReturnType =
true;
4843 *
this, TemplateParams,
FunctionType, ArgFunctionType, Info, Deduced,
4852 Result = FinishTemplateArgumentDeduction(
4853 FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
4855 true, IsAddressOfFunction);
4862 if (HasDeducedReturnType && IsAddressOfFunction &&
4884 if (!IsAddressOfFunction) {
4890 if (HasDeducedReturnType) {
4899 if (!ArgFunctionType.
isNull()) {
4901 SpecializationType, ArgFunctionType)
4902 : !
Context.hasSameFunctionTypeIgnoringExceptionSpec(
4903 SpecializationType, ArgFunctionType)) {
4941 if (!IsReferenceP) {
4950 assert(!A->
isReferenceType() &&
"Reference types were handled above");
4956 P =
Context.getArrayDecayedType(P);
4961 P =
Context.getPointerType(P);
4987 Deduced.resize(TemplateParams->
size());
5016 ParamType, ObjectType, ObjectClassification,
5017 nullptr, Info, Deduced, OriginalCallArgs,
5024 *
this, TemplateParams, P, A, Info, Deduced, TDF,
5036 Result = FinishTemplateArgumentDeduction(
5037 ConversionTemplate, Deduced, 0, ConversionSpecialized, Info,
5038 &OriginalCallArgs, false,
5041 Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
5050 bool IsAddressOfFunction) {
5053 IsAddressOfFunction);
5057 struct DependentAuto {
bool IsPack; };
5061 class SubstituteDeducedTypeTransform :
5064 bool ReplacementIsPack;
5069 SubstituteDeducedTypeTransform(
Sema &SemaRef, DependentAuto DA)
5071 ReplacementIsPack(DA.IsPack), UseTypeSugar(
true) {}
5073 SubstituteDeducedTypeTransform(Sema &SemaRef, QualType Replacement,
5074 bool UseTypeSugar =
true)
5075 : TreeTransform<SubstituteDeducedTypeTransform>(SemaRef),
5076 Replacement(Replacement), ReplacementIsPack(
false),
5077 UseTypeSugar(UseTypeSugar) {}
5079 QualType TransformDesugared(TypeLocBuilder &TLB, DeducedTypeLoc TL) {
5081 "unexpected unsugared replacement kind");
5082 QualType
Result = Replacement;
5083 TemplateTypeParmTypeLoc NewTL = TLB.
push<TemplateTypeParmTypeLoc>(
Result);
5088 QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) {
5099 return TransformDesugared(TLB, TL);
5101 QualType
Result = SemaRef.Context.getAutoType(
5102 Replacement, TL.
getTypePtr()->getKeyword(), Replacement.isNull(),
5103 ReplacementIsPack, TL.
getTypePtr()->getTypeConstraintConcept(),
5104 TL.
getTypePtr()->getTypeConstraintArguments());
5110 QualType TransformDeducedTemplateSpecializationType(
5111 TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
5113 return TransformDesugared(TLB, TL);
5115 QualType
Result = SemaRef.Context.getDeducedTemplateSpecializationType(
5117 Replacement, Replacement.isNull());
5118 auto NewTL = TLB.
push<DeducedTemplateSpecializationTypeLoc>(
Result);
5129 bool TransformExceptionSpec(SourceLocation Loc,
5130 FunctionProtoType::ExceptionSpecInfo &ESI,
5131 SmallVectorImpl<QualType> &Exceptions,
5137 return inherited::TransformExceptionSpec(Loc, ESI, Exceptions, Changed);
5140 QualType Apply(TypeLoc TL) {
5145 return TransformType(TLB, TL);
5161 Deduced,
TypeLoc.getNameLoc())));
5162 for (
unsigned I = 0,
C =
TypeLoc.getNumArgs(); I !=
C; ++I)
5192 llvm::raw_string_ostream OS(Buf);
5193 OS <<
"'" <<
Concept->getName();
5194 if (
TypeLoc.hasExplicitTemplateArgs()) {
5195 printTemplateArgumentList(
5197 Type.getTypeConstraintConcept()->getTemplateParameters());
5201 diag::err_placeholder_constraints_not_satisfied)
5212 bool IgnoreConstraints,
5215 if (
Init->containsErrors())
5221 if (
Init->getType()->isNonOverloadPlaceholderType() || AT->isDecltypeAuto()) {
5228 DependentAuto DependentResult = {
5231 if (!DependentDeduction &&
5233 Init->containsUnexpandedParameterPack())) {
5234 Result = SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
5235 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
5240 auto *String = dyn_cast<StringLiteral>(
Init);
5242 Diag(
Type.getBeginLoc(), diag::ext_c23_auto_non_plain_identifier);
5244 Result = SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(TL);
5245 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
5251 Diag(
Type.getBeginLoc(), diag::ext_c23_auto_non_plain_identifier);
5254 auto *InitList = dyn_cast<InitListExpr>(
Init);
5256 Diag(
Init->getBeginLoc(), diag::err_auto_init_list_from_c)
5268 if (
Init->isTypeDependent()) {
5270 SubstituteDeducedTypeTransform(*
this, DependentResult).Apply(
Type);
5271 assert(!
Result.isNull() &&
"substituting DependentTy can't fail");
5281 if (AT->isDecltypeAuto()) {
5283 Diag(
Init->getBeginLoc(), diag::err_decltype_auto_initializer_list);
5288 assert(!DeducedType.
isNull());
5296 nullptr,
false,
false,
false);
5300 Context, Loc, Loc, TemplParamPtr, Loc,
nullptr);
5306 if (!
Type.getType().getNonReferenceType()->
getAs<AutoType>())
5310 for (
Expr *
Init : InitList->inits()) {
5316 *
this, TemplateParamsSt.get(), 0, TemplArg,
Init->getType(),
5325 <<
Init->getSourceRange();
5328 return DeductionFailed(TDK);
5333 DeducedFromInitRange =
Init->getSourceRange();
5337 Diag(Loc, diag::err_auto_bitfield);
5341 SubstituteDeducedTypeTransform(*
this, TemplArg).Apply(
Type);
5342 assert(!FuncParam.
isNull() &&
5343 "substituting template parameter for 'auto' failed");
5345 *
this, TemplateParamsSt.get(), 0, FuncParam,
Init->getType(),
5348 false, 0, 0, FailedTSC);
5350 return DeductionFailed(TDK);
5356 DeducedType = Deduced[0].getAsType();
5360 if (DeducedType.
isNull())
5371 DeducedType =
Context.getCommonSugaredType(
Result, DeducedType);
5374 if (AT->isConstrained() && !IgnoreConstraints &&
5376 *
this, *AT,
Type.getContainedAutoTypeLoc(), DeducedType))
5379 Result = SubstituteDeducedTypeTransform(*
this, DeducedType).Apply(
Type);
5387 assert((
bool)InitList == OriginalArg.DecomposedParam &&
5388 "decomposed non-init-list in auto deduction?");
5393 return DeductionFailed(TDK);
5402 assert(TypeToReplaceAuto !=
Context.DependentTy);
5403 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
5404 .TransformType(TypeWithAuto);
5409 assert(TypeToReplaceAuto !=
Context.DependentTy);
5410 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto)
5411 .TransformType(TypeWithAuto);
5415 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
5416 .TransformType(TypeWithAuto);
5421 return SubstituteDeducedTypeTransform(*
this, DependentAuto{
false})
5422 .TransformType(TypeWithAuto);
5427 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
5429 .TransformType(TypeWithAuto);
5434 return SubstituteDeducedTypeTransform(*
this, TypeToReplaceAuto,
5436 .TransformType(TypeWithAuto);
5444 ? diag::err_init_capture_deduction_failure_from_init_list
5445 : diag::err_auto_var_deduction_failure_from_init_list)
5449 VDecl->
isInitCapture() ? diag::err_init_capture_deduction_failure
5450 : diag::err_auto_var_deduction_failure)
5452 <<
Init->getSourceRange();
5484 "failed to deduce lambda return type");
5494 RetType =
Context.getPointerType(RetType);
5497 RetType =
Context.getBlockPointerType(RetType);
5499 Context.adjustDeducedFunctionResultType(FD, RetType);
5511 Diag(Loc, diag::err_auto_fn_used_before_defined) << FD;
5515 return StillUndeduced;
5558 assert(Method && !Method->isExplicitObjectMemberFunction() &&
5559 "expected a member function with no explicit object parameter");
5561 RawType = Context.getQualifiedType(RawType, Method->getMethodQualifiers());
5562 if (Method->getRefQualifier() ==
RQ_RValue ||
5563 (IsOtherRvr && Method->getRefQualifier() ==
RQ_None))
5564 return Context.getRValueReferenceType(RawType);
5565 return Context.getLValueReferenceType(RawType);
5576 bool IsIncompleteSubstitution =
false;
5585 if (IsDeductionGuide) {
5587 P = Injected->getOriginalDecl()->getCanonicalTemplateSpecializationType(
5592 if (InstP.
isNull() && !IsIncompleteSubstitution)
5594 if (!CheckConsistency)
5596 if (IsIncompleteSubstitution)
5601 if (
auto *PA = dyn_cast<PackExpansionType>(A);
5603 A = PA->getPattern();
5606 if (IsDeductionGuide) {
5607 if (
auto *Injected = T1->getAsCanonical<InjectedClassNameType>())
5608 T1 = Injected->getOriginalDecl()->getCanonicalTemplateSpecializationType(
5610 if (
auto *Injected = T2->getAsCanonical<InjectedClassNameType>())
5611 T2 = Injected->getOriginalDecl()->getCanonicalTemplateSpecializationType(
5633 bool IsIncomplete =
false;
5649 Info.
reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
5674 assert(Proto1 && Proto2 &&
"Function templates must have prototypes");
5690 Proto1->
isVariadic() == Proto2->isVariadic() &&
5691 "shouldn't partial order functions with different qualifiers in a "
5692 "context where the function type is used");
5694 assert(Args1.empty() && Args2.empty() &&
5695 "Only call context should have arguments");
5697 Args2 = Proto2->getParamTypes();
5704 bool HasDeducedAnyParamFromReturnType =
false;
5707 S, TemplateParams, Proto2->getReturnType(), Proto1->
getReturnType(),
5710 &HasDeducedAnyParamFromReturnType) !=
5715 llvm::SmallBitVector HasDeducedParam;
5717 HasDeducedParam.resize(Args2.size());
5721 &HasDeducedParam) !=
5733 bool AtLeastAsSpecialized;
5735 AtLeastAsSpecialized =
5736 ::FinishTemplateArgumentDeduction(
5737 S, FT2, Deduced, Info,
5738 [&](Sema &S, FunctionTemplateDecl *FTD,
5739 ArrayRef<TemplateArgument> DeducedArgs) {
5744 if (TPOC != TPOC_Call) {
5745 if (auto TDR = ::CheckDeductionConsistency(
5746 S, FTD, std::nullopt,
5747 Proto2->getReturnType(), Proto1->getReturnType(),
5749 HasDeducedAnyParamFromReturnType);
5750 TDR != TemplateDeductionResult::Success)
5754 if (TPOC == TPOC_Conversion)
5755 return TemplateDeductionResult::Success;
5757 return ::DeduceForEachType(
5758 S, TemplateParams, Args2, Args1, Info, Deduced,
5759 PartialOrderingKind::Call, true,
5760 [&](Sema &S, TemplateParameterList *, int ParamIdx,
5761 UnsignedOrNone ArgIdx, QualType P, QualType A,
5762 TemplateDeductionInfo &Info,
5763 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
5764 PartialOrderingKind) {
5765 if (ArgIdx && *ArgIdx >= static_cast<unsigned>(Args1Offset))
5766 ArgIdx = *ArgIdx - Args1Offset;
5768 ArgIdx = std::nullopt;
5769 return ::CheckDeductionConsistency(
5770 S, FTD, ArgIdx, P, A, DeducedArgs,
5771 HasDeducedParam[ParamIdx]);
5775 if (!AtLeastAsSpecialized)
5784 unsigned ArgIdx = 0, NumArgs = Deduced.size();
5785 for (; ArgIdx != NumArgs; ++ArgIdx)
5786 if (Deduced[ArgIdx].isNull())
5789 if (ArgIdx == NumArgs) {
5796 llvm::SmallBitVector UsedParameters(TemplateParams->size());
5799 for (
unsigned I = 0, N = Args2.size(); I != N; ++I)
5801 TemplateParams->getDepth(), UsedParameters);
5807 TemplateParams->getDepth(), UsedParameters);
5832 S.Context.getFunctionTypeWithExceptionSpec(FD2->getType(),
EST_None),
5833 false, TemplateParams->getDepth(), UsedParameters);
5837 for (; ArgIdx != NumArgs; ++ArgIdx)
5840 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
5852 const TemplateSpecializationType *TST1,
5853 const TemplateSpecializationType *TST2) {
5855 As2 = TST2->template_arguments();
5861 assert(As1.size() == As2.size());
5863 unsigned PackSize1 = TA1.
pack_size(), PackSize2 = TA2.pack_size();
5864 bool IsPackExpansion1 =
5866 bool IsPackExpansion2 =
5867 PackSize2 && TA2.pack_elements().back().isPackExpansion();
5868 if (PackSize1 == PackSize2 && IsPackExpansion1 == IsPackExpansion2)
5870 if (PackSize1 > PackSize2 && IsPackExpansion1)
5872 if (PackSize1 < PackSize2 && IsPackExpansion2)
5881 bool PartialOverloading) {
5886 bool ShouldConvert1 =
false;
5887 bool ShouldConvert2 =
false;
5888 bool Args1Offset =
false;
5889 bool Args2Offset =
false;
5900 const CXXMethodDecl *Method1 = dyn_cast<CXXMethodDecl>(FD1);
5901 const CXXMethodDecl *Method2 = dyn_cast<CXXMethodDecl>(FD2);
5912 bool NonStaticMethod1 = Method1 && !Method1->isStatic(),
5913 NonStaticMethod2 = Method2 && !Method2->
isStatic();
5916 Params2Begin = Proto2->param_type_begin();
5918 size_t NumComparedArguments = NumCallArguments1;
5921 (NonStaticMethod1 && NonStaticMethod2) ||
5922 (OO !=
OO_None && OO != OO_Call && OO != OO_Subscript)) {
5924 NonStaticMethod1 && !Method1->hasCXXExplicitFunctionObjectParameter();
5927 NumComparedArguments += 1;
5929 if (ShouldConvert1) {
5933 : Proto2->param_type_begin()[0]->isRValueReferenceType();
5936 RawObj1Ty, IsRValRef2);
5937 Args1.push_back(Obj1Ty);
5940 if (ShouldConvert2) {
5943 ? Method1->getRefQualifier() ==
RQ_RValue
5947 RawObj2Ty, IsRValRef1);
5948 Args2.push_back(Obj2Ty);
5952 if (NonStaticMethod1 && Method1->hasCXXExplicitFunctionObjectParameter())
5957 Args1.insert(Args1.end(), Params1Begin, Proto1->
param_type_end());
5958 Args2.insert(Args2.end(), Params2Begin, Proto2->param_type_end());
5963 Args1.resize(std::min(Args1.size(), NumComparedArguments));
5964 Args2.resize(std::min(Args2.size(), NumComparedArguments));
5967 std::reverse(Args2.begin(), Args2.end());
5969 assert(!
Reversed &&
"Only call context could have reversed arguments");
5972 Args2, Args2Offset);
5974 Args1, Args1Offset);
5978 if (Better1 != Better2)
5979 return Better1 ? FT1 : FT2;
5981 if (!Better1 && !Better2)
5990 Param1.reserve(FD1->
param_size() + ShouldConvert1);
5992 Param1.push_back(Obj1Ty);
5994 Param1.push_back(P->getType());
5997 Param2.reserve(FD2->
param_size() + ShouldConvert2);
5999 Param2.push_back(Obj2Ty);
6001 Param2.push_back(P->getType());
6003 unsigned NumParams1 = Param1.size();
6004 unsigned NumParams2 = Param2.size();
6010 if (Variadic1 != Variadic2) {
6011 if (Variadic1 && NumParams1 > NumParams2)
6013 if (Variadic2 && NumParams2 > NumParams1)
6020 for (
int i = 0, e = std::min(NumParams1, NumParams2);
6021 !PartialOverloading && i < e; ++i) {
6022 QualType T1 = Param1[i].getCanonicalType();
6023 QualType T2 = Param2[i].getCanonicalType();
6024 auto *TST1 = dyn_cast<TemplateSpecializationType>(T1);
6025 auto *TST2 = dyn_cast<TemplateSpecializationType>(T2);
6037 "unknown MoreSpecializedTrailingPackTieBreakerResult value");
6040 if (!
Context.getLangOpts().CPlusPlus20)
6056 if (TPL1->
size() != TPL2->
size() || NumParams1 != NumParams2)
6072 for (
unsigned i = 0; i < NumParams1; ++i)
6073 if (!
Context.hasSameUnqualifiedType(Param1[i], Param2[i]))
6088 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
6093 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
6095 return AtLeastAsConstrained1 ? FT1 : FT2;
6103 bool Complain,
QualType TargetType) {
6104 if (SpecBegin == SpecEnd) {
6106 Diag(Loc, NoneDiag);
6112 if (SpecBegin + 1 == SpecEnd)
6120 assert(BestTemplate &&
"Not a function template specialization?");
6124 assert(Challenger &&
"Not a function template specialization?");
6129 BestTemplate = Challenger;
6155 Diag(Loc, AmbigDiag);
6162 FD->getPrimaryTemplate()->getTemplateParameters(),
6163 *FD->getTemplateSpecializationArgs());
6164 if (!TargetType.
isNull())
6166 Diag((*I)->getLocation(), PD);
6176 "not for function templates");
6193 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
6198 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
6200 return AtLeastAsConstrained1 ? FD1 : FD2;
6212template <
typename TemplateLikeDecl>
6214 TemplateLikeDecl *P2,
6244 Deduced.resize(P2->getTemplateParameters()->size());
6246 S, P2->getTemplateParameters(), T2, T1, Info, Deduced,
TDF_None,
6266 Result = ::FinishTemplateArgumentDeduction(
6267 S, P2, P2->getTemplateParameters(), Template,
6268 true, Ps, As, Deduced, Info,
6285 template <
typename T1,
typename T2,
6286 std::enable_if_t<std::is_same_v<T1, T2>,
bool> =
true>
6287 T2 *operator()(T1 *, T2 *P2) {
6290 template <
typename T1,
typename T2,
6291 std::enable_if_t<!std::is_same_v<T1, T2>,
bool> =
true>
6292 T1 *operator()(T1 *, T2 *) {
6298struct TemplateArgumentListAreEqual {
6300 TemplateArgumentListAreEqual(ASTContext &Ctx) : Ctx(Ctx) {}
6302 template <
typename T1,
typename T2,
6303 std::enable_if_t<std::is_same_v<T1, T2>,
bool> =
true>
6304 bool operator()(T1 *PS1, T2 *PS2) {
6305 ArrayRef<TemplateArgument> Args1 = PS1->getTemplateArgs().asArray(),
6306 Args2 = PS2->getTemplateArgs().asArray();
6308 for (
unsigned I = 0, E = Args1.size(); I < E; ++I) {
6312 llvm::FoldingSetNodeID IDA, IDB;
6313 Args1[I].Profile(IDA, Ctx);
6314 Args2[I].Profile(IDB, Ctx);
6321 template <
typename T1,
typename T2,
6322 std::enable_if_t<!std::is_same_v<T1, T2>,
bool> =
true>
6323 bool operator()(T1 *Spec, T2 *Primary) {
6324 ArrayRef<TemplateArgument> Args1 = Spec->getTemplateArgs().asArray(),
6325 Args2 = Primary->getInjectedTemplateArgs(Ctx);
6327 for (
unsigned I = 0, E = Args1.size(); I < E; ++I) {
6331 llvm::FoldingSetNodeID IDA, IDB;
6332 Args1[I].Profile(IDA, Ctx);
6366template <
typename TemplateLikeDecl,
typename PrimaryDel>
6367static TemplateLikeDecl *
6370 constexpr bool IsMoreSpecialThanPrimaryCheck =
6371 !std::is_same_v<TemplateLikeDecl, PrimaryDel>;
6374 if constexpr (IsMoreSpecialThanPrimaryCheck)
6377 P2T = P2->getSpecializedTemplate();
6380 if (IsMoreSpecialThanPrimaryCheck && !Better1)
6384 P1->getSpecializedTemplate(), Info);
6385 if (IsMoreSpecialThanPrimaryCheck && !Better2)
6391 if (Better1 != Better2)
6392 return Better1 ? P1 : GetP2()(P1, P2);
6394 if (!Better1 && !Better2)
6403 return GetP2()(P1, P2);
6432 if (!TemplateArgumentListAreEqual(S.
getASTContext())(P1, P2))
6436 P1->getAssociatedConstraints(AC1);
6437 P2->getAssociatedConstraints(AC2);
6438 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
6440 (IsMoreSpecialThanPrimaryCheck && !AtLeastAsConstrained1))
6444 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
6446 return AtLeastAsConstrained1 ? P1 : GetP2()(P1, P2);
6481 "the partial specializations being compared should specialize"
6482 " the same template.");
6500 Context.canonicalizeTemplateArguments(PrimaryCanonArgs);
6550 for (
unsigned I = 0, N = P->
size(); I != N; ++I) {
6575 if (StrictPackMatch)
6582 Deduced.resize(A->
size());
6596 *
this, A, AArgs, PArgs, Info, Deduced,
6602 *StrictPackMatch =
true;
6606 Diag(AArg->
getLocation(), diag::err_template_param_list_different_arity)
6616 diag::err_inconsistent_deduction)
6637 llvm_unreachable(
"Unexpected Result");
6642 TDK = ::FinishTemplateArgumentDeduction(
6643 *this, AArg, AArg->getTemplateParameters(), AArg, PartialOrdering,
6644 AArgs, PArgs, Deduced, Info, false);
6654 assert(PArg->
isInvalidDecl() &&
"Unexpected NonDeducedMismatch");
6678 llvm_unreachable(
"Unexpected Result");
6680 llvm_unreachable(
"Unexpected TDK");
6685 llvm::SmallBitVector &
Used;
6688 MarkUsedTemplateParameterVisitor(llvm::SmallBitVector &
Used,
6692 bool VisitTemplateTypeParmType(TemplateTypeParmType *
T)
override {
6693 if (
T->getDepth() == Depth)
6694 Used[
T->getIndex()] =
true;
6699 if (
auto *TTP = llvm::dyn_cast_or_null<TemplateTemplateParmDecl>(
6701 if (TTP->getDepth() == Depth)
6702 Used[TTP->getIndex()] =
true;
6707 bool VisitDeclRefExpr(DeclRefExpr *E)
override {
6708 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(E->
getDecl()))
6709 if (NTTP->getDepth() == Depth)
6710 Used[NTTP->getIndex()] =
true;
6714 bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *ULE)
override {
6717 if (TTP->getDepth() == Depth)
6718 Used[TTP->getIndex()] =
true;
6735 llvm::SmallBitVector &
Used) {
6737 MarkUsedTemplateParameterVisitor(
Used, Depth)
6738 .TraverseStmt(
const_cast<Expr *
>(E));
6744 E = Expansion->getPattern();
6747 if (
const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E);
6750 Used[TTP->getIndex()] =
true;
6773 bool OnlyDeduced,
unsigned Depth,
6774 llvm::SmallBitVector &
Used) {
6788 llvm::SmallBitVector &
Used) {
6791 = dyn_cast<TemplateTemplateParmDecl>(
Template)) {
6792 if (TTP->getDepth() == Depth)
6793 Used[TTP->getIndex()] =
true;
6812 llvm::SmallBitVector &
Used) {
6817 if (!
T->isDependentType())
6821 switch (
T->getTypeClass()) {
6830 case Type::BlockPointer:
6838 case Type::LValueReference:
6839 case Type::RValueReference:
6847 case Type::MemberPointer: {
6853 OnlyDeduced, Depth,
Used);
6857 case Type::DependentSizedArray:
6860 OnlyDeduced, Depth,
Used);
6864 case Type::ConstantArray:
6865 case Type::IncompleteArray:
6866 case Type::ArrayParameter:
6869 OnlyDeduced, Depth,
Used);
6872 case Type::ExtVector:
6875 OnlyDeduced, Depth,
Used);
6878 case Type::DependentVector: {
6886 case Type::DependentSizedExtVector: {
6896 case Type::DependentAddressSpace: {
6900 OnlyDeduced, Depth,
Used);
6903 OnlyDeduced, Depth,
Used);
6907 case Type::ConstantMatrix: {
6914 case Type::DependentSizedMatrix: {
6925 case Type::FunctionProto: {
6929 for (
unsigned I = 0, N = Proto->
getNumParams(); I != N; ++I) {
6934 if (!OnlyDeduced || I + 1 == N ||
6952 case Type::TemplateTypeParm: {
6954 if (TTP->getDepth() == Depth)
6955 Used[TTP->getIndex()] =
true;
6959 case Type::SubstTemplateTypeParmPack: {
6960 const SubstTemplateTypeParmPackType *Subst
6962 if (Subst->getReplacedParameter()->getDepth() == Depth)
6963 Used[Subst->getIndex()] =
true;
6968 case Type::SubstBuiltinTemplatePack: {
6970 OnlyDeduced, Depth,
Used);
6974 case Type::InjectedClassName:
6977 ->getCanonicalTemplateSpecializationType(Ctx);
6980 case Type::TemplateSpecialization: {
6981 const TemplateSpecializationType *Spec
6998 for (
const auto &Arg : Spec->template_arguments())
7007 OnlyDeduced, Depth,
Used);
7014 OnlyDeduced, Depth,
Used);
7017 case Type::DependentName:
7021 OnlyDeduced, Depth,
Used);
7027 OnlyDeduced, Depth,
Used);
7030 case Type::TypeOfExpr:
7034 OnlyDeduced, Depth,
Used);
7037 case Type::Decltype:
7041 OnlyDeduced, Depth,
Used);
7044 case Type::PackIndexing:
7047 OnlyDeduced, Depth,
Used);
7049 OnlyDeduced, Depth,
Used);
7053 case Type::UnaryTransform:
7057 OnlyDeduced, Depth,
Used);
7060 case Type::PackExpansion:
7063 OnlyDeduced, Depth,
Used);
7067 case Type::DeducedTemplateSpecialization:
7070 OnlyDeduced, Depth,
Used);
7072 case Type::DependentBitInt:
7075 OnlyDeduced, Depth,
Used);
7078 case Type::HLSLAttributedResource:
7085 OnlyDeduced, Depth,
Used);
7090 case Type::VariableArray:
7091 case Type::FunctionNoProto:
7094 case Type::ObjCInterface:
7095 case Type::ObjCObject:
7096 case Type::ObjCObjectPointer:
7097 case Type::UnresolvedUsing:
7100 case Type::HLSLInlineSpirv:
7101#define TYPE(Class, Base)
7102#define ABSTRACT_TYPE(Class, Base)
7103#define DEPENDENT_TYPE(Class, Base)
7104#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
7105#include "clang/AST/TypeNodes.inc"
7117 llvm::SmallBitVector &
Used) {
7135 OnlyDeduced, Depth,
Used);
7153 llvm::SmallBitVector &
Used) {
7159 bool OnlyDeduced,
unsigned Depth,
7160 llvm::SmallBitVector &
Used) {
7169 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
7176 llvm::SmallBitVector &
Used) {
7177 for (
unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
7179 false, Depth,
Used);
7184 llvm::SmallBitVector &Deduced) {
7188 Deduced.resize(TemplateParams->
size());
7191 for (
unsigned I = 0, N =
Function->getNumParams(); I != N; ++I)
7193 true, TemplateParams->
getDepth(), Deduced);
7199 if (!
T->isDependentType())
7204 llvm::SmallBitVector Deduced(TemplateParams->
size());
7208 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.
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 TemplateDeductionResult DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams, NonTypeOrVarTemplateParmDecl NTTP, QualType NullPtrType, TemplateDeductionInfo &Info, bool PartialOrdering, SmallVectorImpl< DeducedTemplateArgument > &Deduced, bool *HasDeducedAnyParam)
Deduce the value of the given non-type template parameter from the given null pointer template argume...
static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, DeducedTemplateArgument Arg, NamedDecl *Template, TemplateDeductionInfo &Info, bool IsDeduced, Sema::CheckTemplateArgumentInfo &CTAI)
Convert the given deduced template argument and add it to the set of fully-converted template argumen...
static TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, ArrayRef< TemplateArgument > Ps, ArrayRef< TemplateArgument > As, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, bool NumberOfArgumentsMustMatch, bool PartialOrdering, PackFold PackFold, bool *HasDeducedAnyParam)
static TemplateDeductionResult DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams, const QualType P, QualType A, TemplateDeductionInfo &Info, bool PartialOrdering, SmallVectorImpl< DeducedTemplateArgument > &Deduced, bool *HasDeducedAnyParam)
static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, unsigned TDF, PartialOrderingKind POK, bool DeducedFromArrayBound, bool *HasDeducedAnyParam)
Deduce the template arguments by comparing the parameter type and the argument type (C++ [temp....
static TemplateDeductionResult CheckDeductionConsistency(Sema &S, FunctionTemplateDecl *FTD, UnsignedOrNone ArgIdx, QualType P, QualType A, ArrayRef< TemplateArgument > DeducedArgs, bool CheckConsistency)
static PartialOrderingKind degradeCallPartialOrderingKind(PartialOrderingKind POK)
When propagating a partial ordering kind into a NonCall context, this is used to downgrade a 'Call' i...
static MoreSpecializedTrailingPackTieBreakerResult getMoreSpecializedTrailingPackTieBreaker(const TemplateSpecializationType *TST1, const TemplateSpecializationType *TST2)
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 const Expr * unwrapExpressionForDeduction(const Expr *E)
static bool isSameDeclaration(Decl *X, Decl *Y)
Determine whether two declaration pointers refer to the same declaration.
static NonTypeOrVarTemplateParmDecl getDeducedNTTParameterFromExpr(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 DeduceForEachType(Sema &S, TemplateParameterList *TemplateParams, ArrayRef< QualType > Params, ArrayRef< QualType > Args, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, PartialOrderingKind POK, bool FinishingDeduction, T &&DeductFunc)
static TemplateDeductionResult DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD, TemplateParameterList *TemplateParams, QualType P, TemplateDeductionInfo &Info, bool PartialOrdering, SmallVectorImpl< DeducedTemplateArgument > &Deduced, bool *HasDeducedAnyParam)
Attempt to deduce the template arguments by checking the base types according to (C++20 [temp....
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 UnsignedOrNone 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 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 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.
PartialOrderingKind
The kind of PartialOrdering we're performing template argument deduction for (C++11 [temp....
MoreSpecializedTrailingPackTieBreakerResult
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 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 bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc, FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, TemplatePartialOrderingContext TPOC, ArrayRef< QualType > Args1, ArrayRef< QualType > Args2, bool Args1Offset)
Determine whether the function template FT1 is at least as specialized as FT2.
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...
PackFold
What directions packs are allowed to match non-packs.
static TemplateDeductionResult ConvertDeducedTemplateArguments(Sema &S, NamedDecl *Template, TemplateParameterList *TemplateParams, bool IsDeduced, SmallVectorImpl< DeducedTemplateArgument > &Deduced, TemplateDeductionInfo &Info, Sema::CheckTemplateArgumentInfo &CTAI, LocalInstantiationScope *CurrentInstantiationScope, unsigned NumAlreadyConverted, bool *IsIncomplete)
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 TemplateDeductionResult CheckDeducedArgumentConstraints(Sema &S, NamedDecl *Template, ArrayRef< TemplateArgument > SugaredDeducedArgs, ArrayRef< TemplateArgument > CanonicalDeducedArgs, TemplateDeductionInfo &Info)
static const TemplateSpecializationType * getLastTemplateSpecType(QualType QT)
Deduce the template arguments by comparing the template parameter type (which is a template-id) with ...
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 TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams, const NonTypeOrVarTemplateParmDecl NTTP, const DeducedTemplateArgument &NewDeduced, QualType ValueType, TemplateDeductionInfo &Info, bool PartialOrdering, SmallVectorImpl< DeducedTemplateArgument > &Deduced, bool *HasDeducedAnyParam)
Deduce the value of the given non-type template parameter as the given deduced template argument.
static bool IsPossiblyOpaquelyQualifiedTypeInternal(const Type *T)
static bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T)
static bool isForwardingReference(QualType Param, unsigned FirstInnerIndex)
Determine whether a type denotes a forwarding reference.
static TemplateDeductionResult FinishTemplateArgumentDeduction(Sema &S, NamedDecl *Entity, TemplateParameterList *EntityTPL, TemplateDecl *Template, bool PartialOrdering, ArrayRef< TemplateArgumentLoc > Ps, ArrayRef< TemplateArgument > As, SmallVectorImpl< DeducedTemplateArgument > &Deduced, TemplateDeductionInfo &Info, bool CopyDeducedArgs)
Complete template argument deduction.
static bool isParameterPack(Expr *PackExpression)
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::TemplateNameKind enum.
Defines the clang::TypeLoc interface and its subclasses.
Allows QualTypes to be sorted and hence used in maps and sets.
C Language Family Type Representation.
SourceLocation getLocation() const
const TemplateTemplateParmDecl * getTemplate() const
bool isExpandedParameterPack() const
const NonTypeTemplateParmDecl * getNTTP() const
unsigned getIndex() const
NonTypeOrVarTemplateParmDecl(const NamedDecl *Template)
TemplateParameter asTemplateParam() const
unsigned getDepth() const
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
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
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.
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
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
const LangOptions & getLangOpts() const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
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 getMemberPointerType(QualType T, NestedNameSpecifier Qualifier, const CXXRecordDecl *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y, bool IgnoreDeduced=false) const
Determine whether the given template names refer to the same template.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
CanQualType getCanonicalTagType(const TagDecl *TD) const
bool isSameTemplateArgument(const TemplateArgument &Arg1, const TemplateArgument &Arg2) const
Determine whether the given template arguments Arg1 and Arg2 are equivalent.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
TemplateName getDeducedTemplateName(TemplateName Underlying, DefaultArguments DefaultArgs) const
Represents a TemplateName which had some of its default arguments deduced.
const DependentSizedArrayType * getAsDependentSizedArrayType(QualType T) 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.
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.
CanQualType getCanonicalInjectedSpecializationType(const ASTContext &Ctx) const
Retrieve the canonical template specialization type of the injected-class-name for this class templat...
CanQualType getCanonicalInjectedSpecializationType(const ASTContext &Ctx) const
Retrieves the canonical injected specialization type for this partial specialization.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
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.
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.
ASTContext & getASTContext() const LLVM_READONLY
bool isInvalidDecl() const
SourceLocation getLocation() const
DeclContext * getDeclContext()
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
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...
SourceLocation getElaboratedKeywordLoc() const
NestedNameSpecifierLoc getQualifierLoc() const
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 vector type where either the type or size is dependent.
virtual bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc)
virtual bool TraverseTemplateName(TemplateName Template)
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.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Expr * IgnoreImplicitAsWritten() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
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.
bool hasCXXExplicitFunctionObjectParameter() const
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...
void getAssociatedConstraints(SmallVectorImpl< AssociatedConstraint > &ACs) const
Get the associated-constraints of this function declaration.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
bool isImmediateEscalating() const
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
size_t param_size() const
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.
Qualifiers getMethodQuals() const
QualType getParamType(unsigned i) const
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
bool isVariadic() const
Whether this function prototype is variadic.
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
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
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)
Describes an C or C++ initializer list.
unsigned getNumInits() const
unsigned getNumInitsWithEmbedExpanded() const
getNumInits but if the list has an EmbedExpr inside includes full length of embedded data.
ArrayRef< Expr * > inits()
An lvalue reference type, per C++11 [dcl.ref].
A stack-allocated class that identifies which local variable declaration instantiations are present i...
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
void ResetPartiallySubstitutedPack()
Reset the partially-substituted pack when it is no longer of interest.
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.
NestedNameSpecifier getQualifier() const
QualType getPointeeType() 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.
void addOuterRetainedLevels(unsigned Num)
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
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>::".
const Type * getAsType() const
@ Type
A type, stored as a Type*.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a pointer to an Objective C object.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
bool isVarDeclReference() const
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
TemplateTemplateParmDecl * getTemplateTemplateDecl() const
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments into the given structure.
bool isConceptReference() const
decls_iterator decls_end() const
ArrayRef< TemplateArgumentLoc > template_arguments() const
Represents a C++11 pack expansion that produces a sequence of expressions.
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.
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 compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const
Determines if these qualifiers compatibly include another set.
bool hasAddressSpace() const
void removeAddressSpace()
bool hasObjCGCAttr() const
void setCVRQualifiers(unsigned mask)
bool hasObjCLifetime() const
ObjCLifetime getObjCLifetime() const
Qualifiers withoutObjCLifetime() const
LangAS getAddressSpace() const
void setObjCLifetime(ObjCLifetime type)
An rvalue reference type, per C++11 [dcl.ref].
ArrayRef< TemplateArgument > getInjectedTemplateArgs(const ASTContext &Context) const
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 TryFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy) const
Same as IsFunctionConversion, but if this would return true, it sets ResultTy to ToType.
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.
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
const ExpressionEvaluationContextRecord & currentEvaluationContext() const
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...
TemplateDeductionResult FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl< DeducedTemplateArgument > &Deduced, unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info, SmallVectorImpl< OriginalCallArg > const *OriginalCallArgs, bool PartialOverloading, bool PartialOrdering, bool ForOverloadSetAddressResolution, llvm::function_ref< bool(bool)> CheckNonDependent=[](bool) { return false;})
Finish template argument deduction for a function template, checking the deduced template arguments f...
@ 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.
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(TemplateParameterList *PParam, TemplateDecl *PArg, TemplateDecl *AArg, const DefaultArguments &DefaultArgs, SourceLocation ArgLoc, bool PartialOrdering, bool *StrictPackMatch)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)
@ TPL_TemplateParamsEquivalent
We are determining whether the template-parameters are equivalent according to C++ [temp....
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, CheckTemplateArgumentInfo &CTAI, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
bool isSameOrCompatibleFunctionType(QualType Param, QualType Arg)
Compare types for equality with respect to possibly compatible function types (noreturn adjustment,...
const LangOptions & getLangOpts() const
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< AssociatedConstraint > AssociatedConstraints, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
UnsignedOrNone 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.
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, bool ForDefaultArgumentSubstitution=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
SuppressedDiagnosticsMap SuppressedDiagnostics
bool IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived, CXXRecordDecl *Base, CXXBasePaths &Paths)
Determine whether the type Derived is a C++ class that is derived from the type Base.
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr, TemplateSpecCandidateSet *FailedTSC=nullptr, bool ForTypeDeduction=false)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
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.
bool IsFunctionConversion(QualType FromType, QualType ToType, bool *DiscardingCFIUncheckedCallee=nullptr, bool *AddingCFIUncheckedCallee=nullptr) const
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, SourceLocation TemplateKWLoc, SourceLocation TemplateNameLoc, 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...
TypeSourceInfo * SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto)
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),...
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.
bool IsAtLeastAsConstrained(const NamedDecl *D1, MutableArrayRef< AssociatedConstraint > AC1, const NamedDecl *D2, MutableArrayRef< AssociatedConstraint > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
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)
bool CheckFunctionTemplateConstraints(SourceLocation PointOfInstantiation, FunctionDecl *Decl, ArrayRef< TemplateArgument > TemplateArgs, ConstraintSatisfaction &Satisfaction)
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.
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, const DefaultArguments &DefaultArgs, bool PartialTemplateArgs, CheckTemplateArgumentInfo &CTAI, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr)
Check that the given template arguments can be provided to the given template, converting the argumen...
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.
@ 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.
FunctionTemplateDecl * getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, QualType RawObj1Ty={}, QualType RawObj2Ty={}, bool Reversed=false, bool PartialOverloading=false)
Returns the more specialized function template according to the rules of function template partial or...
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.
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.
const TemplateArgument * pack_iterator
Iterator that traverses the elements 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.).
void getAssociatedConstraints(llvm::SmallVectorImpl< AssociatedConstraint > &AC) const
Get the total constraint-expression associated with this template, including constraint-expressions d...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) 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.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
ArrayRef< TemplateArgument > getInjectedTemplateArgs(const ASTContext &Context)
Get the template argument list of the template parameter list.
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
ArrayRef< NamedDecl * > asArray()
SourceLocation getTemplateLoc() const
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...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
TemplateNameKind templateParameterKind() const
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.
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
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, UnsignedOrNone NumExpanded=std::nullopt)
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.
const TemplateSpecializationType * getAsNonAliasTemplateSpecializationType() const
Look through sugar for an instance of TemplateSpecializationType which is not a type alias,...
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
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
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 isMemberFunctionPointerType() const
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
bool isAnyPointerType() const
TypeClass getTypeClass() const
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.
VarTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
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.
void setStrictPackMatch()
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.
bool hasStrictPackMatch() const
__inline void unsigned int _2
The JSON file list parser is used to communicate input to InstallAPI.
@ OO_None
Not an overloaded operator.
@ Match
This is not an overload because the signature exactly matches an existing declaration.
bool isa(CodeGen::Address addr)
bool isTargetAddressSpace(LangAS AS)
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
@ Both
Look for allocation functions in both the global scope and in the scope of the allocated class.
@ RQ_None
No ref-qualifier was provided.
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
NamedDecl * getAsNamedDecl(TemplateParameter P)
bool isPackProducingBuiltinTemplateName(TemplateName N)
UnsignedOrNone getExpandedPackSize(const NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
unsigned toTargetAddressSpace(LangAS AS)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
std::pair< unsigned, unsigned > getDepthAndIndex(const NamedDecl *ND)
Retrieve the depth and index of a template parameter.
const FunctionProtoType * T
@ Template
We are parsing a template declaration.
ActionResult< CXXBaseSpecifier * > BaseResult
@ FunctionTemplate
The name was classified as a function template name.
@ Concept
The name was classified as a concept name.
bool isLambdaConversionOperator(CXXConversionDecl *C)
@ TNK_Var_template
The name refers to a variable template whose specialization produces a variable.
@ TNK_Concept_template
The name refers to a concept.
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
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.
DynamicRecursiveASTVisitorBase< false > DynamicRecursiveASTVisitor
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.
@ CUDATargetMismatch
CUDA Target attributes do not match.
@ 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.
U cast(CodeGen::Address addr)
@ Noexcept
Condition in a noexcept(bool) specifier.
@ None
No keyword precedes the qualified type name.
ActionResult< Expr * > ExprResult
@ 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...
static constexpr bool value
static constexpr bool value
static constexpr bool value
A pack that we're currently deducing.
DeducedPack(unsigned Index)
SmallVector< DeducedTemplateArgument, 4 > New
DeducedTemplateArgument Saved
DeducedTemplateArgument DeferredDeduction
ExceptionSpecificationType Type
The kind of exception specification this is.
Extra information about a function prototype.
const ExtParameterInfo * ExtParameterInfos
bool HasFormOfMemberPointer
OverloadExpr * Expression
bool StrictPackMatch
Is set to true when, in the context of TTP matching, a pack parameter matches non-pack arguments.
bool MatchingTTP
If true, assume these template arguments are the injected template arguments for a template template ...
bool PartialOrdering
The check is being performed in the context of partial ordering.
SmallVector< TemplateArgument, 4 > SugaredConverted
The checked, converted argument will be added to the end of these vectors.
SmallVector< TemplateArgument, 4 > CanonicalConverted
@ 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.