38#include "llvm/ADT/DenseSet.h"
39#include "llvm/ADT/STLExtras.h"
40#include "llvm/ADT/STLForwardCompat.h"
41#include "llvm/ADT/ScopeExit.h"
42#include "llvm/ADT/SmallPtrSet.h"
43#include "llvm/ADT/SmallVector.h"
57 return P->hasAttr<PassObjectSizeAttr>();
78 if (HadMultipleCandidates)
89 CK_FunctionToPointerDecay);
93 bool InOverloadResolution,
96 bool AllowObjCWritebackConversion);
100 bool InOverloadResolution,
108 bool AllowObjCConversionOnExplicit);
169 return Rank[(int)Kind];
194 static const char *
const Name[] = {
198 "Function-to-pointer",
199 "Function pointer conversion",
201 "Integral promotion",
202 "Floating point promotion",
204 "Integral conversion",
205 "Floating conversion",
206 "Complex conversion",
207 "Floating-integral conversion",
208 "Pointer conversion",
209 "Pointer-to-member conversion",
210 "Boolean conversion",
211 "Compatible-types conversion",
212 "Derived-to-base conversion",
214 "SVE Vector conversion",
215 "RVV Vector conversion",
217 "Complex-real conversion",
218 "Block Pointer conversion",
219 "Transparent Union Conversion",
220 "Writeback conversion",
221 "OpenCL Zero Event Conversion",
222 "OpenCL Zero Queue Conversion",
223 "C specific type conversion",
224 "Incompatible pointer conversion",
225 "Fixed point conversion",
226 "HLSL vector truncation",
227 "Non-decaying array conversion",
304 FromType = Context.getArrayDecayedType(FromType);
316 const Expr *Converted) {
319 if (
auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
326 while (
auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
327 switch (ICE->getCastKind()) {
329 case CK_IntegralCast:
330 case CK_IntegralToBoolean:
331 case CK_IntegralToFloating:
332 case CK_BooleanToSignedIntegral:
333 case CK_FloatingToIntegral:
334 case CK_FloatingToBoolean:
335 case CK_FloatingCast:
336 Converted = ICE->getSubExpr();
360 QualType &ConstantType,
bool IgnoreFloatToIntegralConversion)
const {
362 "narrowing check outside C++");
373 ToType = ED->getIntegerType();
379 goto FloatingIntegralConversion;
381 goto IntegralConversion;
392 FloatingIntegralConversion:
397 if (IgnoreFloatToIntegralConversion)
400 assert(
Initializer &&
"Unknown conversion expression");
406 if (std::optional<llvm::APSInt> IntConstantValue =
410 Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
411 llvm::APFloat::rmNearestTiesToEven);
413 llvm::APSInt ConvertedValue = *IntConstantValue;
415 llvm::APFloat::opStatus Status =
Result.convertToInteger(
416 ConvertedValue, llvm::APFloat::rmTowardZero, &ignored);
419 if (Status == llvm::APFloat::opInvalidOp ||
420 *IntConstantValue != ConvertedValue) {
421 ConstantValue =
APValue(*IntConstantValue);
448 Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
451 ConstantValue = R.
Val;
452 assert(ConstantValue.
isFloat());
453 llvm::APFloat FloatVal = ConstantValue.
getFloat();
456 llvm::APFloat Converted = FloatVal;
457 llvm::APFloat::opStatus ConvertStatus =
459 llvm::APFloat::rmNearestTiesToEven, &ignored);
461 llvm::APFloat::rmNearestTiesToEven, &ignored);
463 if (FloatVal.isNaN() && Converted.isNaN() &&
464 !FloatVal.isSignaling() && !Converted.isSignaling()) {
470 if (!Converted.bitwiseIsEqual(FloatVal)) {
477 if (ConvertStatus & llvm::APFloat::opOverflow) {
499 IntegralConversion: {
507 constexpr auto CanRepresentAll = [](
bool FromSigned,
unsigned FromWidth,
508 bool ToSigned,
unsigned ToWidth) {
509 return (FromWidth < ToWidth + (FromSigned == ToSigned)) &&
510 !(FromSigned && !ToSigned);
513 if (CanRepresentAll(FromSigned, FromWidth, ToSigned, ToWidth))
519 bool DependentBitField =
false;
521 if (BitField->getBitWidth()->isValueDependent())
522 DependentBitField =
true;
523 else if (
unsigned BitFieldWidth = BitField->getBitWidthValue();
524 BitFieldWidth < FromWidth) {
525 if (CanRepresentAll(FromSigned, BitFieldWidth, ToSigned, ToWidth))
529 FromWidth = BitFieldWidth;
537 std::optional<llvm::APSInt> OptInitializerValue =
539 if (!OptInitializerValue) {
543 if (DependentBitField && !(FromSigned && !ToSigned))
549 llvm::APSInt &InitializerValue = *OptInitializerValue;
550 bool Narrowing =
false;
551 if (FromWidth < ToWidth) {
554 if (InitializerValue.isSigned() && InitializerValue.isNegative())
560 InitializerValue.extend(InitializerValue.getBitWidth() + 1);
562 llvm::APSInt ConvertedValue = InitializerValue;
563 ConvertedValue = ConvertedValue.trunc(ToWidth);
564 ConvertedValue.setIsSigned(ToSigned);
565 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
566 ConvertedValue.setIsSigned(InitializerValue.isSigned());
568 if (ConvertedValue != InitializerValue)
573 ConstantValue =
APValue(InitializerValue);
589 ConstantValue = R.
Val;
590 assert(ConstantValue.
isFloat());
591 llvm::APFloat FloatVal = ConstantValue.
getFloat();
596 if (FloatVal.isNaN() && FloatVal.isSignaling()) {
612 raw_ostream &OS = llvm::errs();
613 bool PrintedSomething =
false;
616 PrintedSomething =
true;
620 if (PrintedSomething) {
626 OS <<
" (by copy constructor)";
628 OS <<
" (direct reference binding)";
630 OS <<
" (reference binding)";
632 PrintedSomething =
true;
636 if (PrintedSomething) {
640 PrintedSomething =
true;
643 if (!PrintedSomething) {
644 OS <<
"No conversions required";
651 raw_ostream &OS = llvm::errs();
659 OS <<
"aggregate initialization";
669 raw_ostream &OS = llvm::errs();
671 OS <<
"Worst list element conversion: ";
672 switch (ConversionKind) {
674 OS <<
"Standard conversion: ";
678 OS <<
"User-defined conversion: ";
682 OS <<
"Ellipsis conversion";
685 OS <<
"Ambiguous conversion";
688 OS <<
"Bad conversion";
713 struct DFIArguments {
719 struct DFIParamWithArguments : DFIArguments {
724 struct DFIDeducedMismatchArgs : DFIArguments {
725 TemplateArgumentList *TemplateArgs;
726 unsigned CallArgIndex;
731 TemplateArgumentList *TemplateArgs;
732 ConstraintSatisfaction Satisfaction;
743 Result.Result =
static_cast<unsigned>(TDK);
744 Result.HasDiagnostic =
false;
763 auto *Saved =
new (Context) DFIDeducedMismatchArgs;
774 DFIArguments *Saved =
new (Context) DFIArguments;
786 DFIParamWithArguments *Saved =
new (Context) DFIParamWithArguments;
787 Saved->Param = Info.
Param;
800 Result.HasDiagnostic =
true;
805 CNSInfo *Saved =
new (Context) CNSInfo;
815 llvm_unreachable(
"not a deduction failure");
848 Diag->~PartialDiagnosticAt();
855 static_cast<CNSInfo *
>(
Data)->Satisfaction.~ConstraintSatisfaction();
858 Diag->~PartialDiagnosticAt();
894 return TemplateParameter::getFromOpaqueValue(
Data);
899 return static_cast<DFIParamWithArguments*
>(
Data)->Param;
929 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->TemplateArgs;
935 return static_cast<CNSInfo*
>(
Data)->TemplateArgs;
967 return &
static_cast<DFIArguments*
>(
Data)->FirstArg;
999 return &
static_cast<DFIArguments*
>(
Data)->SecondArg;
1014 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->CallArgIndex;
1017 return std::nullopt;
1030 for (
unsigned I = 0; I <
X->getNumParams(); ++I)
1034 if (
auto *FTX =
X->getDescribedFunctionTemplate()) {
1039 FTY->getTemplateParameters()))
1048 OverloadedOperatorKind::OO_EqualEqual);
1060 OverloadedOperatorKind::OO_ExclaimEqual);
1078 auto *NotEqFD = Op->getAsFunction();
1079 if (
auto *UD = dyn_cast<UsingShadowDecl>(Op))
1080 NotEqFD = UD->getUnderlyingDecl()->getAsFunction();
1093 return Op == OO_EqualEqual || Op == OO_Spaceship;
1101 if (Op == OverloadedOperatorKind::OO_EqualEqual) {
1102 assert(OriginalArgs.size() == 2);
1104 S,
OpLoc, OriginalArgs[1], FD))
1115void OverloadCandidateSet::destroyCandidates() {
1116 for (
iterator i = Candidates.begin(), e = Candidates.end(); i != e; ++i) {
1117 for (
auto &
C : i->Conversions)
1118 C.~ImplicitConversionSequence();
1120 i->DeductionFailure.Destroy();
1125 destroyCandidates();
1126 SlabAllocator.Reset();
1127 NumInlineBytesUsed = 0;
1131 FirstDeferredCandidate =
nullptr;
1132 DeferredCandidatesCount = 0;
1133 HasDeferredTemplateConstructors =
false;
1134 ResolutionByPerfectCandidateIsDisabled =
false;
1138 class UnbridgedCastsSet {
1148 Entry entry = { &E, E };
1149 Entries.push_back(entry);
1154 for (SmallVectorImpl<Entry>::iterator
1155 i = Entries.begin(), e = Entries.end(); i != e; ++i)
1156 *i->Addr = i->Saved;
1170 UnbridgedCastsSet *unbridgedCasts =
nullptr) {
1174 if (placeholder->getKind() == BuiltinType::Overload)
return false;
1178 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
1180 unbridgedCasts->save(S, E);
1200 UnbridgedCastsSet &unbridged) {
1201 for (
unsigned i = 0, e = Args.size(); i != e; ++i)
1210 bool NewIsUsingDecl) {
1215 bool OldIsUsingDecl =
false;
1217 OldIsUsingDecl =
true;
1221 if (NewIsUsingDecl)
continue;
1228 if ((OldIsUsingDecl || NewIsUsingDecl) && !
isVisible(*I))
1236 bool UseMemberUsingDeclRules =
1237 (OldIsUsingDecl || NewIsUsingDecl) &&
CurContext->isRecord() &&
1238 !
New->getFriendObjectKind();
1242 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
1248 !shouldLinkPossiblyHiddenDecl(*I,
New))
1267 }
else if (
auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1274 if (UUD->getQualifier().isDependent() && !UUD->isCXXClassMember()) {
1302 if (
New->getFriendObjectKind() &&
New->getQualifier() &&
1303 !
New->getDescribedFunctionTemplate() &&
1304 !
New->getDependentSpecializationInfo() &&
1305 !
New->getType()->isDependentType()) {
1310 New->setInvalidDecl();
1322 assert(D &&
"function decl should not be null");
1323 if (
auto *A = D->
getAttr<AttrT>())
1324 return !A->isImplicit();
1330 bool UseMemberUsingDeclRules,
1331 bool ConsiderCudaAttrs,
1332 bool UseOverrideRules =
false) {
1338 if (
New->isMSVCRTEntryPoint())
1349 if ((OldTemplate ==
nullptr) != (NewTemplate ==
nullptr))
1372 if (OldQType != NewQType && OldType->isVariadic() != NewType->isVariadic())
1376 if ((
New->isMemberLikeConstrainedFriend() ||
1387 OldDecl = OldTemplate;
1388 NewDecl = NewTemplate;
1406 bool ConstraintsInTemplateHead =
1417 if (UseMemberUsingDeclRules && ConstraintsInTemplateHead &&
1418 !SameTemplateParameterList)
1420 if (!UseMemberUsingDeclRules &&
1421 (!SameTemplateParameterList || !SameReturnType))
1425 const auto *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1426 const auto *NewMethod = dyn_cast<CXXMethodDecl>(
New);
1428 int OldParamsOffset = 0;
1429 int NewParamsOffset = 0;
1437 if (ThisType.isConstQualified())
1457 BS.
Quals = NormalizeQualifiers(OldMethod, BS.
Quals);
1458 DS.Quals = NormalizeQualifiers(NewMethod, DS.Quals);
1460 if (OldMethod->isExplicitObjectMemberFunction()) {
1462 DS.Quals.removeVolatile();
1465 return BS.
Quals == DS.Quals;
1469 auto BS =
Base.getNonReferenceType().getCanonicalType().split();
1470 auto DS = D.getNonReferenceType().getCanonicalType().split();
1472 if (!AreQualifiersEqual(BS, DS))
1475 if (OldMethod->isImplicitObjectMemberFunction() &&
1476 OldMethod->getParent() != NewMethod->getParent()) {
1488 if (
Base->isLValueReferenceType())
1489 return D->isLValueReferenceType();
1490 return Base->isRValueReferenceType() == D->isRValueReferenceType();
1495 auto DiagnoseInconsistentRefQualifiers = [&]() {
1496 if (SemaRef.
LangOpts.CPlusPlus23 && !UseOverrideRules)
1498 if (OldMethod->getRefQualifier() == NewMethod->getRefQualifier())
1500 if (OldMethod->isExplicitObjectMemberFunction() ||
1501 NewMethod->isExplicitObjectMemberFunction())
1503 if (!UseMemberUsingDeclRules && (OldMethod->getRefQualifier() ==
RQ_None ||
1504 NewMethod->getRefQualifier() ==
RQ_None)) {
1505 SemaRef.
Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1506 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1507 SemaRef.
Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1513 if (OldMethod && OldMethod->isExplicitObjectMemberFunction())
1515 if (NewMethod && NewMethod->isExplicitObjectMemberFunction())
1518 if (OldType->getNumParams() - OldParamsOffset !=
1519 NewType->getNumParams() - NewParamsOffset ||
1521 {OldType->param_type_begin() + OldParamsOffset,
1522 OldType->param_type_end()},
1523 {NewType->param_type_begin() + NewParamsOffset,
1524 NewType->param_type_end()},
1529 if (OldMethod && NewMethod && !OldMethod->isStatic() &&
1530 !NewMethod->isStatic()) {
1531 bool HaveCorrespondingObjectParameters = [&](
const CXXMethodDecl *Old,
1533 auto NewObjectType =
New->getFunctionObjectParameterReferenceType();
1537 return F->getRefQualifier() ==
RQ_None &&
1538 !F->isExplicitObjectMemberFunction();
1541 if (IsImplicitWithNoRefQual(Old) != IsImplicitWithNoRefQual(
New) &&
1542 CompareType(OldObjectType.getNonReferenceType(),
1543 NewObjectType.getNonReferenceType()))
1545 return CompareType(OldObjectType, NewObjectType);
1546 }(OldMethod, NewMethod);
1548 if (!HaveCorrespondingObjectParameters) {
1549 if (DiagnoseInconsistentRefQualifiers())
1554 if (!UseOverrideRules || (!NewMethod->isExplicitObjectMemberFunction() &&
1555 !OldMethod->isExplicitObjectMemberFunction()))
1560 if (!UseOverrideRules &&
1564 if (!NewRC != !OldRC)
1574 if (NewMethod && OldMethod && OldMethod->isImplicitObjectMemberFunction() &&
1575 NewMethod->isImplicitObjectMemberFunction()) {
1576 if (DiagnoseInconsistentRefQualifiers())
1590 NewI =
New->specific_attr_begin<EnableIfAttr>(),
1591 NewE =
New->specific_attr_end<EnableIfAttr>(),
1594 NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1595 if (NewI == NewE || OldI == OldE)
1597 llvm::FoldingSetNodeID NewID, OldID;
1598 NewI->getCond()->Profile(NewID, SemaRef.
Context,
true);
1599 OldI->getCond()->Profile(OldID, SemaRef.
Context,
true);
1605 if (SemaRef.
getLangOpts().CUDA && ConsiderCudaAttrs) {
1613 "Unexpected invalid target.");
1617 if (NewTarget != OldTarget) {
1620 if (OldMethod && NewMethod && OldMethod->isVirtual() &&
1621 OldMethod->isConstexpr() && !NewMethod->isConstexpr() &&
1639 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs) {
1645 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs) {
1658 bool SuppressUserConversions,
1660 bool InOverloadResolution,
1662 bool AllowObjCWritebackConversion,
1663 bool AllowObjCConversionOnExplicit) {
1666 if (SuppressUserConversions) {
1677 Conversions, AllowExplicit,
1678 AllowObjCConversionOnExplicit)) {
1699 bool FromListInit =
false;
1700 if (
const auto *InitList = dyn_cast<InitListExpr>(From);
1701 InitList && InitList->getNumInits() == 1 &&
1703 const Expr *SingleInit = InitList->getInit(0);
1704 FromType = SingleInit->
getType();
1706 FromListInit =
true;
1715 if ((FromCanon == ToCanon ||
1727 if (ToCanon != FromCanon)
1738 Cand != Conversions.
end(); ++Cand)
1779static ImplicitConversionSequence
1781 bool SuppressUserConversions,
1783 bool InOverloadResolution,
1785 bool AllowObjCWritebackConversion,
1786 bool AllowObjCConversionOnExplicit) {
1789 ICS.
Standard, CStyle, AllowObjCWritebackConversion)){
1833 FromResType->getWrappedType()) &&
1835 FromResType->getContainedType()) &&
1836 ToResType->getAttrs() == FromResType->getAttrs()) {
1846 AllowExplicit, InOverloadResolution, CStyle,
1847 AllowObjCWritebackConversion,
1848 AllowObjCConversionOnExplicit);
1851ImplicitConversionSequence
1853 bool SuppressUserConversions,
1855 bool InOverloadResolution,
1857 bool AllowObjCWritebackConversion) {
1858 return ::TryImplicitConversion(*
this, From, ToType, SuppressUserConversions,
1859 AllowExplicit, InOverloadResolution, CStyle,
1860 AllowObjCWritebackConversion,
1866 bool AllowExplicit) {
1871 bool AllowObjCWritebackConversion =
1878 *
this, From, ToType,
1880 AllowExplicit ? AllowedExplicit::All : AllowedExplicit::None,
1882 false, AllowObjCWritebackConversion,
1903 if (
Context.hasSameUnqualifiedType(FromType, ToType))
1916 if (TyClass != CanFrom->getTypeClass())
return false;
1917 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1918 if (TyClass == Type::Pointer) {
1921 }
else if (TyClass == Type::BlockPointer) {
1924 }
else if (TyClass == Type::MemberPointer) {
1931 CanTo = ToMPT->getPointeeType();
1937 TyClass = CanTo->getTypeClass();
1938 if (TyClass != CanFrom->getTypeClass())
return false;
1939 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1949 bool Changed =
false;
1957 const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn);
1958 const auto *ToFPT = dyn_cast<FunctionProtoType>(ToFn);
1960 if (FromFPT && ToFPT) {
1961 if (FromFPT->hasCFIUncheckedCallee() && !ToFPT->hasCFIUncheckedCallee()) {
1963 FromFPT->getReturnType(), FromFPT->getParamTypes(),
1964 FromFPT->getExtProtoInfo().withCFIUncheckedCallee(
false));
1970 }
else if (!FromFPT->hasCFIUncheckedCallee() &&
1971 ToFPT->hasCFIUncheckedCallee()) {
1973 FromFPT->getReturnType(), FromFPT->getParamTypes(),
1974 FromFPT->getExtProtoInfo().withCFIUncheckedCallee(
true));
1984 if (FromFPT && ToFPT) {
1985 if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1997 bool CanUseToFPT, CanUseFromFPT;
1998 if (
Context.mergeExtParameterInfo(ToFPT, FromFPT, CanUseToFPT,
1999 CanUseFromFPT, NewParamInfos) &&
2000 CanUseToFPT && !CanUseFromFPT) {
2003 NewParamInfos.empty() ?
nullptr : NewParamInfos.data();
2005 FromFPT->getParamTypes(), ExtInfo);
2019 const auto FromFX = FromFPT->getFunctionEffects();
2020 const auto ToFX = ToFPT->getFunctionEffects();
2021 if (FromFX != ToFX) {
2025 FromFPT->getReturnType(), FromFPT->getParamTypes(), ExtInfo);
2035 assert(
QualType(FromFn, 0).isCanonical());
2036 if (
QualType(FromFn, 0) != CanTo)
return false;
2063 if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
2064 &ToSem == &llvm::APFloat::IEEEquad()) ||
2065 (&FromSem == &llvm::APFloat::IEEEquad() &&
2066 &ToSem == &llvm::APFloat::PPCDoubleDouble()))
2121 bool InOverloadResolution,
bool CStyle) {
2138 if (ToExtType && FromExtType) {
2140 unsigned ToElts = ToExtType->getNumElements();
2141 if (FromElts < ToElts)
2143 if (FromElts == ToElts)
2149 QualType ToElTy = ToExtType->getElementType();
2154 if (FromExtType && !ToExtType) {
2168 if (ToExtType->getNumElements() != FromExtType->getNumElements())
2173 FromExtType->getElementType()->isIntegerType()) {
2185 QualType ToElTy = ToExtType->getElementType();
2219 !ToType->
hasAttr(attr::ArmMveStrictPolymorphism))) {
2224 !InOverloadResolution && !CStyle) {
2226 << FromType << ToType;
2237 bool InOverloadResolution,
2238 StandardConversionSequence &SCS,
2250 bool InOverloadResolution,
2253 bool AllowObjCWritebackConversion) {
2279 FromType = Fn->getType();
2299 if (Method && !Method->isStatic() &&
2300 !Method->isExplicitObjectMemberFunction()) {
2302 "Non-unary operator on non-static member address");
2305 "Non-address-of operator on non-static member address");
2307 FromType, std::nullopt, Method->getParent());
2311 "Non-address-of operator for overloaded function expression");
2357 FromType =
Atomic->getValueType();
2392 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
2412 bool IncompatibleObjC =
false;
2467 }
else if (AllowObjCWritebackConversion &&
2471 FromType, IncompatibleObjC)) {
2477 InOverloadResolution, FromType)) {
2481 From, InOverloadResolution, CStyle)) {
2491 S, From, ToType, InOverloadResolution, SCS, CStyle)) {
2527 bool ObjCLifetimeConversion;
2533 ObjCLifetimeConversion)) {
2552 CanonFrom = CanonTo;
2565 if ((S.
getLangOpts().CPlusPlus || !InOverloadResolution))
2577 case AssignConvertType::
2578 CompatibleVoidPtrToNonVoidPtr:
2611 bool InOverloadResolution,
2619 const RecordDecl *UD = UT->getOriginalDecl()->getDefinitionOrSelf();
2620 if (!UD->
hasAttr<TransparentUnionAttr>())
2623 for (
const auto *it : UD->
fields()) {
2626 ToType = it->getType();
2652 return To->
getKind() == BuiltinType::Int;
2655 return To->
getKind() == BuiltinType::UInt;
2679 if (FromED->isScoped())
2686 if (FromED->isFixed()) {
2687 QualType Underlying = FromED->getIntegerType();
2688 return Context.hasSameUnqualifiedType(Underlying, ToType) ||
2695 return Context.hasSameUnqualifiedType(ToType, FromED->getPromotionType());
2720 uint64_t FromSize =
Context.getTypeSize(FromType);
2729 for (
int Idx = 0; Idx < 6; ++Idx) {
2730 uint64_t ToSize =
Context.getTypeSize(PromoteTypes[Idx]);
2731 if (FromSize < ToSize ||
2732 (FromSize == ToSize &&
2733 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2737 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
2758 std::optional<llvm::APSInt> BitWidth;
2761 MemberDecl->getBitWidth()->getIntegerConstantExpr(
Context))) {
2762 llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
2763 ToSize =
Context.getTypeSize(ToType);
2766 if (*BitWidth < ToSize ||
2768 return To->
getKind() == BuiltinType::Int;
2774 return To->
getKind() == BuiltinType::UInt;
2792 return Context.getTypeSize(FromType) <
Context.getTypeSize(ToType);
2802 if (FromBuiltin->getKind() == BuiltinType::Float &&
2803 ToBuiltin->getKind() == BuiltinType::Double)
2810 (FromBuiltin->getKind() == BuiltinType::Float ||
2811 FromBuiltin->getKind() == BuiltinType::Double) &&
2812 (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2813 ToBuiltin->getKind() == BuiltinType::Float128 ||
2814 ToBuiltin->getKind() == BuiltinType::Ibm128))
2819 if (
getLangOpts().
HLSL && FromBuiltin->getKind() == BuiltinType::Half &&
2820 (ToBuiltin->getKind() == BuiltinType::Float ||
2821 ToBuiltin->getKind() == BuiltinType::Double))
2826 FromBuiltin->getKind() == BuiltinType::Half &&
2827 ToBuiltin->getKind() == BuiltinType::Float)
2859 bool StripObjCLifetime =
false) {
2862 "Invalid similarly-qualified pointer type");
2873 if (StripObjCLifetime)
2885 return Context.getObjCObjectPointerType(ToPointee);
2886 return Context.getPointerType(ToPointee);
2894 return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
2895 return Context.getPointerType(QualifiedCanonToPointee);
2899 bool InOverloadResolution,
2905 return !InOverloadResolution;
2913 bool InOverloadResolution,
2915 bool &IncompatibleObjC) {
2916 IncompatibleObjC =
false;
2924 ConvertedType = ToType;
2931 ConvertedType = ToType;
2938 ConvertedType = ToType;
2946 ConvertedType = ToType;
2956 ConvertedType = ToType;
2978 if (
Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
3005 Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
3027 !
Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
3036 Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
3055 return Context.getQualifiedType(
T, Qs);
3057 return Context.getQualifiedType(
T.getUnqualifiedType(), Qs);
3062 bool &IncompatibleObjC) {
3075 if (ToObjCPtr && FromObjCPtr) {
3083 if (
Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
3097 if (
Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
3101 IncompatibleObjC =
true;
3117 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
3146 IncompatibleObjC)) {
3148 IncompatibleObjC =
true;
3149 ConvertedType =
Context.getPointerType(ConvertedType);
3158 IncompatibleObjC)) {
3160 ConvertedType =
Context.getPointerType(ConvertedType);
3173 if (FromFunctionType && ToFunctionType) {
3176 if (
Context.getCanonicalType(FromPointeeType)
3177 ==
Context.getCanonicalType(ToPointeeType))
3182 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
3183 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic() ||
3184 FromFunctionType->
getMethodQuals() != ToFunctionType->getMethodQuals())
3187 bool HasObjCConversion =
false;
3189 Context.getCanonicalType(ToFunctionType->getReturnType())) {
3192 ToFunctionType->getReturnType(),
3193 ConvertedType, IncompatibleObjC)) {
3195 HasObjCConversion =
true;
3202 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
3203 ArgIdx != NumArgs; ++ArgIdx) {
3205 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3206 if (
Context.getCanonicalType(FromArgType)
3207 ==
Context.getCanonicalType(ToArgType)) {
3210 ConvertedType, IncompatibleObjC)) {
3212 HasObjCConversion =
true;
3219 if (HasObjCConversion) {
3223 IncompatibleObjC =
true;
3255 if (!FromFunctionType || !ToFunctionType)
3258 if (
Context.hasSameType(FromPointeeType, ToPointeeType))
3263 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
3264 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic())
3269 if (FromEInfo != ToEInfo)
3272 bool IncompatibleObjC =
false;
3274 ToFunctionType->getReturnType())) {
3278 QualType LHS = ToFunctionType->getReturnType();
3283 if (
Context.hasSameType(RHS,LHS)) {
3286 ConvertedType, IncompatibleObjC)) {
3287 if (IncompatibleObjC)
3296 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
3297 ArgIdx != NumArgs; ++ArgIdx) {
3298 IncompatibleObjC =
false;
3300 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3301 if (
Context.hasSameType(FromArgType, ToArgType)) {
3304 ConvertedType, IncompatibleObjC)) {
3305 if (IncompatibleObjC)
3314 bool CanUseToFPT, CanUseFromFPT;
3315 if (!
Context.mergeExtParameterInfo(ToFunctionType, FromFunctionType,
3316 CanUseToFPT, CanUseFromFPT,
3320 ConvertedType = ToType;
3359 ToMember->getMostRecentCXXRecordDecl())) {
3361 if (ToMember->isSugared())
3363 ToMember->getMostRecentCXXRecordDecl());
3365 PDiag << ToMember->getQualifier();
3366 if (FromMember->isSugared())
3368 FromMember->getMostRecentCXXRecordDecl());
3370 PDiag << FromMember->getQualifier();
3388 !FromType->
getAs<TemplateSpecializationType>()) {
3394 if (
Context.hasSameType(FromType, ToType)) {
3403 if (!FromFunction || !ToFunction) {
3408 if (FromFunction->
getNumParams() != ToFunction->getNumParams()) {
3418 << ToFunction->getParamType(ArgPos)
3425 ToFunction->getReturnType())) {
3431 if (FromFunction->
getMethodQuals() != ToFunction->getMethodQuals()) {
3454 assert(llvm::size(Old) == llvm::size(
New) &&
3455 "Can't compare parameters of functions with different number of "
3458 for (
auto &&[Idx,
Type] : llvm::enumerate(Old)) {
3460 size_t J =
Reversed ? (llvm::size(
New) - Idx - 1) : Idx;
3465 Context.removePtrSizeAddrSpace(
Type.getUnqualifiedType());
3467 Context.removePtrSizeAddrSpace((
New.begin() + J)->getUnqualifiedType());
3469 if (!
Context.hasSameType(OldType, NewType)) {
3494 unsigned OldIgnore =
3496 unsigned NewIgnore =
3503 NewPT->param_types().slice(NewIgnore),
3510 bool IgnoreBaseAccess,
3513 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
3522 PDiag(diag::warn_impcast_bool_to_null_pointer)
3533 if (FromPointeeType->
isRecordType() && ToPointeeType->isRecordType() &&
3534 !
Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
3537 unsigned InaccessibleID = 0;
3538 unsigned AmbiguousID = 0;
3540 InaccessibleID = diag::err_upcast_to_inaccessible_base;
3541 AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
3544 FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
3546 &BasePath, IgnoreBaseAccess))
3550 Kind = CK_DerivedToBase;
3553 if (
Diagnose && !IsCStyleOrFunctionalCast &&
3554 FromPointeeType->
isFunctionType() && ToPointeeType->isVoidType()) {
3556 "this should only be possible with MSVCCompat!");
3568 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
3571 Kind = CK_BlockPointerToObjCPointerCast;
3573 Kind = CK_CPointerToObjCPointerCast;
3577 Kind = CK_AnyPointerToBlockPointerCast;
3583 Kind = CK_NullToPointer;
3590 bool InOverloadResolution,
3600 ConvertedType = ToType;
3616 ConvertedType =
Context.getMemberPointerType(
3630 if (
Context.getTargetInfo().getCXXABI().isMicrosoft()) {
3638 Kind = CK_NullToMemberPointer;
3656 PD <<
Context.getCanonicalTagType(Cls);
3666 std::swap(
Base, Derived);
3675 PD <<
int(Direction);
3683 DiagFromTo(PD) <<
QualType(VBase, 0) << OpRange;
3691 ? CK_DerivedToBaseMemberPointer
3692 : CK_BaseToDerivedMemberPointer;
3694 if (!IgnoreBaseAccess)
3698 ? diag::err_upcast_to_inaccessible_base
3699 : diag::err_downcast_from_inaccessible_base,
3701 NestedNameSpecifier BaseQual = FromPtrType->getQualifier(),
3702 DerivedQual = ToPtrType->getQualifier();
3703 if (Direction == MemberPointerConversionDirection::Upcast)
3704 std::swap(BaseQual, DerivedQual);
3705 DiagCls(PD, DerivedQual, Derived);
3706 DiagCls(PD, BaseQual, Base);
3741 bool CStyle,
bool IsTopLevel,
3742 bool &PreviousToQualsIncludeConst,
3743 bool &ObjCLifetimeConversion,
3756 ObjCLifetimeConversion =
true;
3796 !PreviousToQualsIncludeConst)
3814 PreviousToQualsIncludeConst =
3815 PreviousToQualsIncludeConst && ToQuals.
hasConst();
3821 bool CStyle,
bool &ObjCLifetimeConversion) {
3822 FromType =
Context.getCanonicalType(FromType);
3823 ToType =
Context.getCanonicalType(ToType);
3824 ObjCLifetimeConversion =
false;
3834 bool PreviousToQualsIncludeConst =
true;
3835 bool UnwrappedAnyPointer =
false;
3836 while (
Context.UnwrapSimilarTypes(FromType, ToType)) {
3838 !UnwrappedAnyPointer,
3839 PreviousToQualsIncludeConst,
3842 UnwrappedAnyPointer =
true;
3850 return UnwrappedAnyPointer &&
Context.hasSameUnqualifiedType(FromType,ToType);
3859 bool InOverloadResolution,
3868 InOverloadResolution, InnerSCS,
3885 if (CtorType->getNumParams() > 0) {
3886 QualType FirstArg = CtorType->getParamType(0);
3898 bool AllowExplicit) {
3905 bool Usable = !Info.Constructor->isInvalidDecl() &&
3908 bool SuppressUserConversions =
false;
3909 if (Info.ConstructorTmpl)
3912 CandidateSet, SuppressUserConversions,
3917 CandidateSet, SuppressUserConversions,
3918 false, AllowExplicit);
3922 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3925 switch (
auto Result =
3949 llvm_unreachable(
"Invalid OverloadResult!");
3971 bool AllowObjCConversionOnExplicit) {
3972 assert(AllowExplicit != AllowedExplicit::None ||
3973 !AllowObjCConversionOnExplicit);
3977 bool ConstructorsOnly =
false;
3981 if (
const RecordType *ToRecordType = ToType->
getAsCanonical<RecordType>()) {
3993 ConstructorsOnly =
true;
3997 }
else if (
auto *ToRecordDecl =
3998 dyn_cast<CXXRecordDecl>(ToRecordType->getOriginalDecl())) {
3999 ToRecordDecl = ToRecordDecl->getDefinitionOrSelf();
4001 Expr **Args = &From;
4002 unsigned NumArgs = 1;
4003 bool ListInitializing =
false;
4004 if (
InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
4007 S, From, ToType, ToRecordDecl, User, CandidateSet,
4008 AllowExplicit == AllowedExplicit::All);
4017 Args = InitList->getInits();
4018 NumArgs = InitList->getNumInits();
4019 ListInitializing =
true;
4027 bool Usable = !Info.Constructor->isInvalidDecl();
4028 if (!ListInitializing)
4029 Usable = Usable && Info.Constructor->isConvertingConstructor(
4032 bool SuppressUserConversions = !ConstructorsOnly;
4040 if (SuppressUserConversions && ListInitializing) {
4041 SuppressUserConversions =
4046 if (Info.ConstructorTmpl)
4048 Info.ConstructorTmpl, Info.FoundDecl,
4050 CandidateSet, SuppressUserConversions,
4052 AllowExplicit == AllowedExplicit::All);
4058 SuppressUserConversions,
4060 AllowExplicit == AllowedExplicit::All);
4070 }
else if (
const RecordType *FromRecordType =
4072 if (
auto *FromRecordDecl =
4073 dyn_cast<CXXRecordDecl>(FromRecordType->getOriginalDecl())) {
4074 FromRecordDecl = FromRecordDecl->getDefinitionOrSelf();
4076 const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
4077 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4086 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
4093 ConvTemplate, FoundDecl, ActingContext, From, ToType,
4094 CandidateSet, AllowObjCConversionOnExplicit,
4095 AllowExplicit != AllowedExplicit::None);
4098 CandidateSet, AllowObjCConversionOnExplicit,
4099 AllowExplicit != AllowedExplicit::None);
4104 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4107 switch (
auto Result =
4113 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
4125 if (Best->Conversions[0].isEllipsis())
4128 User.
Before = Best->Conversions[0].Standard;
4141 = dyn_cast<CXXConversionDecl>(Best->Function)) {
4143 assert(Best->HasFinalConversion);
4151 User.
Before = Best->Conversions[0].Standard;
4166 User.
After = Best->FinalConversion;
4169 llvm_unreachable(
"Not a constructor or conversion function?");
4178 llvm_unreachable(
"Invalid OverloadResult!");
4188 CandidateSet, AllowedExplicit::None,
false);
4203 diag::err_typecheck_nonviable_condition_incomplete,
4210 *
this, From, Cands);
4236 if (!Conv1 || !Conv2)
4251 if (Block1 != Block2)
4264 if (Conv1FuncRet && Conv2FuncRet &&
4273 CallOp->getType()->castAs<
FunctionType>()->getCallConv();
4275 CallOpProto->isVariadic(),
false);
4277 CallOpProto->isVariadic(),
true);
4279 CallingConv PrefOrder[] = {DefaultFree, DefaultMember, CallOpCC};
4374 if (!ICS1.
isBad()) {
4375 bool StdInit1 =
false, StdInit2 =
false;
4382 if (StdInit1 != StdInit2)
4393 CAT2->getElementType())) {
4395 if (CAT1->getSize() != CAT2->getSize())
4397 return CAT1->getSize().ult(CAT2->getSize())
4525 if (!
Enum->isFixed())
4561 else if (Rank2 < Rank1)
4596 bool SCS1ConvertsToVoid
4598 bool SCS2ConvertsToVoid
4600 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
4605 }
else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
4611 }
else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
4640 if (FromObjCPtr1 && FromObjCPtr2) {
4645 if (AssignLeft != AssignRight) {
4680 if (UnqualT1 == UnqualT2) {
4742 if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
4743 return SCS1IsCompatibleVectorConversion
4750 bool SCS1IsCompatibleSVEVectorConversion =
4752 bool SCS2IsCompatibleSVEVectorConversion =
4755 if (SCS1IsCompatibleSVEVectorConversion !=
4756 SCS2IsCompatibleSVEVectorConversion)
4757 return SCS1IsCompatibleSVEVectorConversion
4764 bool SCS1IsCompatibleRVVVectorConversion =
4766 bool SCS2IsCompatibleRVVVectorConversion =
4769 if (SCS1IsCompatibleRVVVectorConversion !=
4770 SCS2IsCompatibleRVVVectorConversion)
4771 return SCS1IsCompatibleRVVVectorConversion
4811 if (UnqualT1 == UnqualT2)
4829 bool ObjCLifetimeConversion;
4839 if (CanPick1 != CanPick2)
4893 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4901 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4918 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4925 bool FromAssignRight
4934 if (ToPtr1->isObjCIdType() &&
4935 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4937 if (ToPtr2->isObjCIdType() &&
4938 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4943 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4945 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4950 if (ToPtr1->isObjCClassType() &&
4951 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4953 if (ToPtr2->isObjCClassType() &&
4954 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4959 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4961 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4967 (ToAssignLeft != ToAssignRight)) {
4978 }
else if (IsSecondSame)
4987 (FromAssignLeft != FromAssignRight))
5001 CXXRecordDecl *FromPointee1 = FromMemPointer1->getMostRecentCXXRecordDecl();
5006 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
5013 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
5051 if (!
T.getQualifiers().hasUnaligned())
5065 "T1 must be the pointee type of the reference type");
5066 assert(!OrigT2->
isReferenceType() &&
"T2 cannot be a reference type");
5089 if (UnqualT1 == UnqualT2) {
5093 Conv |= ReferenceConversions::DerivedToBase;
5096 Context.canBindObjCObjectType(UnqualT1, UnqualT2))
5097 Conv |= ReferenceConversions::ObjC;
5100 Conv |= ReferenceConversions::Function;
5104 bool ConvertedReferent = Conv != 0;
5108 bool PreviousToQualsIncludeConst =
true;
5109 bool TopLevel =
true;
5115 Conv |= ReferenceConversions::Qualification;
5121 Conv |= ReferenceConversions::NestedQualification;
5129 bool ObjCLifetimeConversion =
false;
5131 PreviousToQualsIncludeConst,
5133 return (ConvertedReferent ||
Context.hasSimilarType(T1, T2))
5138 if (ObjCLifetimeConversion)
5139 Conv |= ReferenceConversions::ObjCLifetime;
5142 }
while (
Context.UnwrapSimilarTypes(T1, T2));
5147 return (ConvertedReferent ||
Context.hasSameUnqualifiedType(T1, T2))
5158 bool AllowExplicit) {
5159 assert(T2->
isRecordType() &&
"Can only find conversions of record types.");
5163 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
5164 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5171 = dyn_cast<FunctionTemplateDecl>(D);
5188 if (!ConvTemplate &&
5212 ConvTemplate, I.getPair(), ActingDC,
Init, DeclType, CandidateSet,
5213 false, AllowExplicit);
5216 Conv, I.getPair(), ActingDC,
Init, DeclType, CandidateSet,
5217 false, AllowExplicit);
5220 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5226 assert(Best->HasFinalConversion);
5238 if (!Best->FinalConversion.DirectBinding)
5250 "Expected a direct reference binding!");
5256 Cand != CandidateSet.
end(); ++Cand)
5268 llvm_unreachable(
"Invalid OverloadResult!");
5273static ImplicitConversionSequence
5276 bool SuppressUserConversions,
5277 bool AllowExplicit) {
5278 assert(DeclType->
isReferenceType() &&
"Reference init needs a reference");
5305 auto SetAsReferenceBinding = [&](
bool BindsDirectly) {
5310 ICS.
Standard.
Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
5312 : (RefConv & Sema::ReferenceConversions::ObjC)
5320 Sema::ReferenceConversions::NestedQualification)
5334 (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
5358 SetAsReferenceBinding(
true);
5407 SetAsReferenceBinding(S.
getLangOpts().CPlusPlus11 ||
5498 AllowedExplicit::None,
5523 if (isRValRef && LValRefType) {
5540static ImplicitConversionSequence
5542 bool SuppressUserConversions,
5543 bool InOverloadResolution,
5544 bool AllowObjCWritebackConversion,
5545 bool AllowExplicit =
false);
5549static ImplicitConversionSequence
5551 bool SuppressUserConversions,
5552 bool InOverloadResolution,
5553 bool AllowObjCWritebackConversion) {
5566 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
5568 InitTy = IAT->getElementType();
5594 if (From->
getNumInits() == 1 && !IsDesignatedInit) {
5600 SuppressUserConversions,
5601 InOverloadResolution,
5602 AllowObjCWritebackConversion);
5610 Result.setStandard();
5611 Result.Standard.setAsIdentityConversion();
5612 Result.Standard.setFromType(ToType);
5613 Result.Standard.setAllToTypes(ToType);
5638 bool IsUnbounded =
false;
5642 if (CT->getSize().ult(e)) {
5646 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5649 if (CT->getSize().ugt(e)) {
5655 S, &EmptyList, InitTy, SuppressUserConversions,
5656 InOverloadResolution, AllowObjCWritebackConversion);
5657 if (DfltElt.
isBad()) {
5661 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5672 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5681 Result.setStandard();
5682 Result.Standard.setAsIdentityConversion();
5683 Result.Standard.setFromType(InitTy);
5684 Result.Standard.setAllToTypes(InitTy);
5685 for (
unsigned i = 0; i < e; ++i) {
5688 S,
Init, InitTy, SuppressUserConversions, InOverloadResolution,
5689 AllowObjCWritebackConversion);
5699 if (Result.isBad()) {
5700 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5710 S, From->
getEndLoc(), DfltElt, Result) ==
5728 AllowedExplicit::None,
5729 InOverloadResolution,
false,
5730 AllowObjCWritebackConversion,
5748 Result.setUserDefined();
5749 Result.UserDefined.Before.setAsIdentityConversion();
5751 Result.UserDefined.Before.setFromType(
QualType());
5752 Result.UserDefined.Before.setAllToTypes(
QualType());
5754 Result.UserDefined.After.setAsIdentityConversion();
5755 Result.UserDefined.After.setFromType(ToType);
5756 Result.UserDefined.After.setAllToTypes(ToType);
5757 Result.UserDefined.ConversionFunction =
nullptr;
5774 if (From->
getNumInits() == 1 && !IsDesignatedInit) {
5795 SuppressUserConversions,
5803 InOverloadResolution,
5804 AllowObjCWritebackConversion);
5805 if (Result.isFailure())
5807 assert(!Result.isEllipsis() &&
5808 "Sub-initialization cannot result in ellipsis conversion.");
5814 Result.UserDefined.After;
5842 S, From->
getInit(0), ToType, SuppressUserConversions,
5843 InOverloadResolution, AllowObjCWritebackConversion);
5844 if (Result.isStandard())
5845 Result.Standard.FromBracedInitList =
true;
5849 else if (NumInits == 0) {
5850 Result.setStandard();
5851 Result.Standard.setAsIdentityConversion();
5852 Result.Standard.setFromType(ToType);
5853 Result.Standard.setAllToTypes(ToType);
5870static ImplicitConversionSequence
5872 bool SuppressUserConversions,
5873 bool InOverloadResolution,
5874 bool AllowObjCWritebackConversion,
5875 bool AllowExplicit) {
5876 if (
InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
5878 InOverloadResolution,AllowObjCWritebackConversion);
5883 SuppressUserConversions, AllowExplicit);
5886 SuppressUserConversions,
5887 AllowedExplicit::None,
5888 InOverloadResolution,
5890 AllowObjCWritebackConversion,
5903 return !ICS.
isBad();
5912 const CXXRecordDecl *ActingContext,
bool InOverloadResolution =
false,
5914 bool SuppressUserConversion =
false) {
5922 assert(FromClassification.
isLValue());
5933 if (Method->isExplicitObjectMemberFunction()) {
5934 if (ExplicitParameterType.isNull())
5935 ExplicitParameterType = Method->getFunctionObjectParameterReferenceType();
5937 ValueKindFromClassification(FromClassification));
5939 S, &TmpExpr, ExplicitParameterType, SuppressUserConversion,
5956 Qualifiers Quals = Method->getMethodQualifiers();
5994 FromType, ImplicitParamType);
6004 FromType, ImplicitParamType);
6017 }
else if (!Method->isExplicitObjectMemberFunction()) {
6019 FromType, ImplicitParamType);
6024 switch (Method->getRefQualifier()) {
6039 if (!FromClassification.
isRValue()) {
6061 = (Method->getRefQualifier() ==
RQ_None);
6072 QualType ImplicitParamRecordType =
Method->getFunctionObjectParameterType();
6077 DestType =
Method->getThisType();
6080 FromRecordType = From->
getType();
6081 DestType = ImplicitParamRecordType;
6089 Method->getRefQualifier() !=
6107 <<
Method->getDeclName() << FromRecordType << (CVR - 1)
6109 Diag(
Method->getLocation(), diag::note_previous_decl)
6110 <<
Method->getDeclName();
6118 bool IsRValueQualified =
6122 << IsRValueQualified;
6123 Diag(
Method->getLocation(), diag::note_previous_decl)
6124 <<
Method->getDeclName();
6134 llvm_unreachable(
"Lists are not objects");
6137 return Diag(From->
getBeginLoc(), diag::err_member_function_call_bad_type)
6138 << ImplicitParamRecordType << FromRecordType
6147 From = FromRes.
get();
6156 CK = CK_AddressSpaceConversion;
6181 AllowedExplicit::Conversions,
6262 llvm_unreachable(
"found a first conversion kind in Second");
6266 llvm_unreachable(
"found a third conversion kind in Second");
6272 llvm_unreachable(
"unknown conversion kind");
6282 [[maybe_unused]]
bool isCCEAllowedPreCXX11 =
6284 assert((S.
getLangOpts().CPlusPlus11 || isCCEAllowedPreCXX11) &&
6285 "converted constant expression outside C++11 or TTP matching");
6309 if (
T->isRecordType())
6318 diag::err_typecheck_converted_constant_expression)
6324 llvm_unreachable(
"bad conversion in converted constant expression");
6330 diag::err_typecheck_converted_constant_expression_disallowed)
6336 diag::err_typecheck_converted_constant_expression_indirect)
6346 diag::err_reference_bind_to_bitfield_in_cce)
6354 bool IsTemplateArgument =
6356 if (
T->isRecordType()) {
6357 assert(IsTemplateArgument &&
6358 "unexpected class type converted constant expr");
6367 if (Result.isInvalid())
6374 IsTemplateArgument);
6375 if (Result.isInvalid())
6379 bool ReturnPreNarrowingValue =
false;
6382 PreNarrowingType)) {
6392 PreNarrowingValue.
isInt()) {
6395 ReturnPreNarrowingValue =
true;
6415 << CCE << 0 << From->
getType() <<
T;
6418 if (!ReturnPreNarrowingValue)
6419 PreNarrowingValue = {};
6435 if (Result.isInvalid() || Result.get()->isValueDependent()) {
6440 RequireInt, PreNarrowingValue);
6447 return ::BuildConvertedConstantExpression(*
this, From,
T, CCE, Dest,
6454 return ::CheckConvertedConstantExpression(*
this, From,
T,
Value, CCE,
false,
6459 llvm::APSInt &
Value,
6461 assert(
T->isIntegralOrEnumerationType() &&
"unexpected converted const type");
6466 if (!R.isInvalid() && !R.get()->isValueDependent())
6474 const APValue &PreNarrowingValue) {
6486 Kind = ConstantExprKind::ClassTemplateArgument;
6488 Kind = ConstantExprKind::NonClassTemplateArgument;
6490 Kind = ConstantExprKind::Normal;
6493 (RequireInt && !Eval.
Val.
isInt())) {
6500 if (Notes.empty()) {
6503 if (
const auto *CE = dyn_cast<ConstantExpr>(E)) {
6507 "ConstantExpr has no value associated with it");
6513 Value = std::move(PreNarrowingValue);
6519 if (Notes.size() == 1 &&
6520 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
6521 Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
6522 }
else if (!Notes.empty() && Notes[0].second.getDiagID() ==
6523 diag::note_constexpr_invalid_template_arg) {
6524 Notes[0].second.setDiagID(diag::err_constexpr_invalid_template_arg);
6525 for (
unsigned I = 0; I < Notes.size(); ++I)
6526 Diag(Notes[I].first, Notes[I].second);
6530 for (
unsigned I = 0; I < Notes.size(); ++I)
6531 Diag(Notes[I].first, Notes[I].second);
6550static ImplicitConversionSequence
6558 AllowedExplicit::Conversions,
6600 "expected a member expression");
6602 if (
const auto M = dyn_cast<UnresolvedMemberExpr>(MemExprE);
6603 M && !M->isImplicitAccess())
6604 Base = M->getBase();
6605 else if (
const auto M = dyn_cast<MemberExpr>(MemExprE);
6606 M && !M->isImplicitAccess())
6607 Base = M->getBase();
6611 if (
T->isPointerType())
6612 T =
T->getPointeeType();
6640 assert(Method->isExplicitObjectMemberFunction() &&
6641 "Method is not an explicit member function");
6642 assert(NewArgs.empty() &&
"NewArgs should be empty");
6644 NewArgs.reserve(Args.size() + 1);
6646 NewArgs.push_back(
This);
6647 NewArgs.append(Args.begin(), Args.end());
6650 Method, Object->getBeginLoc());
6656 return AllowScopedEnumerations ?
T->isIntegralOrEnumerationType()
6657 :
T->isIntegralOrUnscopedEnumerationType();
6669 for (
unsigned I = 0, N = ViableConversions.
size(); I != N; ++I) {
6683 if (ExplicitConversions.
size() == 1 && !Converter.
Suppress) {
6691 std::string TypeStr;
6696 "static_cast<" + TypeStr +
">(")
6708 HadMultipleCandidates);
6709 if (Result.isInvalid())
6715 From, Result.get()->
getType());
6716 if (Result.isInvalid())
6718 From = Result.get();
6741 HadMultipleCandidates);
6742 if (Result.isInvalid())
6746 CK_UserDefinedConversion, Result.get(),
6747 nullptr, Result.get()->getValueKind(),
6772 if (
auto *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
6774 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
6780 Conv, FoundDecl, ActingContext, From, ToType, CandidateSet,
6814 From = result.
get();
6828 const RecordType *RecordTy =
T->getAsCanonical<RecordType>();
6841 : Converter(Converter), From(From) {}
6846 } IncompleteDiagnoser(Converter, From);
6857 ->getDefinitionOrSelf()
6858 ->getVisibleConversionFunctions();
6860 bool HadMultipleCandidates =
6865 bool HasUniqueTargetType =
true;
6881 "Conversion operator templates are considered potentially "
6885 if (Converter.
match(CurToType) || ConvTemplate) {
6891 ExplicitConversions.
addDecl(I.getDecl(), I.getAccess());
6896 else if (HasUniqueTargetType &&
6898 HasUniqueTargetType =
false;
6900 ViableConversions.
addDecl(I.getDecl(), I.getAccess());
6918 HadMultipleCandidates,
6919 ExplicitConversions))
6925 if (!HasUniqueTargetType)
6944 HadMultipleCandidates,
Found))
6953 HadMultipleCandidates,
6954 ExplicitConversions))
6962 switch (ViableConversions.
size()) {
6965 HadMultipleCandidates,
6966 ExplicitConversions))
6976 HadMultipleCandidates,
Found))
7007 if (Proto->getNumParams() < 1)
7011 QualType ArgType = Proto->getParamType(0).getNonReferenceType();
7012 if (Context.hasSameUnqualifiedType(T1, ArgType))
7016 if (Proto->getNumParams() < 2)
7020 QualType ArgType = Proto->getParamType(1).getNonReferenceType();
7021 if (Context.hasSameUnqualifiedType(T2, ArgType))
7040 unsigned SeenAt = 0;
7042 bool HasDefault =
false;
7051 return HasDefault || SeenAt != 0;
7057 bool PartialOverloading,
bool AllowExplicit,
bool AllowExplicitConversions,
7060 bool StrictPackMatch) {
7063 assert(Proto &&
"Functions without a prototype cannot be overloaded");
7064 assert(!
Function->getDescribedFunctionTemplate() &&
7065 "Use AddTemplateOverloadCandidate for function templates");
7078 CandidateSet, SuppressUserConversions,
7079 PartialOverloading, EarlyConversions, PO,
7115 CandidateSet.
addCandidate(Args.size(), EarlyConversions);
7129 Candidate.
Viable =
false;
7142 bool IsImplicitlyInstantiated =
false;
7143 if (
auto *SpecInfo =
Function->getTemplateSpecializationInfo()) {
7144 ND = SpecInfo->getTemplate();
7145 IsImplicitlyInstantiated = SpecInfo->getTemplateSpecializationKind() ==
7156 const bool IsInlineFunctionInGMF =
7158 (IsImplicitlyInstantiated ||
Function->isInlined());
7161 Candidate.
Viable =
false;
7168 Candidate.
Viable =
false;
7179 if (Args.size() == 1 &&
Constructor->isSpecializationCopyingObject() &&
7180 (
Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
7183 Candidate.
Viable =
false;
7195 auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.
getDecl());
7196 if (Shadow && Args.size() == 1 &&
Constructor->getNumParams() >= 1 &&
7197 Constructor->getParamDecl(0)->getType()->isReferenceType()) {
7204 Candidate.
Viable =
false;
7213 Constructor->getMethodQualifiers().getAddressSpace(),
7215 Candidate.
Viable =
false;
7228 Candidate.
Viable =
false;
7238 unsigned MinRequiredArgs =
Function->getMinRequiredArguments();
7239 if (!AggregateCandidateDeduction && Args.size() < MinRequiredArgs &&
7240 !PartialOverloading) {
7242 Candidate.
Viable =
false;
7256 Candidate.
Viable =
false;
7262 if (
Function->getTrailingRequiresClause()) {
7267 Candidate.
Viable =
false;
7276 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7279 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7282 }
else if (ArgIdx < NumParams) {
7293 *
this, Args[ArgIdx], ParamType, SuppressUserConversions,
7296 getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
7298 Candidate.
Viable =
false;
7310 if (EnableIfAttr *FailedAttr =
7312 Candidate.
Viable =
false;
7322 if (Methods.size() <= 1)
7325 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7331 if (
Method->param_size() > NumNamedArgs)
7332 NumNamedArgs =
Method->param_size();
7333 if (Args.size() < NumNamedArgs)
7336 for (
unsigned i = 0; i < NumNamedArgs; i++) {
7338 if (Args[i]->isTypeDependent()) {
7344 Expr *argExpr = Args[i];
7345 assert(argExpr &&
"SelectBestMethod(): missing expression");
7350 !param->
hasAttr<CFConsumedAttr>())
7351 argExpr =
ObjC().stripARCUnbridgedCast(argExpr);
7368 if (ConversionState.
isBad() ||
7378 for (
unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
7379 if (Args[i]->isTypeDependent()) {
7392 if (Args.size() != NumNamedArgs)
7394 else if (
Match && NumNamedArgs == 0 && Methods.size() > 1) {
7397 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7398 QualType ReturnT = Methods[
b]->getReturnType();
7418 "Shouldn't have `this` for ctors!");
7419 assert(!Method->isStatic() &&
"Shouldn't have `this` for static methods!");
7421 ThisArg, std::nullopt, Method, Method);
7424 ConvertedThis = R.
get();
7426 if (
auto *MD = dyn_cast<CXXMethodDecl>(Function)) {
7428 assert((MissingImplicitThis || MD->isStatic() ||
7430 "Expected `this` for non-ctor instance methods");
7432 ConvertedThis =
nullptr;
7437 unsigned ArgSizeNoVarargs = std::min(Function->param_size(), Args.size());
7440 for (
unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
7443 S.
Context, Function->getParamDecl(I)),
7449 ConvertedArgs.push_back(R.
get());
7456 if (!Function->isVariadic() && Args.size() < Function->getNumParams()) {
7457 for (
unsigned i = Args.size(), e = Function->getNumParams(); i != e; ++i) {
7464 ConvertedArgs.push_back(R.
get());
7476 bool MissingImplicitThis) {
7477 auto EnableIfAttrs =
Function->specific_attrs<EnableIfAttr>();
7478 if (EnableIfAttrs.begin() == EnableIfAttrs.end())
7484 Expr *DiscardedThis;
7486 *
this,
Function,
nullptr, CallLoc, Args, Trap,
7487 true, DiscardedThis, ConvertedArgs))
7488 return *EnableIfAttrs.begin();
7490 for (
auto *EIA : EnableIfAttrs) {
7494 if (EIA->getCond()->isValueDependent() ||
7495 !EIA->getCond()->EvaluateWithSubstitution(
7499 if (!
Result.isInt() || !
Result.getInt().getBoolValue())
7505template <
typename CheckFn>
7508 CheckFn &&IsSuccessful) {
7511 if (ArgDependent == DIA->getArgDependent())
7512 Attrs.push_back(DIA);
7519 auto WarningBegin = std::stable_partition(
7520 Attrs.begin(), Attrs.end(), [](
const DiagnoseIfAttr *DIA) {
7521 return DIA->getDefaultSeverity() == DiagnoseIfAttr::DS_error &&
7522 DIA->getWarningGroup().empty();
7527 auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
7529 if (ErrAttr != WarningBegin) {
7530 const DiagnoseIfAttr *DIA = *ErrAttr;
7531 S.
Diag(Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
7532 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7533 << DIA->getParent() << DIA->getCond()->getSourceRange();
7537 auto ToSeverity = [](DiagnoseIfAttr::DefaultSeverity Sev) {
7539 case DiagnoseIfAttr::DS_warning:
7541 case DiagnoseIfAttr::DS_error:
7544 llvm_unreachable(
"Fully covered switch above!");
7547 for (
const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
7548 if (IsSuccessful(DIA)) {
7549 if (DIA->getWarningGroup().empty() &&
7550 DIA->getDefaultSeverity() == DiagnoseIfAttr::DS_warning) {
7551 S.
Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
7552 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7553 << DIA->getParent() << DIA->getCond()->getSourceRange();
7556 DIA->getWarningGroup());
7559 {ToSeverity(DIA->getDefaultSeverity()),
"%0",
7561 S.
Diag(Loc, DiagID) << DIA->getMessage();
7569 const Expr *ThisArg,
7574 [&](
const DiagnoseIfAttr *DIA) {
7579 if (!DIA->getCond()->EvaluateWithSubstitution(
7582 return Result.isInt() &&
Result.getInt().getBoolValue();
7589 *
this, ND,
false, Loc,
7590 [&](
const DiagnoseIfAttr *DIA) {
7592 return DIA->getCond()->EvaluateAsBooleanCondition(
Result,
Context) &&
7601 bool SuppressUserConversions,
7602 bool PartialOverloading,
7603 bool FirstArgumentIsBase) {
7615 if (Args.size() > 0) {
7616 if (
Expr *E = Args[0]) {
7626 FunctionArgs = Args.slice(1);
7630 FunTmpl, F.getPair(),
7632 ExplicitTemplateArgs, ObjectType, ObjectClassification,
7633 FunctionArgs, CandidateSet, SuppressUserConversions,
7634 PartialOverloading);
7638 ObjectClassification, FunctionArgs, CandidateSet,
7639 SuppressUserConversions, PartialOverloading);
7646 if (Args.size() > 0 &&
7650 FunctionArgs = Args.slice(1);
7654 ExplicitTemplateArgs, FunctionArgs,
7655 CandidateSet, SuppressUserConversions,
7656 PartialOverloading);
7659 SuppressUserConversions, PartialOverloading);
7669 bool SuppressUserConversions,
7679 "Expected a member function template");
7681 nullptr, ObjectType,
7682 ObjectClassification, Args, CandidateSet,
7683 SuppressUserConversions,
false, PO);
7686 ObjectType, ObjectClassification, Args, CandidateSet,
7687 SuppressUserConversions,
false, {}, PO);
7700 assert(Proto &&
"Methods without a prototype cannot be overloaded");
7702 "Use AddOverloadCandidate for constructors");
7711 Method->isMoveAssignmentOperator())
7718 bool IgnoreExplicitObject =
7719 (
Method->isExplicitObjectMemberFunction() &&
7722 bool ImplicitObjectMethodTreatedAsStatic =
7725 Method->isImplicitObjectMemberFunction();
7727 unsigned ExplicitOffset =
7728 !IgnoreExplicitObject &&
Method->isExplicitObjectMemberFunction() ? 1 : 0;
7730 unsigned NumParams =
Method->getNumParams() - ExplicitOffset +
7731 int(ImplicitObjectMethodTreatedAsStatic);
7733 unsigned ExtraArgs =
7740 CandidateSet.
addCandidate(Args.size() + ExtraArgs, EarlyConversions);
7756 Candidate.
Viable =
false;
7766 unsigned MinRequiredArgs =
Method->getMinRequiredArguments() -
7768 int(ImplicitObjectMethodTreatedAsStatic);
7770 if (Args.size() < MinRequiredArgs && !PartialOverloading) {
7772 Candidate.
Viable =
false;
7780 if (!IgnoreExplicitObject) {
7783 else if (
Method->isStatic()) {
7793 Candidate.
Conversions[FirstConvIdx].setStaticObjectArgument();
7798 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7799 Method, ActingContext,
true);
7800 if (Candidate.
Conversions[FirstConvIdx].isBad()) {
7801 Candidate.
Viable =
false;
7812 Candidate.
Viable =
false;
7817 if (
Method->getTrailingRequiresClause()) {
7822 Candidate.
Viable =
false;
7830 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7833 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7836 }
else if (ArgIdx < NumParams) {
7842 if (ImplicitObjectMethodTreatedAsStatic) {
7843 ParamType = ArgIdx == 0
7844 ?
Method->getFunctionObjectParameterReferenceType()
7847 ParamType = Proto->
getParamType(ArgIdx + ExplicitOffset);
7851 SuppressUserConversions,
7856 Candidate.
Viable =
false;
7868 if (EnableIfAttr *FailedAttr =
7870 Candidate.
Viable =
false;
7877 Candidate.
Viable =
false;
7888 bool SuppressUserConversions,
bool PartialOverloading,
7906 PartialOverloading,
false,
7907 false, ObjectType, ObjectClassification,
7911 bool OnlyInitializeNonUserDefinedConversions) {
7912 return S.CheckNonDependentConversions(
7913 MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
7914 Sema::CheckNonDependentConversionsFlag(
7915 SuppressUserConversions,
7916 OnlyInitializeNonUserDefinedConversions),
7917 ActingContext, ObjectType, ObjectClassification, PO);
7921 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7924 Candidate.
Viable =
false;
7933 Method->isStatic() ||
7934 (!Method->isExplicitObjectMemberFunction() && ObjectType.
isNull());
7948 assert(
Specialization &&
"Missing member function template specialization?");
7950 "Specialization is not a member function?");
7953 ObjectClassification, Args, CandidateSet, SuppressUserConversions,
7967 if (ExplicitTemplateArgs ||
7970 *
this, CandidateSet, MethodTmpl, FoundDecl, ActingContext,
7971 ExplicitTemplateArgs, ObjectType, ObjectClassification, Args,
7972 SuppressUserConversions, PartialOverloading, PO);
7977 MethodTmpl, FoundDecl, ActingContext, ObjectType, ObjectClassification,
7978 Args, SuppressUserConversions, PartialOverloading, PO);
7996 bool SuppressUserConversions,
bool PartialOverloading,
bool AllowExplicit,
7998 bool AggregateCandidateDeduction) {
8007 Candidate.
Viable =
false;
8027 PartialOverloading, AggregateCandidateDeduction,
8034 bool OnlyInitializeNonUserDefinedConversions) {
8035 return S.CheckNonDependentConversions(
8036 FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions,
8037 Sema::CheckNonDependentConversionsFlag(
8038 SuppressUserConversions,
8039 OnlyInitializeNonUserDefinedConversions),
8040 nullptr, QualType(), {}, PO);
8043 OverloadCandidate &Candidate =
8044 CandidateSet.addCandidate(Conversions.size(), Conversions);
8047 Candidate.
Viable =
false;
8049 CandidateSet.getRewriteInfo().getRewriteKind(Candidate.
Function, PO);
8055 CandidateSet.getKind() ==
8061 ->isExplicitObjectMemberFunction() &&
8077 assert(
Specialization &&
"Missing function template specialization?");
8079 Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
8080 PartialOverloading, AllowExplicit,
8081 false, IsADLCandidate, Conversions, PO,
8082 Info.AggregateDeductionCandidateHasMismatchedArity,
8083 Info.hasStrictPackMatch());
8090 bool PartialOverloading,
bool AllowExplicit,
ADLCallKind IsADLCandidate,
8097 if (ExplicitTemplateArgs ||
8100 DependentExplicitSpecifier)) {
8104 Args, SuppressUserConversions, PartialOverloading, AllowExplicit,
8105 IsADLCandidate, PO, AggregateCandidateDeduction);
8107 if (DependentExplicitSpecifier)
8114 PartialOverloading, AllowExplicit, IsADLCandidate, PO,
8115 AggregateCandidateDeduction);
8128 const bool AllowExplicit =
false;
8130 bool ForOverloadSetAddressResolution =
8133 auto *
Method = dyn_cast<CXXMethodDecl>(FD);
8134 bool HasThisConversion = !ForOverloadSetAddressResolution &&
Method &&
8136 unsigned ThisConversions = HasThisConversion ? 1 : 0;
8152 if (!FD->hasCXXExplicitFunctionObjectParameter() ||
8153 !ParamTypes[0]->isDependentType()) {
8155 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
8156 Method, ActingContext,
true,
8157 FD->hasCXXExplicitFunctionObjectParameter() ? ParamTypes[0]
8167 auto MaybeInvolveUserDefinedConversion = [&](
QualType ParamType,
8191 if (
auto *RD =
ArgType->getAsCXXRecordDecl();
8192 RD && RD->hasDefinition() &&
8193 !RD->getVisibleConversionFunctions().empty())
8200 HasThisConversion &&
Method->hasCXXExplicitFunctionObjectParameter() ? 1
8203 for (
unsigned I = 0, N = std::min(ParamTypes.size() - Offset, Args.size());
8205 QualType ParamType = ParamTypes[I + Offset];
8209 ConvIdx = Args.size() - 1 - I;
8210 assert(Args.size() + ThisConversions == 2 &&
8211 "number of args (including 'this') must be exactly 2 for "
8215 assert(!HasThisConversion || (ConvIdx == 0 && I == 0));
8218 ConvIdx = ThisConversions + I;
8223 MaybeInvolveUserDefinedConversion(ParamType, Args[I]->
getType()))
8252 bool AllowObjCPointerConversion) {
8260 bool ObjCLifetimeConversion;
8262 ObjCLifetimeConversion))
8267 if (!AllowObjCPointerConversion)
8271 bool IncompatibleObjC =
false;
8281 bool AllowExplicit,
bool AllowResultConversion,
bool StrictPackMatch) {
8283 "Conversion function templates use AddTemplateConversionCandidate");
8298 if (!AllowResultConversion &&
8310 AllowObjCConversionOnExplicit))
8332 if (!AllowExplicit && Conversion->
isExplicit()) {
8333 Candidate.
Viable =
false;
8360 Candidate.
Viable =
false;
8369 Candidate.
Viable =
false;
8380 QualType ToCanon =
Context.getCanonicalType(ToType).getUnqualifiedType();
8381 if (FromCanon == ToCanon ||
8383 Candidate.
Viable =
false;
8400 CK_FunctionToPointerDecay, &ConversionRef,
8405 Candidate.
Viable =
false;
8435 Candidate.
Viable =
false;
8447 Candidate.
Viable =
false;
8454 Candidate.
Viable =
false;
8460 "Can only end up with a standard conversion sequence or failure");
8463 if (EnableIfAttr *FailedAttr =
8465 Candidate.
Viable =
false;
8472 Candidate.
Viable =
false;
8481 bool AllowObjCConversionOnExplicit,
bool AllowExplicit,
8482 bool AllowResultConversion) {
8491 Candidate.
Viable =
false;
8508 Candidate.
Viable =
false;
8518 assert(
Specialization &&
"Missing function template specialization?");
8520 ToType, CandidateSet, AllowObjCConversionOnExplicit,
8521 AllowExplicit, AllowResultConversion,
8529 bool AllowExplicit,
bool AllowResultConversion) {
8531 "Only conversion function templates permitted here");
8542 ToType, AllowObjCConversionOnExplicit, AllowExplicit,
8543 AllowResultConversion);
8551 AllowObjCConversionOnExplicit, AllowExplicit, AllowResultConversion);
8586 *
this, CandidateSet.
getLocation(), Object->getType(),
8587 Object->Classify(
Context), Conversion, ActingContext);
8590 if (ObjectInit.
isBad()) {
8591 Candidate.
Viable =
false;
8602 Candidate.
Conversions[0].UserDefined.EllipsisConversion =
false;
8603 Candidate.
Conversions[0].UserDefined.HadMultipleCandidates =
false;
8604 Candidate.
Conversions[0].UserDefined.ConversionFunction = Conversion;
8605 Candidate.
Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
8608 Candidate.
Conversions[0].UserDefined.After.setAsIdentityConversion();
8616 if (Args.size() > NumParams && !Proto->
isVariadic()) {
8617 Candidate.
Viable =
false;
8624 if (Args.size() < NumParams) {
8626 Candidate.
Viable =
false;
8633 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8634 if (ArgIdx < NumParams) {
8647 Candidate.
Viable =
false;
8664 Candidate.
Viable =
false;
8670 if (EnableIfAttr *FailedAttr =
8672 Candidate.
Viable =
false;
8696 "unqualified operator lookup found a member function");
8700 FunctionArgs, CandidateSet);
8706 FunctionArgs[1], FunctionArgs[0]);
8708 Reversed, CandidateSet,
false,
false,
true,
8709 ADLCallKind::NotADL,
8713 if (ExplicitTemplateArgs)
8718 {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
8719 false,
false,
true,
false, ADLCallKind::NotADL, {},
8751 if (!T1RD || (!IsComplete && !T1RD->isBeingDefined()))
8759 OperEnd = Operators.
end();
8760 Oper != OperEnd; ++Oper) {
8761 if (Oper->getAsFunction() &&
8764 *
this, {Args[1], Args[0]}, Oper->getAsFunction()))
8767 Args[0]->Classify(
Context), Args.slice(1),
8768 CandidateSet,
false, PO);
8775 bool IsAssignmentOperator,
8776 unsigned NumContextualBoolArguments) {
8791 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8804 if (ArgIdx < NumContextualBoolArguments) {
8805 assert(ParamTys[ArgIdx] ==
Context.BoolTy &&
8806 "Contextual conversion to bool requires bool type");
8812 ArgIdx == 0 && IsAssignmentOperator,
8818 Candidate.
Viable =
false;
8831class BuiltinCandidateTypeSet {
8837 TypeSet PointerTypes;
8841 TypeSet MemberPointerTypes;
8845 TypeSet EnumerationTypes;
8849 TypeSet VectorTypes;
8853 TypeSet MatrixTypes;
8856 TypeSet BitIntTypes;
8859 bool HasNonRecordTypes;
8863 bool HasArithmeticOrEnumeralTypes;
8867 bool HasNullPtrType;
8876 bool AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8878 bool AddMemberPointerWithMoreQualifiedTypeVariants(
QualType Ty);
8882 typedef TypeSet::iterator
iterator;
8884 BuiltinCandidateTypeSet(
Sema &SemaRef)
8885 : HasNonRecordTypes(
false),
8886 HasArithmeticOrEnumeralTypes(
false),
8887 HasNullPtrType(
false),
8889 Context(SemaRef.Context) { }
8891 void AddTypesConvertedFrom(
QualType Ty,
8893 bool AllowUserConversions,
8894 bool AllowExplicitConversions,
8895 const Qualifiers &VisibleTypeConversionsQuals);
8897 llvm::iterator_range<iterator> pointer_types() {
return PointerTypes; }
8898 llvm::iterator_range<iterator> member_pointer_types() {
8899 return MemberPointerTypes;
8901 llvm::iterator_range<iterator> enumeration_types() {
8902 return EnumerationTypes;
8904 llvm::iterator_range<iterator> vector_types() {
return VectorTypes; }
8905 llvm::iterator_range<iterator> matrix_types() {
return MatrixTypes; }
8906 llvm::iterator_range<iterator> bitint_types() {
return BitIntTypes; }
8908 bool containsMatrixType(QualType Ty)
const {
return MatrixTypes.count(Ty); }
8909 bool hasNonRecordTypes() {
return HasNonRecordTypes; }
8910 bool hasArithmeticOrEnumeralTypes() {
return HasArithmeticOrEnumeralTypes; }
8911 bool hasNullPtrType()
const {
return HasNullPtrType; }
8926BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
8927 const Qualifiers &VisibleQuals) {
8930 if (!PointerTypes.insert(Ty))
8934 const PointerType *PointerTy = Ty->
getAs<PointerType>();
8935 bool buildObjCPtr =
false;
8937 const ObjCObjectPointerType *PTy = Ty->
castAs<ObjCObjectPointerType>();
8939 buildObjCPtr =
true;
8951 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
8957 if ((CVR | BaseCVR) != CVR)
continue;
8972 QualType QPointerTy;
8979 PointerTypes.insert(QPointerTy);
8995BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
8998 if (!MemberPointerTypes.insert(Ty))
9001 const MemberPointerType *PointerTy = Ty->
getAs<MemberPointerType>();
9002 assert(PointerTy &&
"type was not a member pointer type!");
9017 if ((CVR | BaseCVR) != CVR)
continue;
9021 QPointeeTy, std::nullopt, Cls));
9036BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
9038 bool AllowUserConversions,
9039 bool AllowExplicitConversions,
9040 const Qualifiers &VisibleQuals) {
9046 if (
const ReferenceType *RefTy = Ty->
getAs<ReferenceType>())
9051 Ty = SemaRef.Context.getArrayDecayedType(Ty);
9058 HasNonRecordTypes = HasNonRecordTypes || !TyIsRec;
9061 HasArithmeticOrEnumeralTypes =
9065 PointerTypes.insert(Ty);
9066 else if (Ty->
getAs<PointerType>() || Ty->
getAs<ObjCObjectPointerType>()) {
9069 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
9073 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
9076 HasArithmeticOrEnumeralTypes =
true;
9077 EnumerationTypes.insert(Ty);
9079 HasArithmeticOrEnumeralTypes =
true;
9080 BitIntTypes.insert(Ty);
9084 HasArithmeticOrEnumeralTypes =
true;
9085 VectorTypes.insert(Ty);
9089 HasArithmeticOrEnumeralTypes =
true;
9090 MatrixTypes.insert(Ty);
9092 HasNullPtrType =
true;
9093 }
else if (AllowUserConversions && TyIsRec) {
9095 if (!SemaRef.isCompleteType(Loc, Ty))
9099 for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
9109 if (AllowExplicitConversions || !Conv->
isExplicit()) {
9157 ClassDecl = RHSMPType->getMostRecentCXXRecordDecl();
9205 if (Available.hasAtomic()) {
9206 Available.removeAtomic();
9213 if (Available.hasVolatile()) {
9214 Available.removeVolatile();
9248class BuiltinOperatorOverloadBuilder {
9251 ArrayRef<Expr *> Args;
9252 QualifiersAndAtomic VisibleTypeConversionsQuals;
9253 bool HasArithmeticOrEnumeralCandidateType;
9254 SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes;
9255 OverloadCandidateSet &CandidateSet;
9257 static constexpr int ArithmeticTypesCap = 26;
9258 SmallVector<CanQualType, ArithmeticTypesCap> ArithmeticTypes;
9263 unsigned FirstIntegralType,
9265 unsigned FirstPromotedIntegralType,
9266 LastPromotedIntegralType;
9267 unsigned FirstPromotedArithmeticType,
9268 LastPromotedArithmeticType;
9269 unsigned NumArithmeticTypes;
9271 void InitArithmeticTypes() {
9273 FirstPromotedArithmeticType = 0;
9283 FirstIntegralType = ArithmeticTypes.size();
9284 FirstPromotedIntegralType = ArithmeticTypes.size();
9306 llvm::SmallSetVector<CanQualType, 2> BitIntCandidates;
9307 for (BuiltinCandidateTypeSet &Candidate : CandidateTypes) {
9308 for (QualType BitTy : Candidate.bitint_types())
9311 llvm::move(BitIntCandidates, std::back_inserter(ArithmeticTypes));
9312 LastPromotedIntegralType = ArithmeticTypes.size();
9313 LastPromotedArithmeticType = ArithmeticTypes.size();
9327 LastIntegralType = ArithmeticTypes.size();
9328 NumArithmeticTypes = ArithmeticTypes.size();
9335 assert(ArithmeticTypes.size() - BitIntCandidates.size() <=
9336 ArithmeticTypesCap &&
9337 "Enough inline storage for all arithmetic types.");
9342 void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy,
9345 QualType ParamTypes[2] = {
9385 void AddCandidate(QualType L, QualType R) {
9386 QualType LandR[2] = {L, R};
9391 BuiltinOperatorOverloadBuilder(
9392 Sema &S, ArrayRef<Expr *> Args,
9393 QualifiersAndAtomic VisibleTypeConversionsQuals,
9394 bool HasArithmeticOrEnumeralCandidateType,
9395 SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes,
9396 OverloadCandidateSet &CandidateSet)
9398 VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
9399 HasArithmeticOrEnumeralCandidateType(
9400 HasArithmeticOrEnumeralCandidateType),
9401 CandidateTypes(CandidateTypes),
9402 CandidateSet(CandidateSet) {
9404 InitArithmeticTypes();
9427 if (!HasArithmeticOrEnumeralCandidateType)
9430 for (
unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
9431 const auto TypeOfT = ArithmeticTypes[Arith];
9433 if (Op == OO_MinusMinus)
9435 if (Op == OO_PlusPlus && S.
getLangOpts().CPlusPlus17)
9438 addPlusPlusMinusMinusStyleOverloads(
9455 void addPlusPlusMinusMinusPointerOverloads() {
9456 for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
9458 if (!PtrTy->getPointeeType()->isObjectType())
9461 addPlusPlusMinusMinusStyleOverloads(
9463 (!PtrTy.isVolatileQualified() &&
9465 (!PtrTy.isRestrictQualified() &&
9480 void addUnaryStarPointerOverloads() {
9481 for (QualType ParamTy : CandidateTypes[0].pointer_types()) {
9486 if (
const FunctionProtoType *Proto =PointeeTy->
getAs<FunctionProtoType>())
9487 if (Proto->getMethodQuals() || Proto->getRefQualifier())
9500 void addUnaryPlusOrMinusArithmeticOverloads() {
9501 if (!HasArithmeticOrEnumeralCandidateType)
9504 for (
unsigned Arith = FirstPromotedArithmeticType;
9505 Arith < LastPromotedArithmeticType; ++Arith) {
9506 QualType ArithTy = ArithmeticTypes[Arith];
9511 for (QualType VecTy : CandidateTypes[0].vector_types())
9520 void addUnaryPlusPointerOverloads() {
9521 for (QualType ParamTy : CandidateTypes[0].pointer_types())
9530 void addUnaryTildePromotedIntegralOverloads() {
9531 if (!HasArithmeticOrEnumeralCandidateType)
9534 for (
unsigned Int = FirstPromotedIntegralType;
9535 Int < LastPromotedIntegralType; ++
Int) {
9536 QualType IntTy = ArithmeticTypes[
Int];
9541 for (QualType VecTy : CandidateTypes[0].vector_types())
9551 void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
9553 llvm::SmallPtrSet<QualType, 8> AddedTypes;
9555 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9556 for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9561 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9565 if (CandidateTypes[ArgIdx].hasNullPtrType()) {
9567 if (AddedTypes.insert(NullPtrTy).second) {
9568 QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
9587 void addGenericBinaryPointerOrEnumeralOverloads(
bool IsSpaceship) {
9600 llvm::DenseSet<std::pair<CanQualType, CanQualType> >
9601 UserDefinedBinaryOperators;
9603 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9604 if (!CandidateTypes[ArgIdx].enumeration_types().empty()) {
9606 CEnd = CandidateSet.
end();
9608 if (!
C->Viable || !
C->Function ||
C->Function->getNumParams() != 2)
9611 if (
C->Function->isFunctionTemplateSpecialization())
9618 QualType FirstParamType =
C->Function->getParamDecl(
Reversed ? 1 : 0)
9620 .getUnqualifiedType();
9621 QualType SecondParamType =
C->Function->getParamDecl(
Reversed ? 0 : 1)
9623 .getUnqualifiedType();
9631 UserDefinedBinaryOperators.insert(
9639 llvm::SmallPtrSet<QualType, 8> AddedTypes;
9641 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9642 for (QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9646 if (IsSpaceship && PtrTy->isFunctionPointerType())
9649 QualType ParamTypes[2] = {PtrTy, PtrTy};
9652 for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9657 if (!AddedTypes.insert(CanonType).second ||
9658 UserDefinedBinaryOperators.count(std::make_pair(CanonType,
9661 QualType ParamTypes[2] = {EnumTy, EnumTy};
9686 llvm::SmallPtrSet<QualType, 8> AddedTypes;
9688 for (
int Arg = 0; Arg < 2; ++Arg) {
9689 QualType AsymmetricParamTypes[2] = {
9693 for (QualType PtrTy : CandidateTypes[Arg].pointer_types()) {
9698 AsymmetricParamTypes[Arg] = PtrTy;
9699 if (Arg == 0 || Op == OO_Plus) {
9704 if (Op == OO_Minus) {
9709 QualType ParamTypes[2] = {PtrTy, PtrTy};
9745 void addGenericBinaryArithmeticOverloads() {
9746 if (!HasArithmeticOrEnumeralCandidateType)
9749 for (
unsigned Left = FirstPromotedArithmeticType;
9750 Left < LastPromotedArithmeticType; ++
Left) {
9751 for (
unsigned Right = FirstPromotedArithmeticType;
9752 Right < LastPromotedArithmeticType; ++
Right) {
9753 QualType LandR[2] = { ArithmeticTypes[
Left],
9754 ArithmeticTypes[
Right] };
9761 for (QualType Vec1Ty : CandidateTypes[0].vector_types())
9762 for (QualType Vec2Ty : CandidateTypes[1].vector_types()) {
9763 QualType LandR[2] = {Vec1Ty, Vec2Ty};
9773 void addMatrixBinaryArithmeticOverloads() {
9774 if (!HasArithmeticOrEnumeralCandidateType)
9777 for (QualType M1 : CandidateTypes[0].matrix_types()) {
9779 AddCandidate(M1, M1);
9782 for (QualType M2 : CandidateTypes[1].matrix_types()) {
9784 if (!CandidateTypes[0].containsMatrixType(M2))
9785 AddCandidate(M2, M2);
9820 void addThreeWayArithmeticOverloads() {
9821 addGenericBinaryArithmeticOverloads();
9838 void addBinaryBitwiseArithmeticOverloads() {
9839 if (!HasArithmeticOrEnumeralCandidateType)
9842 for (
unsigned Left = FirstPromotedIntegralType;
9843 Left < LastPromotedIntegralType; ++
Left) {
9844 for (
unsigned Right = FirstPromotedIntegralType;
9846 QualType LandR[2] = { ArithmeticTypes[
Left],
9847 ArithmeticTypes[
Right] };
9860 void addAssignmentMemberPointerOrEnumeralOverloads() {
9862 llvm::SmallPtrSet<QualType, 8> AddedTypes;
9864 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9865 for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9872 for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9897 void addAssignmentPointerOverloads(
bool isEqualOp) {
9899 llvm::SmallPtrSet<QualType, 8> AddedTypes;
9901 for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
9905 else if (!PtrTy->getPointeeType()->isObjectType())
9909 QualType ParamTypes[2] = {
9916 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9926 if (!PtrTy.isRestrictQualified() &&
9946 for (QualType PtrTy : CandidateTypes[1].pointer_types()) {
9951 QualType ParamTypes[2] = {
9960 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9970 if (!PtrTy.isRestrictQualified() &&
10003 void addAssignmentArithmeticOverloads(
bool isEqualOp) {
10004 if (!HasArithmeticOrEnumeralCandidateType)
10007 for (
unsigned Left = 0;
Left < NumArithmeticTypes; ++
Left) {
10008 for (
unsigned Right = FirstPromotedArithmeticType;
10009 Right < LastPromotedArithmeticType; ++
Right) {
10010 QualType ParamTypes[2];
10011 ParamTypes[1] = ArithmeticTypes[
Right];
10013 S, ArithmeticTypes[Left], Args[0]);
10016 VisibleTypeConversionsQuals, [&](QualifiersAndAtomic Quals) {
10026 for (QualType Vec1Ty : CandidateTypes[0].vector_types())
10027 for (QualType Vec2Ty : CandidateTypes[0].vector_types()) {
10028 QualType ParamTypes[2];
10029 ParamTypes[1] = Vec2Ty;
10057 void addAssignmentIntegralOverloads() {
10058 if (!HasArithmeticOrEnumeralCandidateType)
10061 for (
unsigned Left = FirstIntegralType;
Left < LastIntegralType; ++
Left) {
10062 for (
unsigned Right = FirstPromotedIntegralType;
10063 Right < LastPromotedIntegralType; ++
Right) {
10064 QualType ParamTypes[2];
10065 ParamTypes[1] = ArithmeticTypes[
Right];
10067 S, ArithmeticTypes[Left], Args[0]);
10070 VisibleTypeConversionsQuals, [&](QualifiersAndAtomic Quals) {
10086 void addExclaimOverload() {
10092 void addAmpAmpOrPipePipeOverload() {
10109 void addSubscriptOverloads() {
10110 for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
10120 for (QualType PtrTy : CandidateTypes[1].pointer_types()) {
10140 void addArrowStarOverloads() {
10141 for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
10142 QualType C1Ty = PtrTy;
10144 QualifierCollector Q1;
10155 for (QualType MemPtrTy : CandidateTypes[1].member_pointer_types()) {
10162 QualType ParamTypes[2] = {PtrTy, MemPtrTy};
10165 if (!VisibleTypeConversionsQuals.
hasVolatile() &&
10166 T.isVolatileQualified())
10168 if (!VisibleTypeConversionsQuals.
hasRestrict() &&
10169 T.isRestrictQualified())
10187 void addConditionalOperatorOverloads() {
10189 llvm::SmallPtrSet<QualType, 8> AddedTypes;
10191 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
10192 for (QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
10196 QualType ParamTypes[2] = {PtrTy, PtrTy};
10200 for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
10204 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
10209 for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
10210 if (!EnumTy->castAsCanonical<EnumType>()
10211 ->getOriginalDecl()
10218 QualType ParamTypes[2] = {EnumTy, EnumTy};
10237 VisibleTypeConversionsQuals.
addConst();
10238 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
10240 if (Args[ArgIdx]->
getType()->isAtomicType())
10241 VisibleTypeConversionsQuals.
addAtomic();
10244 bool HasNonRecordCandidateType =
false;
10245 bool HasArithmeticOrEnumeralCandidateType =
false;
10247 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
10248 CandidateTypes.emplace_back(*
this);
10249 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->
getType(),
10252 (Op == OO_Exclaim ||
10254 Op == OO_PipePipe),
10255 VisibleTypeConversionsQuals);
10256 HasNonRecordCandidateType = HasNonRecordCandidateType ||
10257 CandidateTypes[ArgIdx].hasNonRecordTypes();
10258 HasArithmeticOrEnumeralCandidateType =
10259 HasArithmeticOrEnumeralCandidateType ||
10260 CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
10268 if (!HasNonRecordCandidateType &&
10269 !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
10273 BuiltinOperatorOverloadBuilder OpBuilder(*
this, Args,
10274 VisibleTypeConversionsQuals,
10275 HasArithmeticOrEnumeralCandidateType,
10276 CandidateTypes, CandidateSet);
10282 llvm_unreachable(
"Expected an overloaded operator");
10287 case OO_Array_Delete:
10290 "Special operators don't use AddBuiltinOperatorCandidates");
10302 if (Args.size() == 1)
10303 OpBuilder.addUnaryPlusPointerOverloads();
10307 if (Args.size() == 1) {
10308 OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
10310 OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
10311 OpBuilder.addGenericBinaryArithmeticOverloads();
10312 OpBuilder.addMatrixBinaryArithmeticOverloads();
10317 if (Args.size() == 1)
10318 OpBuilder.addUnaryStarPointerOverloads();
10320 OpBuilder.addGenericBinaryArithmeticOverloads();
10321 OpBuilder.addMatrixBinaryArithmeticOverloads();
10326 OpBuilder.addGenericBinaryArithmeticOverloads();
10330 case OO_MinusMinus:
10331 OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
10332 OpBuilder.addPlusPlusMinusMinusPointerOverloads();
10335 case OO_EqualEqual:
10336 case OO_ExclaimEqual:
10337 OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
10338 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10339 OpBuilder.addGenericBinaryArithmeticOverloads();
10345 case OO_GreaterEqual:
10346 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10347 OpBuilder.addGenericBinaryArithmeticOverloads();
10351 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
true);
10352 OpBuilder.addThreeWayArithmeticOverloads();
10359 case OO_GreaterGreater:
10360 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10364 if (Args.size() == 1)
10370 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10374 OpBuilder.addUnaryTildePromotedIntegralOverloads();
10378 OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
10382 case OO_MinusEqual:
10383 OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
10387 case OO_SlashEqual:
10388 OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
10391 case OO_PercentEqual:
10392 case OO_LessLessEqual:
10393 case OO_GreaterGreaterEqual:
10395 case OO_CaretEqual:
10397 OpBuilder.addAssignmentIntegralOverloads();
10401 OpBuilder.addExclaimOverload();
10406 OpBuilder.addAmpAmpOrPipePipeOverload();
10410 if (Args.size() == 2)
10411 OpBuilder.addSubscriptOverloads();
10415 OpBuilder.addArrowStarOverloads();
10418 case OO_Conditional:
10419 OpBuilder.addConditionalOperatorOverloads();
10420 OpBuilder.addGenericBinaryArithmeticOverloads();
10431 bool PartialOverloading) {
10448 CandEnd = CandidateSet.
end();
10449 Cand != CandEnd; ++Cand)
10450 if (Cand->Function) {
10454 Fns.
erase(FunTmpl);
10463 if (ExplicitTemplateArgs)
10467 FD, FoundDecl, Args, CandidateSet,
false,
10468 PartialOverloading,
true,
10469 false, ADLCallKind::UsesADL);
10472 FD, FoundDecl, {Args[1], Args[0]}, CandidateSet,
10473 false, PartialOverloading,
10480 FTD, FoundDecl, ExplicitTemplateArgs, Args, CandidateSet,
10481 false, PartialOverloading,
10482 true, ADLCallKind::UsesADL);
10484 *
this, Args, FTD->getTemplatedDecl())) {
10488 if (ReversedArgs.empty())
10492 FTD, FoundDecl, ExplicitTemplateArgs, ReversedArgs, CandidateSet,
10493 false, PartialOverloading,
10494 true, ADLCallKind::UsesADL,
10519 bool Cand1Attr = Cand1->
hasAttr<EnableIfAttr>();
10520 bool Cand2Attr = Cand2->
hasAttr<EnableIfAttr>();
10521 if (!Cand1Attr || !Cand2Attr) {
10522 if (Cand1Attr == Cand2Attr)
10523 return Comparison::Equal;
10524 return Cand1Attr ? Comparison::Better : Comparison::Worse;
10530 llvm::FoldingSetNodeID Cand1ID, Cand2ID;
10531 for (
auto Pair : zip_longest(Cand1Attrs, Cand2Attrs)) {
10532 std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
10533 std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
10538 return Comparison::Worse;
10540 return Comparison::Better;
10545 (*Cand1A)->getCond()->Profile(Cand1ID, S.
getASTContext(),
true);
10546 (*Cand2A)->getCond()->Profile(Cand2ID, S.
getASTContext(),
true);
10547 if (Cand1ID != Cand2ID)
10548 return Comparison::Worse;
10551 return Comparison::Equal;
10559 return Comparison::Equal;
10565 return Comparison::Equal;
10566 return Comparison::Worse;
10569 return Comparison::Better;
10575 const auto *Cand1CPUSpec = Cand1.
Function->
getAttr<CPUSpecificAttr>();
10576 const auto *Cand2CPUSpec = Cand2.
Function->
getAttr<CPUSpecificAttr>();
10578 if (!Cand1CPUDisp && !Cand2CPUDisp && !Cand1CPUSpec && !Cand2CPUSpec)
10579 return Comparison::Equal;
10581 if (Cand1CPUDisp && !Cand2CPUDisp)
10582 return Comparison::Better;
10583 if (Cand2CPUDisp && !Cand1CPUDisp)
10584 return Comparison::Worse;
10586 if (Cand1CPUSpec && Cand2CPUSpec) {
10587 if (Cand1CPUSpec->cpus_size() != Cand2CPUSpec->cpus_size())
10588 return Cand1CPUSpec->cpus_size() < Cand2CPUSpec->cpus_size()
10589 ? Comparison::Better
10590 : Comparison::Worse;
10592 std::pair<CPUSpecificAttr::cpus_iterator, CPUSpecificAttr::cpus_iterator>
10593 FirstDiff = std::mismatch(
10594 Cand1CPUSpec->cpus_begin(), Cand1CPUSpec->cpus_end(),
10595 Cand2CPUSpec->cpus_begin(),
10597 return LHS->getName() == RHS->getName();
10600 assert(FirstDiff.first != Cand1CPUSpec->cpus_end() &&
10601 "Two different cpu-specific versions should not have the same "
10602 "identifier list, otherwise they'd be the same decl!");
10603 return (*FirstDiff.first)->getName() < (*FirstDiff.second)->getName()
10604 ? Comparison::Better
10605 : Comparison::Worse;
10607 llvm_unreachable(
"No way to get here unless both had cpu_dispatch");
10613static std::optional<QualType>
10616 return std::nullopt;
10622 return M->getFunctionObjectParameterReferenceType();
10636 PT2->getInstantiatedFromMemberTemplate()))
10647 assert(I < F->getNumParams());
10654 if (F1NumParams != F2NumParams)
10657 unsigned I1 = 0, I2 = 0;
10658 for (
unsigned I = 0; I != F1NumParams; ++I) {
10659 QualType T1 = NextParam(F1, I1, I == 0);
10660 QualType T2 = NextParam(F2, I2, I == 0);
10661 assert(!T1.
isNull() && !T2.
isNull() &&
"Unexpected null param types");
10662 if (!Context.hasSameUnqualifiedType(T1, T2))
10675 bool IsFn1Reversed,
10676 bool IsFn2Reversed) {
10677 assert(Fn1 && Fn2);
10682 IsFn1Reversed ^ IsFn2Reversed))
10685 auto *Mem1 = dyn_cast<CXXMethodDecl>(Fn1);
10686 auto *Mem2 = dyn_cast<CXXMethodDecl>(Fn2);
10687 if (Mem1 && Mem2) {
10690 if (Mem1->getParent() != Mem2->getParent())
10694 if (Mem1->isInstance() && Mem2->isInstance() &&
10696 Mem1->getFunctionObjectParameterReferenceType(),
10697 Mem1->getFunctionObjectParameterReferenceType()))
10703static FunctionDecl *
10705 bool IsFn1Reversed,
bool IsFn2Reversed) {
10715 if (Cand1IsSpecialization || Cand2IsSpecialization)
10732 bool PartialOverloading) {
10778 bool IsCand1ImplicitHD =
10780 bool IsCand2ImplicitHD =
10795 auto EmitThreshold =
10796 (S.
getLangOpts().CUDAIsDevice && IsCallerImplicitHD &&
10797 (IsCand1ImplicitHD || IsCand2ImplicitHD))
10800 auto Cand1Emittable = P1 > EmitThreshold;
10801 auto Cand2Emittable = P2 > EmitThreshold;
10802 if (Cand1Emittable && !Cand2Emittable)
10804 if (!Cand1Emittable && Cand2Emittable)
10815 unsigned StartArg = 0;
10823 return ICS.isStandard() &&
10835 assert(Cand2.
Conversions.size() == NumArgs &&
"Overload candidate mismatch");
10836 bool HasBetterConversion =
false;
10837 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10838 bool Cand1Bad = IsIllFormedConversion(Cand1.
Conversions[ArgIdx]);
10839 bool Cand2Bad = IsIllFormedConversion(Cand2.
Conversions[ArgIdx]);
10840 if (Cand1Bad != Cand2Bad) {
10843 HasBetterConversion =
true;
10847 if (HasBetterConversion)
10854 bool HasWorseConversion =
false;
10855 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10861 HasBetterConversion =
true;
10880 HasWorseConversion =
true;
10895 if (HasBetterConversion && !HasWorseConversion)
10946 bool Cand1IsSpecialization = Cand1.
Function &&
10948 bool Cand2IsSpecialization = Cand2.
Function &&
10950 if (Cand1IsSpecialization != Cand2IsSpecialization)
10951 return Cand2IsSpecialization;
10957 if (Cand1IsSpecialization && Cand2IsSpecialization) {
10958 const auto *Obj1Context =
10960 const auto *Obj2Context =
10989 bool Cand1IsInherited =
10991 bool Cand2IsInherited =
10993 if (Cand1IsInherited != Cand2IsInherited)
10994 return Cand2IsInherited;
10995 else if (Cand1IsInherited) {
10996 assert(Cand2IsInherited);
10999 if (Cand1Class->isDerivedFrom(Cand2Class))
11001 if (Cand2Class->isDerivedFrom(Cand1Class))
11018 auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.
Function);
11019 auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.
Function);
11020 if (Guide1 && Guide2) {
11022 if (Guide1->isImplicit() != Guide2->isImplicit())
11023 return Guide2->isImplicit();
11033 const auto *Constructor1 = Guide1->getCorrespondingConstructor();
11034 const auto *Constructor2 = Guide2->getCorrespondingConstructor();
11035 if (Constructor1 && Constructor2) {
11036 bool isC1Templated = Constructor1->getTemplatedKind() !=
11038 bool isC2Templated = Constructor2->getTemplatedKind() !=
11040 if (isC1Templated != isC2Templated)
11041 return isC2Templated;
11049 if (Cmp != Comparison::Equal)
11050 return Cmp == Comparison::Better;
11053 bool HasPS1 = Cand1.
Function !=
nullptr &&
11055 bool HasPS2 = Cand2.
Function !=
nullptr &&
11057 if (HasPS1 != HasPS2 && HasPS1)
11061 if (MV == Comparison::Better)
11063 if (MV == Comparison::Worse)
11078 const auto *CD1 = dyn_cast_or_null<CXXConstructorDecl>(Cand1.
Function);
11079 const auto *CD2 = dyn_cast_or_null<CXXConstructorDecl>(Cand2.
Function);
11081 LangAS AS1 = CD1->getMethodQualifiers().getAddressSpace();
11082 LangAS AS2 = CD2->getMethodQualifiers().getAddressSpace();
11103 auto *VA = dyn_cast_or_null<ValueDecl>(A);
11104 auto *VB = dyn_cast_or_null<ValueDecl>(B);
11110 if (!VA->getDeclContext()->getRedeclContext()->Equals(
11111 VB->getDeclContext()->getRedeclContext()) ||
11113 VA->isExternallyVisible() || VB->isExternallyVisible())
11121 if (
Context.hasSameType(VA->getType(), VB->getType()))
11126 if (
auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
11127 if (
auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
11132 if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
11133 !
Context.hasSameType(EnumA->getIntegerType(),
11134 EnumB->getIntegerType()))
11137 return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
11147 assert(D &&
"Unknown declaration");
11148 Diag(Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
11154 for (
auto *E : Equiv) {
11156 Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
11166 ->Satisfaction.ContainsErrors;
11172 bool PartialOverloading,
bool AllowExplicit,
11174 bool AggregateCandidateDeduction) {
11177 allocateDeferredCandidate<DeferredFunctionTemplateOverloadCandidate>();
11182 false, AllowExplicit, SuppressUserConversions,
11183 PartialOverloading, AggregateCandidateDeduction},
11190 HasDeferredTemplateConstructors |=
11198 bool SuppressUserConversions,
bool PartialOverloading,
11204 allocateDeferredCandidate<DeferredMethodTemplateOverloadCandidate>();
11210 false, SuppressUserConversions, PartialOverloading,
11216 ObjectClassification,
11224 bool AllowObjCConversionOnExplicit,
bool AllowExplicit,
11225 bool AllowResultConversion) {
11228 allocateDeferredCandidate<DeferredConversionTemplateOverloadCandidate>();
11232 AllowObjCConversionOnExplicit, AllowResultConversion,
11249 S, CandidateSet,
C.FunctionTemplate,
C.FoundDecl,
C.ActingContext,
11250 nullptr,
C.ObjectType,
C.ObjectClassification,
11251 C.Args,
C.SuppressUserConversions,
C.PartialOverloading,
C.PO);
11258 S, CandidateSet,
C.FunctionTemplate,
C.FoundDecl,
11259 nullptr,
C.Args,
C.SuppressUserConversions,
11260 C.PartialOverloading,
C.AllowExplicit,
C.IsADLCandidate,
C.PO,
11261 C.AggregateCandidateDeduction);
11268 S, CandidateSet,
C.FunctionTemplate,
C.FoundDecl,
C.ActingContext,
C.From,
11269 C.ToType,
C.AllowObjCConversionOnExplicit,
C.AllowExplicit,
11270 C.AllowResultConversion);
11274 Candidates.reserve(Candidates.size() + DeferredCandidatesCount);
11277 switch (Cand->
Kind) {
11296 FirstDeferredCandidate =
nullptr;
11297 DeferredCandidatesCount = 0;
11301OverloadCandidateSet::ResultForBestCandidate(
const iterator &Best) {
11303 if (Best->Function && Best->Function->isDeleted())
11308void OverloadCandidateSet::CudaExcludeWrongSideCandidates(
11325 bool ContainsSameSideCandidate =
11333 if (!ContainsSameSideCandidate)
11336 auto IsWrongSideCandidate = [&](
const OverloadCandidate *Cand) {
11342 llvm::erase_if(Candidates, IsWrongSideCandidate);
11360 DeferredCandidatesCount == 0) &&
11361 "Unexpected deferred template candidates");
11363 bool TwoPhaseResolution =
11364 DeferredCandidatesCount != 0 && !ResolutionByPerfectCandidateIsDisabled;
11366 if (TwoPhaseResolution) {
11368 if (Best !=
end() && Best->isPerfectMatch(S.
Context)) {
11369 if (!(HasDeferredTemplateConstructors &&
11370 isa_and_nonnull<CXXConversionDecl>(Best->Function)))
11376 return BestViableFunctionImpl(S, Loc, Best);
11383 Candidates.reserve(this->Candidates.size());
11384 std::transform(this->Candidates.begin(), this->Candidates.end(),
11385 std::back_inserter(Candidates),
11389 CudaExcludeWrongSideCandidates(S, Candidates);
11392 for (
auto *Cand : Candidates) {
11393 Cand->
Best =
false;
11395 if (Best ==
end() ||
11412 llvm::SmallVector<OverloadCandidate *, 4> PendingBest;
11413 llvm::SmallVector<const NamedDecl *, 4> EquivalentCands;
11414 PendingBest.push_back(&*Best);
11419 while (!PendingBest.empty()) {
11420 auto *Curr = PendingBest.pop_back_val();
11421 for (
auto *Cand : Candidates) {
11424 PendingBest.push_back(Cand);
11429 EquivalentCands.push_back(Cand->
Function);
11441 if (!EquivalentCands.empty())
11449enum OverloadCandidateKind {
11452 oc_reversed_binary_operator,
11454 oc_implicit_default_constructor,
11455 oc_implicit_copy_constructor,
11456 oc_implicit_move_constructor,
11457 oc_implicit_copy_assignment,
11458 oc_implicit_move_assignment,
11459 oc_implicit_equality_comparison,
11460 oc_inherited_constructor
11463enum OverloadCandidateSelect {
11466 ocs_described_template,
11469static std::pair<OverloadCandidateKind, OverloadCandidateSelect>
11470ClassifyOverloadCandidate(Sema &S,
const NamedDecl *
Found,
11471 const FunctionDecl *Fn,
11473 std::string &Description) {
11476 if (FunctionTemplateDecl *FunTmpl =
Fn->getPrimaryTemplate()) {
11479 FunTmpl->getTemplateParameters(), *
Fn->getTemplateSpecializationArgs());
11482 OverloadCandidateSelect Select = [&]() {
11483 if (!Description.empty())
11484 return ocs_described_template;
11485 return isTemplate ? ocs_template : ocs_non_template;
11488 OverloadCandidateKind Kind = [&]() {
11489 if (
Fn->isImplicit() &&
Fn->getOverloadedOperator() == OO_EqualEqual)
11490 return oc_implicit_equality_comparison;
11493 return oc_reversed_binary_operator;
11495 if (
const auto *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
11496 if (!Ctor->isImplicit()) {
11498 return oc_inherited_constructor;
11500 return oc_constructor;
11503 if (Ctor->isDefaultConstructor())
11504 return oc_implicit_default_constructor;
11506 if (Ctor->isMoveConstructor())
11507 return oc_implicit_move_constructor;
11509 assert(Ctor->isCopyConstructor() &&
11510 "unexpected sort of implicit constructor");
11511 return oc_implicit_copy_constructor;
11514 if (
const auto *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
11517 if (!Meth->isImplicit())
11520 if (Meth->isMoveAssignmentOperator())
11521 return oc_implicit_move_assignment;
11523 if (Meth->isCopyAssignmentOperator())
11524 return oc_implicit_copy_assignment;
11530 return oc_function;
11533 return std::make_pair(Kind, Select);
11536void MaybeEmitInheritedConstructorNote(Sema &S,
const Decl *FoundDecl) {
11539 if (
const auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
11541 diag::note_ovl_candidate_inherited_constructor)
11542 << Shadow->getNominatedBaseClass();
11551 if (EnableIf->getCond()->isValueDependent() ||
11552 !EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
11569 bool InOverloadResolution,
11573 if (InOverloadResolution)
11575 diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
11577 S.
Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
11588 if (InOverloadResolution) {
11591 TemplateArgString +=
" ";
11593 FunTmpl->getTemplateParameters(),
11598 diag::note_ovl_candidate_unsatisfied_constraints)
11599 << TemplateArgString;
11601 S.
Diag(Loc, diag::err_addrof_function_constraints_not_satisfied)
11610 return P->hasAttr<PassObjectSizeAttr>();
11617 unsigned ParamNo = std::distance(FD->
param_begin(), I) + 1;
11618 if (InOverloadResolution)
11620 diag::note_ovl_candidate_has_pass_object_size_params)
11623 S.
Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
11639 return ::checkAddressOfFunctionIsAvailable(*
this,
Function, Complain,
11647 const auto *ConvD = dyn_cast<CXXConversionDecl>(Fn);
11652 if (!RD->isLambda())
11657 CallOp->getType()->castAs<
FunctionType>()->getCallConv();
11662 return ConvToCC != CallOpCC;
11668 QualType DestType,
bool TakingAddress) {
11671 if (Fn->isMultiVersion() && Fn->hasAttr<TargetAttr>() &&
11672 !Fn->getAttr<TargetAttr>()->isDefaultVersion())
11674 if (Fn->isMultiVersion() && Fn->hasAttr<TargetVersionAttr>() &&
11675 !Fn->getAttr<TargetVersionAttr>()->isDefaultVersion())
11680 std::string FnDesc;
11681 std::pair<OverloadCandidateKind, OverloadCandidateSelect> KSPair =
11682 ClassifyOverloadCandidate(*
this,
Found, Fn, RewriteKind, FnDesc);
11684 << (
unsigned)KSPair.first << (
unsigned)KSPair.second
11688 Diag(Fn->getLocation(), PD);
11689 MaybeEmitInheritedConstructorNote(*
this,
Found);
11707 FunctionDecl *FirstCand =
nullptr, *SecondCand =
nullptr;
11708 for (
auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
11712 if (
auto *
Template = I->Function->getPrimaryTemplate())
11713 Template->getAssociatedConstraints(AC);
11715 I->Function->getAssociatedConstraints(AC);
11718 if (FirstCand ==
nullptr) {
11719 FirstCand = I->Function;
11721 }
else if (SecondCand ==
nullptr) {
11722 SecondCand = I->Function;
11735 SecondCand, SecondAC))
11744 bool TakingAddress) {
11754 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
11758 = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
11771 S.
Diag(CaretLoc, PDiag)
11773 unsigned CandsShown = 0;
11787 unsigned I,
bool TakingCandidateAddress) {
11789 assert(Conv.
isBad());
11790 assert(Cand->
Function &&
"for now, candidate must be a function");
11796 bool isObjectArgument =
false;
11800 isObjectArgument =
true;
11801 else if (!Fn->hasCXXExplicitFunctionObjectParameter())
11805 std::string FnDesc;
11806 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11817 bool HasParamPack =
11818 llvm::any_of(Fn->parameters().take_front(I), [](
const ParmVarDecl *Parm) {
11819 return Parm->isParameterPack();
11821 if (!isObjectArgument && !HasParamPack)
11822 ToParamRange = Fn->getParamDecl(I)->getSourceRange();
11825 assert(FromExpr &&
"overload set argument came from implicit argument?");
11831 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
11832 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11833 << ToParamRange << ToTy << Name << I + 1;
11834 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11843 CToTy = RT->getPointeeType();
11848 CFromTy = FromPT->getPointeeType();
11849 CToTy = ToPT->getPointeeType();
11859 if (isObjectArgument)
11860 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace_this)
11861 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11864 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
11865 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11868 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11873 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership)
11874 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11877 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11882 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc)
11883 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11886 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11891 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ptrauth)
11892 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11897 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11902 assert(CVR &&
"expected qualifiers mismatch");
11904 if (isObjectArgument) {
11905 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
11906 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11907 << FromTy << (CVR - 1);
11909 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
11910 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11911 << ToParamRange << FromTy << (CVR - 1) << I + 1;
11913 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11919 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_value_category)
11920 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11921 << (
unsigned)isObjectArgument << I + 1
11924 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11931 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
11932 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11933 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11938 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11950 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
11951 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11952 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11953 << (
unsigned)(Cand->
Fix.
Kind);
11955 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11960 unsigned BaseToDerivedConversion = 0;
11963 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11965 !FromPtrTy->getPointeeType()->isIncompleteType() &&
11966 !ToPtrTy->getPointeeType()->isIncompleteType() &&
11968 FromPtrTy->getPointeeType()))
11969 BaseToDerivedConversion = 1;
11977 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11979 FromIface->isSuperClassOf(ToIface))
11980 BaseToDerivedConversion = 2;
11982 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy,
11985 !ToRefTy->getPointeeType()->isIncompleteType() &&
11987 BaseToDerivedConversion = 3;
11991 if (BaseToDerivedConversion) {
11992 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv)
11993 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11994 << ToParamRange << (BaseToDerivedConversion - 1) << FromTy << ToTy
11996 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12005 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv)
12006 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
12007 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument
12009 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12019 FDiag << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
12020 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
12021 << (
unsigned)(Cand->
Fix.
Kind);
12030 S.
Diag(Fn->getLocation(), FDiag);
12032 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12039 unsigned NumArgs,
bool IsAddressOf =
false) {
12040 assert(Cand->
Function &&
"Candidate is required to be a function.");
12042 unsigned MinParams = Fn->getMinRequiredExplicitArguments() +
12043 ((IsAddressOf && !Fn->isStatic()) ? 1 : 0);
12050 if (Fn->isInvalidDecl() &&
12054 if (NumArgs < MinParams) {
12071 unsigned NumFormalArgs,
12072 bool IsAddressOf =
false) {
12074 "The templated declaration should at least be a function"
12075 " when diagnosing bad template argument deduction due to too many"
12076 " or too few arguments");
12082 unsigned MinParams = Fn->getMinRequiredExplicitArguments() +
12083 ((IsAddressOf && !Fn->isStatic()) ? 1 : 0);
12086 bool HasExplicitObjectParam =
12087 !IsAddressOf && Fn->hasCXXExplicitFunctionObjectParameter();
12089 unsigned ParamCount =
12090 Fn->getNumNonObjectParams() + ((IsAddressOf && !Fn->isStatic()) ? 1 : 0);
12091 unsigned mode, modeCount;
12093 if (NumFormalArgs < MinParams) {
12094 if (MinParams != ParamCount || FnTy->isVariadic() ||
12095 FnTy->isTemplateVariadic())
12099 modeCount = MinParams;
12101 if (MinParams != ParamCount)
12105 modeCount = ParamCount;
12108 std::string Description;
12109 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12110 ClassifyOverloadCandidate(S,
Found, Fn,
CRK_None, Description);
12112 if (modeCount == 1 && !IsAddressOf &&
12113 Fn->getParamDecl(HasExplicitObjectParam ? 1 : 0)->getDeclName())
12114 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one)
12115 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
12116 << Description << mode
12117 << Fn->getParamDecl(HasExplicitObjectParam ? 1 : 0) << NumFormalArgs
12118 << HasExplicitObjectParam << Fn->getParametersSourceRange();
12120 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
12121 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
12122 << Description << mode << modeCount << NumFormalArgs
12123 << HasExplicitObjectParam << Fn->getParametersSourceRange();
12125 MaybeEmitInheritedConstructorNote(S,
Found);
12130 unsigned NumFormalArgs) {
12131 assert(Cand->
Function &&
"Candidate must be a function");
12141 llvm_unreachable(
"Unsupported: Getting the described template declaration"
12142 " for bad deduction diagnosis");
12149 bool TakingCandidateAddress) {
12155 switch (DeductionFailure.
getResult()) {
12158 "TemplateDeductionResult::Success while diagnosing bad deduction");
12160 llvm_unreachable(
"TemplateDeductionResult::NonDependentConversionFailure "
12161 "while diagnosing bad deduction");
12167 assert(ParamD &&
"no parameter found for incomplete deduction result");
12169 diag::note_ovl_candidate_incomplete_deduction)
12171 MaybeEmitInheritedConstructorNote(S,
Found);
12176 assert(ParamD &&
"no parameter found for incomplete deduction result");
12178 diag::note_ovl_candidate_incomplete_deduction_pack)
12180 << (DeductionFailure.
getFirstArg()->pack_size() + 1)
12182 MaybeEmitInheritedConstructorNote(S,
Found);
12187 assert(ParamD &&
"no parameter found for bad qualifiers deduction result");
12205 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_underqualified)
12206 << ParamD->
getDeclName() << Arg << NonCanonParam;
12207 MaybeEmitInheritedConstructorNote(S,
Found);
12212 assert(ParamD &&
"no parameter found for inconsistent deduction result");
12226 diag::note_ovl_candidate_inconsistent_deduction_types)
12229 MaybeEmitInheritedConstructorNote(S,
Found);
12249 diag::note_ovl_candidate_inconsistent_deduction)
12252 MaybeEmitInheritedConstructorNote(S,
Found);
12257 assert(ParamD &&
"no parameter found for invalid explicit arguments");
12260 diag::note_ovl_candidate_explicit_arg_mismatch_named)
12265 index = TTP->getIndex();
12267 = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
12268 index = NTTP->getIndex();
12272 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
12275 MaybeEmitInheritedConstructorNote(S,
Found);
12282 TemplateArgString =
" ";
12285 if (TemplateArgString.size() == 1)
12286 TemplateArgString.clear();
12288 diag::note_ovl_candidate_unsatisfied_constraints)
12289 << TemplateArgString;
12292 static_cast<CNSInfo*
>(DeductionFailure.
Data)->Satisfaction);
12302 diag::note_ovl_candidate_instantiation_depth);
12303 MaybeEmitInheritedConstructorNote(S,
Found);
12311 TemplateArgString =
" ";
12314 if (TemplateArgString.size() == 1)
12315 TemplateArgString.clear();
12320 if (PDiag && PDiag->second.getDiagID() ==
12321 diag::err_typename_nested_not_found_enable_if) {
12324 S.
Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
12325 <<
"'enable_if'" << TemplateArgString;
12330 if (PDiag && PDiag->second.getDiagID() ==
12331 diag::err_typename_nested_not_found_requirement) {
12333 diag::note_ovl_candidate_disabled_by_requirement)
12334 << PDiag->second.getStringArg(0) << TemplateArgString;
12344 SFINAEArgString =
": ";
12346 PDiag->second.EmitToString(S.
getDiagnostics(), SFINAEArgString);
12350 diag::note_ovl_candidate_substitution_failure)
12351 << TemplateArgString << SFINAEArgString << R;
12352 MaybeEmitInheritedConstructorNote(S,
Found);
12362 TemplateArgString =
" ";
12365 if (TemplateArgString.size() == 1)
12366 TemplateArgString.clear();
12369 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_deduced_mismatch)
12372 << TemplateArgString
12397 diag::note_ovl_candidate_non_deduced_mismatch_qualified)
12413 diag::note_ovl_candidate_non_deduced_mismatch)
12414 << FirstTA << SecondTA;
12420 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_bad_deduction);
12421 MaybeEmitInheritedConstructorNote(S,
Found);
12425 diag::note_cuda_ovl_candidate_target_mismatch);
12433 bool TakingCandidateAddress) {
12434 assert(Cand->
Function &&
"Candidate must be a function");
12449 assert(Cand->
Function &&
"Candidate must be a Function.");
12455 std::string FnDesc;
12456 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12457 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Callee,
12460 S.
Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
12461 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
12463 << CalleeTarget << CallerTarget;
12468 if (Meth !=
nullptr && Meth->
isImplicit()) {
12472 switch (FnKindPair.first) {
12475 case oc_implicit_default_constructor:
12478 case oc_implicit_copy_constructor:
12481 case oc_implicit_move_constructor:
12484 case oc_implicit_copy_assignment:
12487 case oc_implicit_move_assignment:
12492 bool ConstRHS =
false;
12496 ConstRHS = RT->getPointeeType().isConstQualified();
12507 assert(Cand->
Function &&
"Candidate must be a function");
12511 S.
Diag(Callee->getLocation(),
12512 diag::note_ovl_candidate_disabled_by_function_cond_attr)
12513 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
12517 assert(Cand->
Function &&
"Candidate must be a function");
12520 assert(ES.
isExplicit() &&
"not an explicit candidate");
12523 switch (Fn->getDeclKind()) {
12524 case Decl::Kind::CXXConstructor:
12527 case Decl::Kind::CXXConversion:
12530 case Decl::Kind::CXXDeductionGuide:
12531 Kind = Fn->isImplicit() ? 0 : 2;
12534 llvm_unreachable(
"invalid Decl");
12543 First = Pattern->getFirstDecl();
12546 diag::note_ovl_candidate_explicit)
12547 << Kind << (ES.
getExpr() ? 1 : 0)
12552 auto *DG = dyn_cast<CXXDeductionGuideDecl>(Fn);
12559 if (!(DG->isImplicit() || (OriginTemplate && OriginTemplate->
isTypeAlias())))
12561 std::string FunctionProto;
12562 llvm::raw_string_ostream OS(FunctionProto);
12575 "Non-template implicit deduction guides are only possible for "
12578 S.
Diag(DG->getLocation(), diag::note_implicit_deduction_guide)
12583 assert(
Template &&
"Cannot find the associated function template of "
12584 "CXXDeductionGuideDecl?");
12587 S.
Diag(DG->getLocation(), diag::note_implicit_deduction_guide)
12608 bool TakingCandidateAddress,
12610 assert(Cand->
Function &&
"Candidate must be a function");
12618 if (S.
getLangOpts().OpenCL && Fn->isImplicit() &&
12625 !Fn->hasCXXExplicitFunctionObjectParameter() && !Fn->isStatic())
12630 if (Fn->isDeleted()) {
12631 std::string FnDesc;
12632 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12633 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12636 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
12637 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
12638 << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
12639 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12666 TakingCandidateAddress);
12669 S.
Diag(Fn->getLocation(), diag::note_ovl_candidate_illegal_constructor)
12670 << (Fn->getPrimaryTemplate() ? 1 : 0);
12671 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12678 S.
Diag(Fn->getLocation(),
12679 diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch)
12680 << QualsForPrinting;
12681 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12692 for (
unsigned N = Cand->
Conversions.size(); I != N; ++I)
12715 S.
Diag(Fn->getLocation(),
12716 diag::note_ovl_candidate_inherited_constructor_slice)
12717 << (Fn->getPrimaryTemplate() ? 1 : 0)
12718 << Fn->getParamDecl(0)->getType()->isRValueReferenceType();
12719 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12725 assert(!Available);
12733 std::string FnDesc;
12734 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12735 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12738 S.
Diag(Fn->getLocation(),
12739 diag::note_ovl_candidate_constraints_not_satisfied)
12740 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
12759 bool isLValueReference =
false;
12760 bool isRValueReference =
false;
12761 bool isPointer =
false;
12765 isLValueReference =
true;
12769 isRValueReference =
true;
12785 diag::note_ovl_surrogate_constraints_not_satisfied)
12799 assert(Cand->
Conversions.size() <= 2 &&
"builtin operator is not binary");
12800 std::string TypeStr(
"operator");
12806 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12811 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12818 if (ICS.
isBad())
break;
12822 S, OpLoc, S.
PDiag(diag::note_ambiguous_type_conversion));
12839 llvm_unreachable(
"non-deduction failure while diagnosing bad deduction");
12869 llvm_unreachable(
"Unhandled deduction result");
12874struct CompareOverloadCandidatesForDisplay {
12876 SourceLocation Loc;
12880 CompareOverloadCandidatesForDisplay(
12881 Sema &S, SourceLocation Loc,
size_t NArgs,
12883 : S(S), NumArgs(NArgs), CSK(CSK) {}
12893 if (NumArgs >
C->Function->getNumParams() && !
C->Function->isVariadic())
12895 if (NumArgs < C->
Function->getMinRequiredArguments())
12902 bool operator()(
const OverloadCandidate *L,
12903 const OverloadCandidate *R) {
12905 if (L == R)
return false;
12909 if (!R->
Viable)
return true;
12911 if (
int Ord = CompareConversions(*L, *R))
12931 if (LDist == RDist) {
12932 if (LFailureKind == RFailureKind)
12940 return LDist < RDist;
12958 numLFixes = (numLFixes == 0) ?
UINT_MAX : numLFixes;
12959 numRFixes = (numRFixes == 0) ?
UINT_MAX : numRFixes;
12960 if (numLFixes != numRFixes) {
12961 return numLFixes < numRFixes;
12965 if (
int Ord = CompareConversions(*L, *R))
12977 if (LRank != RRank)
12978 return LRank < RRank;
13004 struct ConversionSignals {
13005 unsigned KindRank = 0;
13008 static ConversionSignals ForSequence(ImplicitConversionSequence &
Seq) {
13009 ConversionSignals Sig;
13010 Sig.KindRank =
Seq.getKindRank();
13011 if (
Seq.isStandard())
13012 Sig.Rank =
Seq.Standard.getRank();
13013 else if (
Seq.isUserDefined())
13014 Sig.Rank =
Seq.UserDefined.After.getRank();
13020 static ConversionSignals ForObjectArgument() {
13030 int CompareConversions(
const OverloadCandidate &L,
13031 const OverloadCandidate &R) {
13036 for (
unsigned I = 0, N = L.
Conversions.size(); I != N; ++I) {
13038 ? ConversionSignals::ForObjectArgument()
13039 : ConversionSignals::ForSequence(L.Conversions[I]);
13041 ? ConversionSignals::ForObjectArgument()
13042 : ConversionSignals::ForSequence(R.Conversions[I]);
13043 if (std::tie(LS.KindRank, LS.Rank) != std::tie(RS.KindRank, RS.Rank))
13044 return std::tie(LS.KindRank, LS.Rank) < std::tie(RS.KindRank, RS.Rank)
13069 bool Unfixable =
false;
13075 for (
unsigned ConvIdx =
13079 assert(ConvIdx != ConvCount &&
"no bad conversion in candidate");
13080 if (Cand->
Conversions[ConvIdx].isInitialized() &&
13089 bool SuppressUserConversions =
false;
13091 unsigned ConvIdx = 0;
13092 unsigned ArgIdx = 0;
13121 assert(ConvCount <= 3);
13127 ConvIdx != ConvCount && ArgIdx < Args.size();
13129 if (Cand->
Conversions[ConvIdx].isInitialized()) {
13131 }
else if (
ParamIdx < ParamTypes.size()) {
13132 if (ParamTypes[
ParamIdx]->isDependentType())
13133 Cand->
Conversions[ConvIdx].setAsIdentityConversion(
13138 SuppressUserConversions,
13143 if (!Unfixable && Cand->
Conversions[ConvIdx].isBad())
13162 for (
iterator Cand = Candidates.begin(), LastCand = Candidates.end();
13163 Cand != LastCand; ++Cand) {
13164 if (!Filter(*Cand))
13189 Cands.push_back(Cand);
13193 Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
13200 bool DeferHint =
false;
13204 auto WrongSidedCands =
13206 return (Cand.
Viable ==
false &&
13212 DeferHint = !WrongSidedCands.empty();
13230 bool NoteCands =
true;
13231 for (
const Expr *Arg : Args) {
13232 if (Arg->getType()->isWebAssemblyTableType())
13241 {Candidates.begin(), Candidates.end()});
13247 bool ReportedAmbiguousConversions =
false;
13250 unsigned CandsShown = 0;
13251 auto I = Cands.begin(), E = Cands.end();
13252 for (; I != E; ++I) {
13268 "Non-viable built-in candidates are not added to Cands.");
13275 if (!ReportedAmbiguousConversions) {
13277 ReportedAmbiguousConversions =
true;
13290 S.
Diag(OpLoc, diag::note_ovl_too_many_candidates,
13302struct CompareTemplateSpecCandidatesForDisplay {
13304 CompareTemplateSpecCandidatesForDisplay(Sema &S) : S(S) {}
13306 bool operator()(
const TemplateSpecCandidate *L,
13307 const TemplateSpecCandidate *R) {
13338 bool ForTakingAddress) {
13343void TemplateSpecCandidateSet::destroyCandidates() {
13345 i->DeductionFailure.Destroy();
13350 destroyCandidates();
13351 Candidates.clear();
13364 Cands.reserve(
size());
13365 for (
iterator Cand =
begin(), LastCand =
end(); Cand != LastCand; ++Cand) {
13366 if (Cand->Specialization)
13367 Cands.push_back(Cand);
13372 llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S));
13379 unsigned CandsShown = 0;
13380 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
13386 if (CandsShown >= 4 && ShowOverloads ==
Ovl_Best)
13391 "Non-matching built-in candidates are not added to Cands.");
13396 S.
Diag(Loc, diag::note_ovl_too_many_candidates) <<
int(E - I);
13406 QualType Ret = PossiblyAFunctionType;
13409 Ret = ToTypePtr->getPointeeType();
13412 Ret = ToTypeRef->getPointeeType();
13415 Ret = MemTypePtr->getPointeeType();
13417 Context.getCanonicalType(Ret).getUnqualifiedType();
13422 bool Complain =
true) {
13439class AddressOfFunctionResolver {
13442 const QualType& TargetType;
13443 QualType TargetFunctionType;
13447 ASTContext& Context;
13449 bool TargetTypeIsNonStaticMemberFunction;
13450 bool FoundNonTemplateFunction;
13451 bool StaticMemberFunctionFromBoundPointer;
13452 bool HasComplained;
13454 OverloadExpr::FindResult OvlExprInfo;
13455 OverloadExpr *OvlExpr;
13456 TemplateArgumentListInfo OvlExplicitTemplateArgs;
13457 SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches;
13458 TemplateSpecCandidateSet FailedCandidates;
13461 AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
13462 const QualType &TargetType,
bool Complain)
13463 : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
13464 Complain(Complain), Context(S.getASTContext()),
13465 TargetTypeIsNonStaticMemberFunction(
13466 !!TargetType->getAs<MemberPointerType>()),
13467 FoundNonTemplateFunction(
false),
13468 StaticMemberFunctionFromBoundPointer(
false),
13469 HasComplained(
false),
13470 OvlExprInfo(OverloadExpr::find(SourceExpr)),
13472 FailedCandidates(OvlExpr->getNameLoc(),
true) {
13473 ExtractUnqualifiedFunctionTypeFromTargetType();
13476 if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
13477 if (!UME->isImplicitAccess() &&
13479 StaticMemberFunctionFromBoundPointer =
true;
13481 DeclAccessPair dap;
13483 OvlExpr,
false, &dap)) {
13484 if (CXXMethodDecl *
Method = dyn_cast<CXXMethodDecl>(Fn))
13485 if (!
Method->isStatic()) {
13489 TargetTypeIsNonStaticMemberFunction =
true;
13497 Matches.push_back(std::make_pair(dap, Fn));
13505 if (FindAllFunctionsThatMatchTargetTypeExactly()) {
13508 if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
13509 if (FoundNonTemplateFunction) {
13510 EliminateAllTemplateMatches();
13511 EliminateLessPartialOrderingConstrainedMatches();
13513 EliminateAllExceptMostSpecializedTemplate();
13518 EliminateSuboptimalCudaMatches();
13521 bool hasComplained()
const {
return HasComplained; }
13524 bool candidateHasExactlyCorrectType(
const FunctionDecl *FD) {
13531 bool isBetterCandidate(
const FunctionDecl *A,
const FunctionDecl *B) {
13535 return candidateHasExactlyCorrectType(A) &&
13536 (!candidateHasExactlyCorrectType(B) ||
13542 bool eliminiateSuboptimalOverloadCandidates() {
13545 auto Best = Matches.begin();
13546 for (
auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
13547 if (isBetterCandidate(I->second, Best->second))
13550 const FunctionDecl *BestFn = Best->second;
13551 auto IsBestOrInferiorToBest = [
this, BestFn](
13552 const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
13553 return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
13558 if (!llvm::all_of(Matches, IsBestOrInferiorToBest))
13560 Matches[0] = *Best;
13565 bool isTargetTypeAFunction()
const {
13574 void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
13580 const DeclAccessPair& CurAccessFunPair) {
13581 if (CXXMethodDecl *
Method
13585 bool CanConvertToFunctionPointer =
13586 Method->isStatic() ||
Method->isExplicitObjectMemberFunction();
13587 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13590 else if (TargetTypeIsNonStaticMemberFunction)
13600 TemplateDeductionInfo Info(FailedCandidates.
getLocation());
13604 Result != TemplateDeductionResult::Success) {
13622 Matches.push_back(std::make_pair(CurAccessFunPair,
Specialization));
13626 bool AddMatchingNonTemplateFunction(NamedDecl* Fn,
13627 const DeclAccessPair& CurAccessFunPair) {
13628 if (CXXMethodDecl *
Method = dyn_cast<CXXMethodDecl>(Fn)) {
13631 bool CanConvertToFunctionPointer =
13632 Method->isStatic() ||
Method->isExplicitObjectMemberFunction();
13633 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13636 else if (TargetTypeIsNonStaticMemberFunction)
13639 if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
13646 if (FunDecl->isMultiVersion()) {
13647 const auto *TA = FunDecl->getAttr<TargetAttr>();
13648 if (TA && !TA->isDefaultVersion())
13650 const auto *TVA = FunDecl->getAttr<TargetVersionAttr>();
13651 if (TVA && !TVA->isDefaultVersion())
13659 HasComplained |= Complain;
13668 candidateHasExactlyCorrectType(FunDecl)) {
13669 Matches.push_back(std::make_pair(
13671 FoundNonTemplateFunction =
true;
13679 bool FindAllFunctionsThatMatchTargetTypeExactly() {
13684 if (IsInvalidFormOfPointerToMemberFunction())
13687 for (UnresolvedSetIterator I = OvlExpr->
decls_begin(),
13691 NamedDecl *
Fn = (*I)->getUnderlyingDecl();
13700 = dyn_cast<FunctionTemplateDecl>(Fn)) {
13706 AddMatchingNonTemplateFunction(Fn, I.getPair()))
13709 assert(Ret || Matches.empty());
13713 void EliminateAllExceptMostSpecializedTemplate() {
13725 UnresolvedSet<4> MatchesCopy;
13726 for (
unsigned I = 0, E = Matches.size(); I != E; ++I)
13727 MatchesCopy.
addDecl(Matches[I].second, Matches[I].first.getAccess());
13732 MatchesCopy.
begin(), MatchesCopy.
end(), FailedCandidates,
13734 S.
PDiag(diag::err_addr_ovl_ambiguous)
13735 << Matches[0].second->getDeclName(),
13736 S.
PDiag(diag::note_ovl_candidate)
13737 << (
unsigned)oc_function << (
unsigned)ocs_described_template,
13738 Complain, TargetFunctionType);
13742 Matches[0].first = Matches[
Result - MatchesCopy.
begin()].first;
13746 HasComplained |= Complain;
13749 void EliminateAllTemplateMatches() {
13752 for (
unsigned I = 0, N = Matches.size(); I != N; ) {
13753 if (Matches[I].second->getPrimaryTemplate() ==
nullptr)
13756 Matches[I] = Matches[--N];
13762 void EliminateLessPartialOrderingConstrainedMatches() {
13767 assert(Matches[0].second->getPrimaryTemplate() ==
nullptr &&
13768 "Call EliminateAllTemplateMatches() first");
13769 SmallVector<std::pair<DeclAccessPair, FunctionDecl *>, 4> Results;
13770 Results.push_back(Matches[0]);
13771 for (
unsigned I = 1, N = Matches.size(); I < N; ++I) {
13772 assert(Matches[I].second->getPrimaryTemplate() ==
nullptr);
13774 S, Matches[I].second, Results[0].second,
13778 Results.push_back(Matches[I]);
13781 if (F == Matches[I].second) {
13783 Results.push_back(Matches[I]);
13786 std::swap(Matches, Results);
13789 void EliminateSuboptimalCudaMatches() {
13795 void ComplainNoMatchesFound()
const {
13796 assert(Matches.empty());
13798 << OvlExpr->
getName() << TargetFunctionType
13800 if (FailedCandidates.
empty())
13807 for (UnresolvedSetIterator I = OvlExpr->
decls_begin(),
13810 if (FunctionDecl *Fun =
13811 dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
13819 bool IsInvalidFormOfPointerToMemberFunction()
const {
13820 return TargetTypeIsNonStaticMemberFunction &&
13824 void ComplainIsInvalidFormOfPointerToMemberFunction()
const {
13832 bool IsStaticMemberFunctionFromBoundPointer()
const {
13833 return StaticMemberFunctionFromBoundPointer;
13836 void ComplainIsStaticMemberFunctionFromBoundPointer()
const {
13838 diag::err_invalid_form_pointer_member_function)
13842 void ComplainOfInvalidConversion()
const {
13844 << OvlExpr->
getName() << TargetType;
13847 void ComplainMultipleMatchesFound()
const {
13848 assert(Matches.size() > 1);
13855 bool hadMultipleCandidates()
const {
return (OvlExpr->
getNumDecls() > 1); }
13857 int getNumMatches()
const {
return Matches.size(); }
13859 FunctionDecl* getMatchingFunctionDecl()
const {
13860 if (Matches.size() != 1)
return nullptr;
13861 return Matches[0].second;
13864 const DeclAccessPair* getMatchingFunctionAccessPair()
const {
13865 if (Matches.size() != 1)
return nullptr;
13866 return &Matches[0].first;
13876 bool *pHadMultipleCandidates) {
13879 AddressOfFunctionResolver Resolver(*
this, AddressOfExpr, TargetType,
13881 int NumMatches = Resolver.getNumMatches();
13883 bool ShouldComplain = Complain && !Resolver.hasComplained();
13884 if (NumMatches == 0 && ShouldComplain) {
13885 if (Resolver.IsInvalidFormOfPointerToMemberFunction())
13886 Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
13888 Resolver.ComplainNoMatchesFound();
13890 else if (NumMatches > 1 && ShouldComplain)
13891 Resolver.ComplainMultipleMatchesFound();
13892 else if (NumMatches == 1) {
13893 Fn = Resolver.getMatchingFunctionDecl();
13897 FoundResult = *Resolver.getMatchingFunctionAccessPair();
13899 if (Resolver.IsStaticMemberFunctionFromBoundPointer())
13900 Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
13906 if (pHadMultipleCandidates)
13907 *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
13915 bool IsResultAmbiguous =
false;
13923 return static_cast<int>(
CUDA().IdentifyPreference(Caller, FD1)) -
13924 static_cast<int>(
CUDA().IdentifyPreference(Caller, FD2));
13931 auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
13939 auto FoundBetter = [&]() {
13940 IsResultAmbiguous =
false;
13952 int PreferenceByCUDA = CheckCUDAPreference(FD,
Result);
13954 if (PreferenceByCUDA != 0) {
13956 if (PreferenceByCUDA > 0)
13972 if (MoreConstrained != FD) {
13973 if (!MoreConstrained) {
13974 IsResultAmbiguous =
true;
13975 AmbiguousDecls.push_back(FD);
13984 if (IsResultAmbiguous)
14005 ExprResult &SrcExpr,
bool DoFunctionPointerConversion) {
14007 assert(E->
getType() ==
Context.OverloadTy &&
"SrcExpr must be an overload");
14011 if (!
Found ||
Found->isCPUDispatchMultiVersion() ||
14012 Found->isCPUSpecificMultiVersion())
14060 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
14091 if (ForTypeDeduction &&
14105 if (FoundResult) *FoundResult = I.getPair();
14116 ExprResult &SrcExpr,
bool doFunctionPointerConversion,
bool complain,
14118 unsigned DiagIDForComplaining) {
14139 if (!complain)
return false;
14142 diag::err_bound_member_function)
14155 SingleFunctionExpression =
14159 if (doFunctionPointerConversion) {
14160 SingleFunctionExpression =
14162 if (SingleFunctionExpression.
isInvalid()) {
14169 if (!SingleFunctionExpression.
isUsable()) {
14171 Diag(OpRangeForComplaining.
getBegin(), DiagIDForComplaining)
14173 << DestTypeForComplaining
14174 << OpRangeForComplaining
14185 SrcExpr = SingleFunctionExpression;
14195 bool PartialOverloading,
14202 if (ExplicitTemplateArgs) {
14203 assert(!KnownValid &&
"Explicit template arguments?");
14212 PartialOverloading);
14217 = dyn_cast<FunctionTemplateDecl>(Callee)) {
14219 ExplicitTemplateArgs, Args, CandidateSet,
14221 PartialOverloading);
14225 assert(!KnownValid &&
"unhandled case in overloaded call candidate");
14231 bool PartialOverloading) {
14254 assert(!(*I)->getDeclContext()->isRecord());
14256 !(*I)->getDeclContext()->isFunctionOrMethod());
14257 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
14267 ExplicitTemplateArgs = &TABuffer;
14273 CandidateSet, PartialOverloading,
14278 Args, ExplicitTemplateArgs,
14279 CandidateSet, PartialOverloading);
14287 CandidateSet,
false,
false);
14294 case OO_New:
case OO_Array_New:
14295 case OO_Delete:
case OO_Array_Delete:
14318 if (DC->isTransparentContext())
14334 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC)) {
14339 if (FoundInClass) {
14340 *FoundInClass = RD;
14343 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
14360 AssociatedNamespaces,
14361 AssociatedClasses);
14365 for (Sema::AssociatedNamespaceSet::iterator
14366 it = AssociatedNamespaces.begin(),
14367 end = AssociatedNamespaces.end(); it !=
end; ++it) {
14379 SuggestedNamespaces.insert(*it);
14383 SemaRef.
Diag(R.
getNameLoc(), diag::err_not_found_by_two_phase_lookup)
14385 if (SuggestedNamespaces.empty()) {
14386 SemaRef.
Diag(Best->Function->getLocation(),
14387 diag::note_not_found_by_two_phase_lookup)
14389 }
else if (SuggestedNamespaces.size() == 1) {
14390 SemaRef.
Diag(Best->Function->getLocation(),
14391 diag::note_not_found_by_two_phase_lookup)
14397 SemaRef.
Diag(Best->Function->getLocation(),
14398 diag::note_not_found_by_two_phase_lookup)
14430class BuildRecoveryCallExprRAII {
14432 Sema::SatisfactionStackResetRAII SatStack;
14435 BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S), SatStack(S) {
14457 bool EmptyLookup,
bool AllowTypoCorrection) {
14465 BuildRecoveryCallExprRAII RCE(SemaRef);
14475 ExplicitTemplateArgs = &TABuffer;
14483 ExplicitTemplateArgs, Args, &FoundInClass)) {
14485 }
else if (EmptyLookup) {
14490 ExplicitTemplateArgs !=
nullptr,
14491 dyn_cast<MemberExpr>(Fn));
14493 AllowTypoCorrection
14499 }
else if (FoundInClass && SemaRef.
getLangOpts().MSVCCompat) {
14514 assert(!R.
empty() &&
"lookup results empty despite recovery");
14525 if ((*R.
begin())->isCXXClassMember())
14527 ExplicitTemplateArgs, S);
14528 else if (ExplicitTemplateArgs || TemplateKWLoc.
isValid())
14530 ExplicitTemplateArgs);
14554 assert(!ULE->
getQualifier() &&
"qualified name with ADL");
14561 (F = dyn_cast<FunctionDecl>(*ULE->
decls_begin())) &&
14563 llvm_unreachable(
"performing ADL for builtin");
14570 UnbridgedCastsSet UnbridgedCasts;
14585 if (CandidateSet->
empty() ||
14601 if (CandidateSet->
empty())
14604 UnbridgedCasts.restore();
14611 std::optional<QualType> Result;
14623 else if (Result !=
T)
14631 if (Best && *Best != CS.
end())
14632 ConsiderCandidate(**Best);
14635 for (
const auto &
C : CS)
14637 ConsiderCandidate(
C);
14640 for (
const auto &
C : CS)
14641 ConsiderCandidate(
C);
14645 auto Value = *Result;
14646 if (
Value.isNull() ||
Value->isUndeducedType())
14663 bool AllowTypoCorrection) {
14664 switch (OverloadResult) {
14675 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14681 if (*Best != CandidateSet->
end() &&
14685 dyn_cast_if_present<CXXMethodDecl>((*Best)->Function);
14690 SemaRef.
PDiag(diag::err_member_call_without_object) << 0 << M),
14700 CandidateSet->
empty(),
14701 AllowTypoCorrection);
14708 for (
const Expr *Arg : Args) {
14709 if (!Arg->getType()->isFunctionType())
14711 if (
auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
14712 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
14715 Arg->getExprLoc()))
14723 SemaRef.
PDiag(diag::err_ovl_no_viable_function_in_call)
14724 << ULE->
getName() << Fn->getSourceRange()),
14732 SemaRef.
PDiag(diag::err_ovl_ambiguous_call)
14733 << ULE->
getName() << Fn->getSourceRange()),
14740 Fn->getSourceRange(), ULE->
getName(),
14741 *CandidateSet, FDecl, Args);
14750 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14758 SubExprs.append(Args.begin(), Args.end());
14765 for (
auto I = CS.
begin(), E = CS.
end(); I != E; ++I) {
14780 bool AllowTypoCorrection,
14781 bool CalleesAddressIsTaken) {
14796 if (CalleesAddressIsTaken)
14807 Best != CandidateSet.
end()) {
14808 if (
auto *M = dyn_cast_or_null<CXXMethodDecl>(Best->Function);
14809 M && M->isImplicitObjectMemberFunction()) {
14820 CUDA().recordPotentialODRUsedVariable(Args, CandidateSet);
14838 if (
const auto *TP =
14848 ExecConfig, &CandidateSet, &Best,
14849 OverloadResult, AllowTypoCorrection);
14858 Context, NamingClass, NNSLoc, DNI, PerformADL, Fns.
begin(), Fns.
end(),
14864 bool HadMultipleCandidates) {
14874 if (
Method->isExplicitObjectMemberFunction())
14878 E, std::nullopt, FoundDecl,
Method);
14882 if (
Method->getParent()->isLambda() &&
14883 Method->getConversionType()->isBlockPointerType()) {
14887 auto *CE = dyn_cast<CastExpr>(SubE);
14888 if (CE && CE->getCastKind() == CK_NoOp)
14889 SubE = CE->getSubExpr();
14891 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
14892 SubE = BE->getSubExpr();
14915 if (
Method->isExplicitObjectMemberFunction()) {
14921 Expr *ObjectParam = Exp.
get();
14935 Exp.
get()->getEndLoc(),
14949 Expr *Input,
bool PerformADL) {
14951 assert(Op !=
OO_None &&
"Invalid opcode for overloaded unary operator");
14959 Expr *Args[2] = { Input,
nullptr };
14960 unsigned NumArgs = 1;
14965 if (Opc == UO_PostInc || Opc == UO_PostDec) {
14979 if (Opc == UO_PreDec || Opc == UO_PreInc || Opc == UO_Deref)
14990 if (Fn.isInvalid())
15016 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15035 if (
Method->isExplicitObjectMemberFunction())
15039 Input, std::nullopt, Best->FoundDecl,
Method);
15042 Base = Input = InputInit.
get();
15053 Input = InputInit.
get();
15058 Base, HadMultipleCandidates,
15070 Context, Op, FnExpr.
get(), ArgsArray, ResultTy,
VK, OpLoc,
15086 Input, Best->BuiltinParamTypes[0], Best->Conversions[0],
15091 Input = InputRes.
get();
15111 PDiag(diag::err_ovl_ambiguous_oper_unary)
15128 << (Msg !=
nullptr)
15129 << (Msg ? Msg->
getString() : StringRef())
15182 if (Op != OO_Equal && PerformADL) {
15189 Context.DeclarationNames.getCXXOperatorName(ExtraOp);
15215 Expr *RHS,
bool PerformADL,
15216 bool AllowRewrittenCandidates,
15218 Expr *Args[2] = { LHS, RHS };
15222 AllowRewrittenCandidates =
false;
15228 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
15249 if (Fn.isInvalid())
15258 if (Opc == BO_PtrMemD) {
15259 auto CheckPlaceholder = [&](
Expr *&Arg) {
15268 if (CheckPlaceholder(Args[0]) || CheckPlaceholder(Args[1]))
15289 if (Opc == BO_Assign && !Args[0]->
getType()->isOverloadableType())
15295 Op, OpLoc, AllowRewrittenCandidates));
15297 CandidateSet.
exclude(DefaultedFn);
15300 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15309 bool IsReversed = Best->isReversed();
15311 std::swap(Args[0], Args[1]);
15328 if (Best->RewriteKind && ChosenOp == OO_EqualEqual &&
15332 Diag(OpLoc, IsExtension ? diag::ext_ovl_rewrite_equalequal_not_bool
15333 : diag::err_ovl_rewrite_equalequal_not_bool)
15341 if (AllowRewrittenCandidates && !IsReversed &&
15351 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
15354 Best->Conversions[ArgIdx]) ==
15356 AmbiguousWith.push_back(Cand.
Function);
15363 if (!AmbiguousWith.empty()) {
15364 bool AmbiguousWithSelf =
15365 AmbiguousWith.size() == 1 &&
15367 Diag(OpLoc, diag::ext_ovl_ambiguous_oper_binary_reversed)
15369 << Args[0]->
getType() << Args[1]->
getType() << AmbiguousWithSelf
15371 if (AmbiguousWithSelf) {
15373 diag::note_ovl_ambiguous_oper_binary_reversed_self);
15378 if (
auto *MD = dyn_cast<CXXMethodDecl>(FnDecl))
15379 if (Op == OverloadedOperatorKind::OO_EqualEqual &&
15381 !MD->hasCXXExplicitFunctionObjectParameter() &&
15382 Context.hasSameUnqualifiedType(
15383 MD->getFunctionObjectParameterType(),
15384 MD->getParamDecl(0)->getType().getNonReferenceType()) &&
15385 Context.hasSameUnqualifiedType(
15386 MD->getFunctionObjectParameterType(),
15388 Context.hasSameUnqualifiedType(
15389 MD->getFunctionObjectParameterType(),
15392 diag::note_ovl_ambiguous_eqeq_reversed_self_non_const);
15395 diag::note_ovl_ambiguous_oper_binary_selected_candidate);
15396 for (
auto *F : AmbiguousWith)
15398 diag::note_ovl_ambiguous_oper_binary_reversed_candidate);
15406 if (Op == OO_Equal)
15417 if (
Method->isExplicitObjectMemberFunction()) {
15422 Args[0], std::nullopt, Best->FoundDecl,
Method);
15455 Best->FoundDecl,
Base,
15456 HadMultipleCandidates, OpLoc);
15467 const Expr *ImplicitThis =
nullptr;
15472 Context, ChosenOp, FnExpr.
get(), Args, ResultTy,
VK, OpLoc,
15476 if (
const auto *
Method = dyn_cast<CXXMethodDecl>(FnDecl);
15479 ImplicitThis = ArgsArray[0];
15480 ArgsArray = ArgsArray.slice(1);
15487 if (Op == OO_Equal) {
15492 *
this,
AssignedEntity{Args[0], dyn_cast<CXXMethodDecl>(FnDecl)},
15495 if (ImplicitThis) {
15500 CheckArgAlignment(OpLoc, FnDecl,
"'this'", ThisType,
15504 checkCall(FnDecl,
nullptr, ImplicitThis, ArgsArray,
15519 (Op == OO_Spaceship && IsReversed)) {
15520 if (Op == OO_ExclaimEqual) {
15521 assert(ChosenOp == OO_EqualEqual &&
"unexpected operator name");
15524 assert(ChosenOp == OO_Spaceship &&
"unexpected operator name");
15526 Expr *ZeroLiteral =
15535 OpLoc, Opc, Fns, IsReversed ? ZeroLiteral : R.
get(),
15536 IsReversed ? R.
get() : ZeroLiteral,
true,
15544 assert(ChosenOp == Op &&
"unexpected operator name");
15548 if (Best->RewriteKind !=
CRK_None)
15557 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
15562 Args[0] = ArgsRes0.
get();
15565 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
15570 Args[1] = ArgsRes1.
get();
15580 if (Opc == BO_Comma)
15585 if (DefaultedFn && Opc == BO_Cmp) {
15587 Args[1], DefaultedFn);
15602 Opc >= BO_Assign && Opc <= BO_OrAssign) {
15603 Diag(OpLoc, diag::err_ovl_no_viable_oper)
15606 if (Args[0]->
getType()->isIncompleteType()) {
15607 Diag(OpLoc, diag::note_assign_lhs_incomplete)
15623 assert(
Result.isInvalid() &&
15624 "C++ binary operator overloading is missing candidates!");
15635 << Args[0]->getSourceRange()
15636 << Args[1]->getSourceRange()),
15646 Diag(OpLoc, diag::err_ovl_deleted_special_oper)
15650 Diag(OpLoc, diag::err_ovl_deleted_comparison)
15651 << Args[0]->
getType() << DeletedFD;
15664 PDiag(diag::err_ovl_deleted_oper)
15666 .getCXXOverloadedOperator())
15667 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef())
15668 << Args[0]->getSourceRange() << Args[1]->getSourceRange()),
15692 "cannot use prvalue expressions more than once");
15693 Expr *OrigLHS = LHS;
15694 Expr *OrigRHS = RHS;
15707 if (
Eq.isInvalid())
15711 true, DefaultedFn);
15712 if (
Less.isInvalid())
15739 for (; I >= 0; --I) {
15741 auto *VI = Info->lookupValueInfo(Comparisons[I].
Result);
15764 Context, OrigLHS, OrigRHS, BO_Cmp,
Result.get()->getType(),
15765 Result.get()->getValueKind(),
Result.get()->getObjectKind(), OpLoc,
15767 Expr *SemanticForm[] = {LHS, RHS,
Result.get()};
15777 unsigned NumArgsSlots =
15778 MethodArgs.size() + std::max<unsigned>(Args.size(), NumParams);
15781 MethodArgs.reserve(MethodArgs.size() + NumArgsSlots);
15782 bool IsError =
false;
15785 for (
unsigned i = 0; i != NumParams; i++) {
15787 if (i < Args.size()) {
15791 S.
Context, Method->getParamDecl(i)),
15805 MethodArgs.push_back(Arg);
15815 Args.push_back(
Base);
15816 for (
auto *e : ArgExpr) {
15820 Context.DeclarationNames.getCXXOperatorName(OO_Subscript);
15825 ArgExpr.back()->getEndLoc());
15837 if (Fn.isInvalid())
15847 UnbridgedCastsSet UnbridgedCasts;
15860 if (Args.size() == 2)
15863 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15883 if (
Method->isExplicitObjectMemberFunction()) {
15888 Args[0] = Res.
get();
15892 Args[0], std::nullopt, Best->FoundDecl,
Method);
15896 MethodArgs.push_back(Arg0.
get());
15900 *
this, MethodArgs,
Method, ArgExpr, LLoc);
15908 *
this, FnDecl, Best->FoundDecl,
Base, HadMultipleCandidates,
15919 Context, OO_Subscript, FnExpr.
get(), MethodArgs, ResultTy,
VK, RLoc,
15936 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
15941 Args[0] = ArgsRes0.
get();
15944 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
15949 Args[1] = ArgsRes1.
get();
15957 CandidateSet.
empty()
15958 ? (
PDiag(diag::err_ovl_no_oper)
15959 << Args[0]->getType() << 0
15960 << Args[0]->getSourceRange() << Range)
15961 : (
PDiag(diag::err_ovl_no_viable_subscript)
15962 << Args[0]->getType() << Args[0]->getSourceRange() << Range);
15969 if (Args.size() == 2) {
15972 LLoc,
PDiag(diag::err_ovl_ambiguous_oper_binary)
15974 << Args[0]->getSourceRange() << Range),
15979 PDiag(diag::err_ovl_ambiguous_subscript_call)
15981 << Args[0]->getSourceRange() << Range),
15990 PDiag(diag::err_ovl_deleted_oper)
15991 <<
"[]" << (Msg !=
nullptr)
15992 << (Msg ? Msg->
getString() : StringRef())
15993 << Args[0]->getSourceRange() << Range),
16007 Expr *ExecConfig,
bool IsExecConfig,
16008 bool AllowRecovery) {
16017 if (
BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
16018 assert(op->getType() ==
Context.BoundMemberTy);
16019 assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
16032 QualType objectType = op->getLHS()->getType();
16033 if (op->getOpcode() == BO_PtrMemI)
16037 Qualifiers difference = objectQuals - funcQuals;
16041 std::string qualsString = difference.
getAsString();
16042 Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
16045 << (qualsString.find(
' ') == std::string::npos ? 1 : 2);
16049 Context, MemExprE, Args, resultType, valueKind, RParenLoc,
16059 if (CheckOtherCall(call, proto))
16069 if (!AllowRecovery)
16071 std::vector<Expr *> SubExprs = {MemExprE};
16072 llvm::append_range(SubExprs, Args);
16080 UnbridgedCastsSet UnbridgedCasts;
16086 bool HadMultipleCandidates =
false;
16094 UnbridgedCasts.restore();
16112 TemplateArgs = &TemplateArgsBuffer;
16116 E = UnresExpr->
decls_end(); I != E; ++I) {
16118 QualType ExplicitObjectType = ObjectType;
16125 bool HasExplicitParameter =
false;
16126 if (
const auto *M = dyn_cast<FunctionDecl>(
Func);
16127 M && M->hasCXXExplicitFunctionObjectParameter())
16128 HasExplicitParameter =
true;
16129 else if (
const auto *M = dyn_cast<FunctionTemplateDecl>(
Func);
16131 M->getTemplatedDecl()->hasCXXExplicitFunctionObjectParameter())
16132 HasExplicitParameter =
true;
16134 if (HasExplicitParameter)
16142 }
else if ((
Method = dyn_cast<CXXMethodDecl>(
Func))) {
16149 ObjectClassification, Args, CandidateSet,
16153 I.getPair(), ActingDC, TemplateArgs,
16154 ExplicitObjectType, ObjectClassification,
16155 Args, CandidateSet,
16160 HadMultipleCandidates = (CandidateSet.
size() > 1);
16164 UnbridgedCasts.restore();
16167 bool Succeeded =
false;
16172 FoundDecl = Best->FoundDecl;
16192 PDiag(diag::err_ovl_no_viable_member_function_in_call)
16199 PDiag(diag::err_ovl_ambiguous_member_call)
16206 CandidateSet, Best->Function, Args,
true);
16217 MemExprE = Res.
get();
16221 if (
Method->isStatic()) {
16223 ExecConfig, IsExecConfig);
16233 assert(
Method &&
"Member call to something that isn't a method?");
16238 if (
Method->isExplicitObjectMemberFunction()) {
16246 HadMultipleCandidates, MemExpr->
getExprLoc());
16253 TheCall->setUsesMemberSyntax(
true);
16263 Proto->getNumParams());
16269 return BuildRecoveryExpr(ResultType);
16274 return BuildRecoveryExpr(ResultType);
16284 if (
auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
16285 if (
const EnableIfAttr *
Attr =
16287 Diag(MemE->getMemberLoc(),
16288 diag::err_ovl_no_viable_member_function_in_call)
16291 diag::note_ovl_candidate_disabled_by_function_cond_attr)
16292 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
16298 TheCall->getDirectCallee()->isPureVirtual()) {
16304 diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
16315 if (
auto *DD = dyn_cast<CXXDestructorDecl>(TheCall->getDirectCallee())) {
16319 CallCanBeVirtual,
true,
16324 TheCall->getDirectCallee());
16336 UnbridgedCastsSet UnbridgedCasts;
16340 assert(Object.get()->getType()->isRecordType() &&
16341 "Requires object type argument");
16355 diag::err_incomplete_object_call, Object.get()))
16358 auto *
Record = Object.get()->getType()->castAsCXXRecordDecl();
16364 Oper != OperEnd; ++Oper) {
16366 Object.get()->Classify(
Context), Args, CandidateSet,
16378 bool IgnoreSurrogateFunctions =
false;
16381 if (!Candidate.
Viable &&
16383 IgnoreSurrogateFunctions =
true;
16405 !IgnoreSurrogateFunctions && I != E; ++I) {
16427 Object.get(), Args, CandidateSet);
16432 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16445 CandidateSet.
empty()
16446 ? (
PDiag(diag::err_ovl_no_oper)
16447 << Object.get()->getType() << 1
16448 << Object.get()->getSourceRange())
16449 : (
PDiag(diag::err_ovl_no_viable_object_call)
16450 << Object.get()->getType() << Object.get()->getSourceRange());
16460 PDiag(diag::err_ovl_ambiguous_object_call)
16461 << Object.get()->getType()
16462 << Object.get()->getSourceRange()),
16473 PDiag(diag::err_ovl_deleted_object_call)
16474 << Object.get()->getType() << (Msg !=
nullptr)
16475 << (Msg ? Msg->
getString() : StringRef())
16476 << Object.get()->getSourceRange()),
16482 if (Best == CandidateSet.
end())
16485 UnbridgedCasts.restore();
16487 if (Best->Function ==
nullptr) {
16492 Best->Conversions[0].UserDefined.ConversionFunction);
16498 assert(Conv == Best->FoundDecl.getDecl() &&
16499 "Found Decl & conversion-to-functionptr should be same, right?!");
16507 Conv, HadMultipleCandidates);
16508 if (
Call.isInvalid())
16512 Context,
Call.get()->getType(), CK_UserDefinedConversion,
Call.get(),
16526 if (
Method->isInvalidDecl())
16533 Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
16536 Obj, HadMultipleCandidates,
16543 MethodArgs.reserve(NumParams + 1);
16545 bool IsError =
false;
16549 if (
Method->isExplicitObjectMemberFunction()) {
16553 Object.get(), std::nullopt, Best->FoundDecl,
Method);
16558 MethodArgs.push_back(Object.get());
16562 *
this, MethodArgs,
Method, Args, LParenLoc);
16565 if (Proto->isVariadic()) {
16567 for (
unsigned i = NumParams, e = Args.size(); i < e; i++) {
16571 MethodArgs.push_back(Arg.
get());
16586 Context, OO_Call, NewFn.
get(), MethodArgs, ResultTy,
VK, RParenLoc,
16600 bool *NoArrowOperatorFound) {
16601 assert(
Base->getType()->isRecordType() &&
16602 "left-hand side must have class type");
16616 Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
16620 diag::err_typecheck_incomplete_tag,
Base))
16628 Oper != OperEnd; ++Oper) {
16634 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16645 if (CandidateSet.
empty()) {
16647 if (NoArrowOperatorFound) {
16650 *NoArrowOperatorFound =
true;
16653 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
16654 << BaseType <<
Base->getSourceRange();
16655 if (BaseType->isRecordType() && !BaseType->isPointerType()) {
16656 Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
16660 Diag(OpLoc, diag::err_ovl_no_viable_oper)
16661 <<
"operator->" <<
Base->getSourceRange();
16669 <<
"->" <<
Base->getType()
16670 <<
Base->getSourceRange()),
16678 <<
"->" << (Msg !=
nullptr)
16679 << (Msg ? Msg->
getString() : StringRef())
16680 <<
Base->getSourceRange()),
16691 if (
Method->isExplicitObjectMemberFunction()) {
16698 Base, std::nullopt, Best->FoundDecl,
Method);
16706 Base, HadMultipleCandidates, OpLoc);
16740 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16753 PDiag(diag::err_ovl_no_viable_function_in_call)
16768 nullptr, HadMultipleCandidates,
16771 if (Fn.isInvalid())
16777 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
16783 ConvArgs[ArgIdx] = InputInit.
get();
16810 Scope *S =
nullptr;
16813 if (!MemberLookup.
empty()) {
16840 if (CandidateSet->
empty() || CandidateSetError) {
16853 Loc,
nullptr, CandidateSet, &Best,
16866 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
16871 if (SubExpr.
get() == PE->getSubExpr())
16875 ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.
get());
16883 assert(
Context.hasSameType(ICE->getSubExpr()->getType(),
16885 "Implicit cast type cannot be determined from overload");
16886 assert(ICE->path_empty() &&
"fixing up hierarchy conversion?");
16887 if (SubExpr.
get() == ICE->getSubExpr())
16895 if (
auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
16896 if (!GSE->isResultDependent()) {
16901 if (SubExpr.
get() == GSE->getResultExpr())
16908 unsigned ResultIdx = GSE->getResultIndex();
16909 AssocExprs[ResultIdx] = SubExpr.
get();
16911 if (GSE->isExprPredicate())
16913 Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
16914 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16915 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16918 Context, GSE->getGenericLoc(), GSE->getControllingType(),
16919 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16920 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16929 assert(UnOp->getOpcode() == UO_AddrOf &&
16930 "Can only take the address of an overloaded function");
16932 if (!
Method->isImplicitObjectMemberFunction()) {
16943 if (SubExpr.
get() == UnOp->getSubExpr())
16951 "fixed to something other than a decl ref");
16954 assert(Qualifier &&
16955 "fixed to a member ref with no nested name qualifier");
16961 Fn->getType(), Qualifier,
16964 if (
Context.getTargetInfo().getCXXABI().isMicrosoft())
16969 UnOp->getOperatorLoc(),
false,
16977 if (SubExpr.
get() == UnOp->getSubExpr())
16990 if (ULE->hasExplicitTemplateArgs()) {
16991 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
16992 TemplateArgs = &TemplateArgsBuffer;
16997 getLangOpts().CPlusPlus && !Fn->hasCXXExplicitFunctionObjectParameter()
17002 if (
unsigned BID = Fn->getBuiltinID()) {
17003 if (!
Context.BuiltinInfo.isDirectlyAddressable(BID)) {
17010 Fn,
Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
17011 Found.getDecl(), ULE->getTemplateKeywordLoc(), TemplateArgs);
17019 if (MemExpr->hasExplicitTemplateArgs()) {
17020 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
17021 TemplateArgs = &TemplateArgsBuffer;
17028 if (MemExpr->isImplicitAccess()) {
17031 Fn, Fn->getType(),
VK_LValue, MemExpr->getNameInfo(),
17032 MemExpr->getQualifierLoc(),
Found.getDecl(),
17033 MemExpr->getTemplateKeywordLoc(), TemplateArgs);
17038 if (MemExpr->getQualifier())
17039 Loc = MemExpr->getQualifierLoc().getBeginLoc();
17044 Base = MemExpr->getBase();
17050 type = Fn->getType();
17057 Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
17058 MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn,
Found,
17059 true, MemExpr->getMemberNameInfo(),
17063 llvm_unreachable(
"Invalid reference to overloaded function");
17074 if (!PartialOverloading || !
Function)
17078 if (
const auto *Proto =
17079 dyn_cast<FunctionProtoType>(
Function->getFunctionType()))
17080 if (Proto->isTemplateVariadic())
17082 if (
auto *Pattern =
Function->getTemplateInstantiationPattern())
17083 if (
const auto *Proto =
17084 dyn_cast<FunctionProtoType>(Pattern->getFunctionType()))
17085 if (Proto->isTemplateVariadic())
17098 << IsMember << Name << (Msg !=
nullptr)
17099 << (Msg ? Msg->
getString() : StringRef())
Defines the clang::ASTContext interface.
Defines the Diagnostic-related interfaces.
static bool isBooleanType(QualType Ty)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
static const GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Record Record
Defines an enumeration for C++ overloaded operators.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
This file declares semantic analysis functions specific to ARM.
static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
static bool hasExplicitAttr(const VarDecl *D)
This file declares semantic analysis for CUDA constructs.
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
static bool isRecordType(QualType T)
static void TryUserDefinedConversion(Sema &S, QualType DestType, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence, bool TopLevelOfInitList)
Attempt a user-defined conversion between two types (C++ [dcl.init]), which enumerates all conversion...
This file declares semantic analysis for Objective-C.
static ImplicitConversionSequence::CompareKind CompareStandardConversionSequences(Sema &S, SourceLocation Loc, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareStandardConversionSequences - Compare two standard conversion sequences to determine whether o...
static bool sameFunctionParameterTypeLists(Sema &S, FunctionDecl *Fn1, FunctionDecl *Fn2, bool IsFn1Reversed, bool IsFn2Reversed)
We're allowed to use constraints partial ordering only if the candidates have the same parameter type...
static bool isNullPointerConstantForConversion(Expr *Expr, bool InOverloadResolution, ASTContext &Context)
static bool shouldSkipNotingLambdaConversionDecl(const FunctionDecl *Fn)
static const FunctionType * getConversionOpReturnTyAsFunction(CXXConversionDecl *Conv)
static bool functionHasPassObjectSizeParams(const FunctionDecl *FD)
static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1, const FunctionDecl *Cand2)
Compares the enable_if attributes of two FunctionDecls, for the purposes of overload resolution.
static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr *ArgExpr)
CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers, if any, found in visible typ...
@ ToPromotedUnderlyingType
static void AddOverloadedCallCandidate(Sema &S, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading, bool KnownValid)
Add a single candidate to the overload set.
static void AddTemplateOverloadCandidateImmediately(Sema &S, OverloadCandidateSet &CandidateSet, FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, bool SuppressUserConversions, bool PartialOverloading, bool AllowExplicit, Sema::ADLCallKind IsADLCandidate, OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction)
static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, OverloadCandidateSet *CandidateSet, OverloadCandidateSet::iterator *Best, OverloadingResult OverloadResult, bool AllowTypoCorrection)
FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns the completed call expre...
static bool isQualificationConversionStep(QualType FromType, QualType ToType, bool CStyle, bool IsTopLevel, bool &PreviousToQualsIncludeConst, bool &ObjCLifetimeConversion, const ASTContext &Ctx)
Perform a single iteration of the loop for checking if a qualification conversion is valid.
static ImplicitConversionSequence::CompareKind CompareQualificationConversions(Sema &S, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareQualificationConversions - Compares two standard conversion sequences to determine whether the...
static void dropPointerConversion(StandardConversionSequence &SCS)
dropPointerConversions - If the given standard conversion sequence involves any pointer conversions,...
static SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand)
static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D, unsigned NumFormalArgs, bool IsAddressOf=false)
General arity mismatch diagnosis over a candidate in a candidate set.
static const Expr * IgnoreNarrowingConversion(ASTContext &Ctx, const Expr *Converted)
Skip any implicit casts which could be either part of a narrowing conversion or after one in an impli...
static bool allowAmbiguity(ASTContext &Context, const FunctionDecl *F1, const FunctionDecl *F2)
static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI)
static QualType BuildSimilarlyQualifiedPointerType(const Type *FromPtr, QualType ToPointee, QualType ToType, ASTContext &Context, bool StripObjCLifetime=false)
BuildSimilarlyQualifiedPointerType - In a pointer conversion from the pointer type FromPtr to a point...
static void forAllQualifierCombinations(QualifiersAndAtomic Quals, llvm::function_ref< void(QualifiersAndAtomic)> Callback)
static bool FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS, QualType DeclType, SourceLocation DeclLoc, Expr *Init, QualType T2, bool AllowRvalues, bool AllowExplicit)
Look for a user-defined conversion to a value reference-compatible with DeclType.
static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle)
static Expr * GetExplicitObjectExpr(Sema &S, Expr *Obj, const FunctionDecl *Fun)
static bool hasDeprecatedStringLiteralToCharPtrConversion(const ImplicitConversionSequence &ICS)
static void AddBuiltinAssignmentOperatorCandidates(Sema &S, QualType T, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet)
Helper function for AddBuiltinOperatorCandidates() that adds the volatile- and non-volatile-qualified...
static bool CheckConvertedConstantConversions(Sema &S, StandardConversionSequence &SCS)
Check that the specified conversion is permitted in a converted constant expression,...
static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc, SourceLocation OpLoc, OverloadCandidate *Cand)
static ImplicitConversionSequence::CompareKind compareConversionFunctions(Sema &S, FunctionDecl *Function1, FunctionDecl *Function2)
Compare the user-defined conversion functions or constructors of two user-defined conversion sequence...
static void forAllQualifierCombinationsImpl(QualifiersAndAtomic Available, QualifiersAndAtomic Applied, llvm::function_ref< void(QualifiersAndAtomic)> Callback)
static const char * GetImplicitConversionName(ImplicitConversionKind Kind)
GetImplicitConversionName - Return the name of this kind of implicit conversion.
static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc)
Returns true if we can take the address of the function.
static ImplicitConversionSequence::CompareKind CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareDerivedToBaseConversions - Compares two standard conversion sequences to determine whether the...
static bool convertArgsForAvailabilityChecks(Sema &S, FunctionDecl *Function, Expr *ThisArg, SourceLocation CallLoc, ArrayRef< Expr * > Args, Sema::SFINAETrap &Trap, bool MissingImplicitThis, Expr *&ConvertedThis, SmallVectorImpl< Expr * > &ConvertedArgs)
static TemplateDecl * getDescribedTemplate(Decl *Templated)
static void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand, ArrayRef< Expr * > Args, OverloadCandidateSet::CandidateSetKind CSK)
CompleteNonViableCandidate - Normally, overload resolution only computes up to the first bad conversi...
static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs)
Adopt the given qualifiers for the given type.
static void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc, OverloadCandidate *Cand)
static bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool IsAddressOf=false)
Additional arity mismatch diagnosis specific to a function overload candidates.
static ImplicitConversionSequence::CompareKind compareStandardConversionSubsets(ASTContext &Context, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
static bool hasDependentExplicit(FunctionTemplateDecl *FTD)
static bool IsVectorConversion(Sema &S, QualType FromType, QualType ToType, ImplicitConversionKind &ICK, ImplicitConversionKind &ElConv, Expr *From, bool InOverloadResolution, bool CStyle)
Determine whether the conversion from FromType to ToType is a valid vector conversion.
static ImplicitConversionSequence TryContextuallyConvertToObjCPointer(Sema &S, Expr *From)
TryContextuallyConvertToObjCPointer - Attempt to contextually convert the expression From to an Objec...
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From, QualType T, APValue &Value, CCEKind CCE, bool RequireInt, NamedDecl *Dest)
CheckConvertedConstantExpression - Check that the expression From is a converted constant expression ...
static ExprResult CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl, const Expr *Base, bool HadMultipleCandidates, SourceLocation Loc=SourceLocation(), const DeclarationNameLoc &LocInfo=DeclarationNameLoc())
A convenience routine for creating a decayed reference to a function.
static std::optional< QualType > getImplicitObjectParamType(ASTContext &Context, const FunctionDecl *F)
Compute the type of the implicit object parameter for the given function, if any.
static bool checkPlaceholderForOverload(Sema &S, Expr *&E, UnbridgedCastsSet *unbridgedCasts=nullptr)
checkPlaceholderForOverload - Do any interesting placeholder-like preprocessing on the given expressi...
static FixedEnumPromotion getFixedEnumPromtion(Sema &S, const StandardConversionSequence &SCS)
Returns kind of fixed enum promotion the SCS uses.
static bool isAllowableExplicitConversion(Sema &S, QualType ConvType, QualType ToType, bool AllowObjCPointerConversion)
Determine whether this is an allowable conversion from the result of an explicit conversion operator ...
static bool isNonViableMultiVersionOverload(FunctionDecl *FD)
static bool FunctionsCorrespond(ASTContext &Ctx, const FunctionDecl *X, const FunctionDecl *Y)
static ImplicitConversionSequence TryImplicitConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, AllowedExplicit AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
TryImplicitConversion - Attempt to perform an implicit conversion from the given expression (Expr) to...
static ExprResult BuildConvertedConstantExpression(Sema &S, Expr *From, QualType T, CCEKind CCE, NamedDecl *Dest, APValue &PreNarrowingValue)
BuildConvertedConstantExpression - Check that the expression From is a converted constant expression ...
static bool IsVectorElementConversion(Sema &S, QualType FromType, QualType ToType, ImplicitConversionKind &ICK, Expr *From)
static ImplicitConversionSequence TryListConversion(Sema &S, InitListExpr *From, QualType ToType, bool SuppressUserConversions, bool InOverloadResolution, bool AllowObjCWritebackConversion)
TryListConversion - Try to copy-initialize a value of type ToType from the initializer list From.
static bool IsOverloadOrOverrideImpl(Sema &SemaRef, FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs, bool UseOverrideRules=false)
static QualType withoutUnaligned(ASTContext &Ctx, QualType T)
static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand)
CUDA: diagnose an invalid call across targets.
static void MaybeDiagnoseAmbiguousConstraints(Sema &S, ArrayRef< OverloadCandidate > Cands)
static bool diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, UnresolvedSetImpl &ExplicitConversions)
static void AddMethodTemplateCandidateImmediately(Sema &S, OverloadCandidateSet &CandidateSet, FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr * > Args, bool SuppressUserConversions, bool PartialOverloading, OverloadCandidateParamOrder PO)
static void AddTemplateConversionCandidateImmediately(Sema &S, OverloadCandidateSet &CandidateSet, FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion)
static ImplicitConversionSequence TryContextuallyConvertToBool(Sema &S, Expr *From)
TryContextuallyConvertToBool - Attempt to contextually convert the expression From to bool (C++0x [co...
static ImplicitConversionSequence TryObjectArgumentInitialization(Sema &S, SourceLocation Loc, QualType FromType, Expr::Classification FromClassification, CXXMethodDecl *Method, const CXXRecordDecl *ActingContext, bool InOverloadResolution=false, QualType ExplicitParameterType=QualType(), bool SuppressUserConversion=false)
TryObjectArgumentInitialization - Try to initialize the object parameter of the given member function...
static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, DeclAccessPair &Found)
static ImplicitConversionSequence::CompareKind CompareImplicitConversionSequences(Sema &S, SourceLocation Loc, const ImplicitConversionSequence &ICS1, const ImplicitConversionSequence &ICS2)
CompareImplicitConversionSequences - Compare two implicit conversion sequences to determine whether o...
static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS=LangAS::Default)
Generates a 'note' diagnostic for an overload candidate.
static ImplicitConversionSequence TryCopyInitialization(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool InOverloadResolution, bool AllowObjCWritebackConversion, bool AllowExplicit=false)
TryCopyInitialization - Try to copy-initialize a value of type ToType from the expression From.
static ExprResult diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From, Sema::ContextualImplicitConverter &Converter, QualType T, UnresolvedSetImpl &ViableConversions)
static void markUnaddressableCandidatesUnviable(Sema &S, OverloadCandidateSet &CS)
static QualType GetExplicitObjectType(Sema &S, const Expr *MemExprE)
Sema::AllowedExplicit AllowedExplicit
static QualType AdjustAddressSpaceForBuiltinOperandType(Sema &S, QualType T, Expr *Arg)
Helper function for adjusting address spaces for the pointer or reference operands of builtin operato...
static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand)
static bool DiagnoseTwoPhaseLookup(Sema &SemaRef, SourceLocation FnLoc, const CXXScopeSpec &SS, LookupResult &R, OverloadCandidateSet::CandidateSetKind CSK, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, CXXRecordDecl **FoundInClass=nullptr)
Attempt to recover from an ill-formed use of a non-dependent name in a template, where the non-depend...
static bool isBetterReferenceBindingKind(const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
Determine whether one of the given reference bindings is better than the other based on what kind of ...
static bool canBeDeclaredInNamespace(const DeclarationName &Name)
Determine whether a declaration with the specified name could be moved into a different namespace.
static ExprResult finishContextualImplicitConversion(Sema &SemaRef, SourceLocation Loc, Expr *From, Sema::ContextualImplicitConverter &Converter)
static bool IsStandardConversion(Sema &S, Expr *From, QualType ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle, bool AllowObjCWritebackConversion)
IsStandardConversion - Determines whether there is a standard conversion sequence (C++ [conv],...
static bool DiagnoseTwoPhaseOperatorLookup(Sema &SemaRef, OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args)
Attempt to recover from ill-formed use of a non-dependent operator in a template, where the non-depen...
static bool isNonTrivialObjCLifetimeConversion(Qualifiers FromQuals, Qualifiers ToQuals)
Determine whether the lifetime conversion between the two given qualifiers sets is nontrivial.
static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress)
static bool completeFunctionType(Sema &S, FunctionDecl *FD, SourceLocation Loc, bool Complain=true)
static bool shouldAddReversedEqEq(Sema &S, SourceLocation OpLoc, Expr *FirstOperand, FunctionDecl *EqFD)
static bool isFunctionAlwaysEnabled(const ASTContext &Ctx, const FunctionDecl *FD)
static bool PrepareExplicitObjectArgument(Sema &S, CXXMethodDecl *Method, Expr *Object, MultiExprArg &Args, SmallVectorImpl< Expr * > &NewArgs)
static OverloadingResult IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType, CXXRecordDecl *To, UserDefinedConversionSequence &User, OverloadCandidateSet &CandidateSet, bool AllowExplicit)
static bool checkAddressOfCandidateIsAvailable(Sema &S, const FunctionDecl *FD)
static bool IsFloatingPointConversion(Sema &S, QualType FromType, QualType ToType)
Determine whether the conversion from FromType to ToType is a valid floating point conversion.
static bool isFirstArgumentCompatibleWithType(ASTContext &Context, CXXConstructorDecl *Constructor, QualType Type)
static Comparison isBetterMultiversionCandidate(const OverloadCandidate &Cand1, const OverloadCandidate &Cand2)
static void NoteImplicitDeductionGuide(Sema &S, FunctionDecl *Fn)
static void collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType, UnresolvedSetImpl &ViableConversions, OverloadCandidateSet &CandidateSet)
static ImplicitConversionSequence TryReferenceInit(Sema &S, Expr *Init, QualType DeclType, SourceLocation DeclLoc, bool SuppressUserConversions, bool AllowExplicit)
Compute an implicit conversion sequence for reference initialization.
static bool isNonDependentlyExplicit(FunctionTemplateDecl *FTD)
Determine whether a given function template has a simple explicit specifier or a non-value-dependent ...
static bool checkArgPlaceholdersForOverload(Sema &S, MultiExprArg Args, UnbridgedCastsSet &unbridged)
checkArgPlaceholdersForOverload - Check a set of call operands for placeholders.
static QualType makeQualifiedLValueReferenceType(QualType Base, QualifiersAndAtomic Quals, Sema &S)
static QualType chooseRecoveryType(OverloadCandidateSet &CS, OverloadCandidateSet::iterator *Best)
static void AddTemplateOverloadCandidate(Sema &S, OverloadCandidateSet &CandidateSet, DeferredMethodTemplateOverloadCandidate &C)
static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand)
static ExprResult BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MutableArrayRef< Expr * > Args, SourceLocation RParenLoc, bool EmptyLookup, bool AllowTypoCorrection)
Attempts to recover from a call where no functions were found.
static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand)
static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND, bool ArgDependent, SourceLocation Loc, CheckFn &&IsSuccessful)
static OverloadingResult IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType, UserDefinedConversionSequence &User, OverloadCandidateSet &Conversions, AllowedExplicit AllowExplicit, bool AllowObjCConversionOnExplicit)
Determines whether there is a user-defined conversion sequence (C++ [over.ics.user]) that converts ex...
static bool IsAcceptableNonMemberOperatorCandidate(ASTContext &Context, FunctionDecl *Fn, ArrayRef< Expr * > Args)
IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is an acceptable non-member overloaded ...
static FunctionDecl * getMorePartialOrderingConstrained(Sema &S, FunctionDecl *Fn1, FunctionDecl *Fn2, bool IsFn1Reversed, bool IsFn2Reversed)
static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress)
Diagnose a failed template-argument deduction.
static bool IsTransparentUnionStandardConversion(Sema &S, Expr *From, QualType &ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle)
static const FunctionProtoType * tryGetFunctionProtoType(QualType FromType)
Attempts to get the FunctionProtoType from a Type.
static bool PrepareArgumentsForCallToObjectOfClassType(Sema &S, SmallVectorImpl< Expr * > &MethodArgs, CXXMethodDecl *Method, MultiExprArg Args, SourceLocation LParenLoc)
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)
Defines the SourceManager interface.
static QualType getPointeeType(const MemRegion *R)
C Language Family Type Representation.
a trap message and trap category.
A class for storing results from argument-dependent lookup.
void erase(NamedDecl *D)
Removes any data associated with a given decl.
llvm::mapped_iterator< decltype(Decls)::iterator, select_second > iterator
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
std::string getAsString(const ASTContext &Ctx, QualType Ty) 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 getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
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
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
DeclarationNameTable DeclarationNames
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
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.
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current context.
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
const TargetInfo * getAuxTargetInfo() const
CanQualType UnsignedLongTy
QualType getRestrictType(QualType T) const
Return the uniqued reference to the type for a restrict qualified type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCIdType() const
Represents the Objective-CC id type.
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.
bool isSameTemplateParameterList(const TemplateParameterList *X, const TemplateParameterList *Y) const
Determine whether two template parameter lists are similar enough that they may be used in declaratio...
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CanQualType UnsignedInt128Ty
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
QualType getVolatileType(QualType T) const
Return the uniqued reference to the type for a volatile qualified type.
CanQualType UnsignedLongLongTy
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
CanQualType UnsignedShortTy
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 getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
const TargetInfo & getTargetInfo() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
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
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
Represents a constant array type that does not decay to a pointer when used as a function parameter.
QualType getConstantArrayType(const ASTContext &Ctx) const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Attr - This represents one attribute.
A builtin binary operation expression such as "x + y" or "x <= y".
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
StringRef getOpcodeStr() const
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
static bool isCompoundAssignmentOp(Opcode Opc)
This class is used for builtin types like 'int'.
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
const RecordType * getDetectedVirtual() const
The virtual base discovered on the path (if we are merely detecting virtuals).
bool isAmbiguous(CanQualType BaseType)
Determine whether the path from the most-derived type to the given base type is ambiguous (i....
Represents a C++ constructor within a class.
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
bool isConvertingConstructor(bool AllowExplicit) const
Whether this constructor is a converting constructor (C++ [class.conv.ctor]), which can be used for u...
Represents a C++ conversion function within a class.
bool isExplicit() const
Return true if the declaration is already resolved to be explicit.
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a call to a member function that may be written either with member call syntax (e....
static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RP, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0)
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...
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
QualType getFunctionObjectParameterReferenceType() const
Return the type of the object pointed by this.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
static CXXOperatorCallExpr * Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation OperatorLoc, FPOptionsOverride FPFeatures, ADLCallKind UsesADL=NotADL)
Represents a C++ struct/union/class.
bool isLambda() const
Determine whether this class describes a lambda function object.
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions() const
Get all conversion functions visible in current class, including conversion function templates.
bool hasDefinition() const
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
A rewritten comparison expression that was originally written using operator syntax.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
void setUsesMemberSyntax(bool V=true)
void markDependentForPostponedNameLookup()
Used by Sema to implement MSVC-compatible delayed name lookup.
Represents a canonical, potentially-qualified type.
bool isAtLeastAsQualifiedAs(CanQual< T > Other, const ASTContext &Ctx) const
Determines whether this canonical type is at least as qualified as the Other canonical type.
static CanQual< Type > CreateUnsafe(QualType Other)
CanProxy< U > castAs() const
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
Qualifiers getQualifiers() const
Retrieve all qualifiers.
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed.
bool isVolatileQualified() const
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
bool isPartial() const
True iff the comparison is not totally ordered.
bool isStrong() const
True iff the comparison is "strong".
Complex values, per C99 6.2.5p11.
QualType getElementType() const
static CompoundAssignOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures, QualType CompLHSType=QualType(), QualType CompResultType=QualType())
Represents the canonical version of C arrays with a specified constant size.
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
NamedDecl * getDecl() const
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.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context semantically encloses the declaration context DC.
A reference to a declared variable, function, enum, etc.
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a function that was resolved from an overload...
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 isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
bool isInvalidDecl() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
specific_attr_iterator< T > specific_attr_end() const
specific_attr_iterator< T > specific_attr_begin() const
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
DeclarationNameLoc - Additional source/type location info for a declaration name.
The name of a declaration.
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
SourceLocation getBeginLoc() const LLVM_READONLY
const AssociatedConstraint & getTrailingRequiresClause() const
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
void overloadCandidatesShown(unsigned N)
Call this after showing N overload candidates.
unsigned getNumOverloadCandidatesToShow() const
When a call or operator fails, print out up to this many candidate overloads as suggestions.
OverloadsShown getShowOverloads() const
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
RAII object that enters a new expression evaluation context.
Store information needed for an explicit specifier.
bool isExplicit() const
Determine whether this specifier is known to correspond to an explicit declaration.
ExplicitSpecKind getKind() const
const Expr * getExpr() const
static ExplicitSpecifier getFromDecl(FunctionDecl *Function)
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
The return type of classify().
static Classification makeSimpleLValue()
Create a simple, modifiable lvalue.
This represents one expression.
bool isIntegerConstantExpr(const ASTContext &Ctx) const
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
@ NPCK_ZeroExpression
Expression is a Null pointer constant built from a zero integer expression that is not a simple,...
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
ExtVectorType - Extended vector type.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Represents a function declaration or definition.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool isMemberLikeConstrainedFriend() const
Determine whether a function is a friend function that cannot be redeclared outside of its class,...
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...
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
param_iterator param_begin()
bool isVariadic() const
Whether this function is variadic.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
unsigned getNumNonObjectParams() const
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
bool isTargetMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target functionality.
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
bool isTargetMultiVersionDefault() const
True if this function is the default version of a multiversioned dispatch function as a part of the t...
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Represents a prototype with parameter type info, e.g.
ExtParameterInfo getExtParameterInfo(unsigned I) const
unsigned getNumParams() const
Qualifiers getMethodQuals() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
A class which abstracts out some details necessary for making a call.
ExtInfo withNoReturn(bool noReturn) const
ParameterABI getABI() const
Return the ABI treatment of this parameter.
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
CallingConv getCallConv() const
QualType getReturnType() const
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > AssocTypes, ArrayRef< Expr * > AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Create a non-result-dependent generic selection expression accepting an expression predicate.
One of these records is kept for each identifier that is lexed.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
void dump() const
dump - Print this implicit conversion sequence to standard error.
bool isUserDefined() const
@ StaticObjectArgumentConversion
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence.
void setBad(BadConversionSequence::FailureKind Failure, Expr *FromExpr, QualType ToType)
Sets this sequence as a bad conversion for an explicit argument.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
static ImplicitConversionSequence getNullptrToBool(QualType SourceType, QualType DestType, bool NeedLValToRVal)
Form an "implicit" conversion sequence from nullptr_t to bool, for a direct-initialization of a bool ...
AmbiguousConversionSequence Ambiguous
When ConversionKind == AmbiguousConversion, provides the details of the ambiguous conversion.
void setInitializerListContainerType(QualType T, bool IA)
bool hasInitializerListContainerType() const
unsigned getKindRank() const
Return a ranking of the implicit conversion sequence kind, where smaller ranks represent better conve...
bool isInitializerListOfIncompleteArray() const
BadConversionSequence Bad
When ConversionKind == BadConversion, provides the details of the bad conversion.
QualType getInitializerListContainerType() const
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
Describes an C or C++ initializer list.
bool hasDesignatedInit() const
Determine whether this initializer list contains a designated initializer.
unsigned getNumInits() const
SourceLocation getBeginLoc() const LLVM_READONLY
const Expr * getInit(unsigned Init) const
SourceLocation getEndLoc() const LLVM_READONLY
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static InitializedEntity InitializeTemplateParameter(QualType T, NamedDecl *Param)
Create the initialization entity for a template parameter.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
An lvalue reference type, per C++11 [dcl.ref].
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Represents the results of name lookup.
void addAllDecls(const LookupResult &Other)
Add all the declarations from another set of lookup results.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
DeclClass * getAsSingle() const
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
bool empty() const
Return true if no decls were found.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
void suppressAccessDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup due to access control violat...
const UnresolvedSetImpl & asUnresolvedSet() const
UnresolvedSetImpl::iterator iterator
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of 'F'.
NestedNameSpecifier getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getExprLoc() const LLVM_READONLY
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
A pointer to member type per C++ 8.3.3 - Pointers to members.
NestedNameSpecifier getQualifier() const
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Note: this can trigger extra deserialization when external AST sources are used.
QualType getPointeeType() const
Describes a module or submodule.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getQualifiedNameAsString() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents an ObjC class declaration.
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
ObjCMethodDecl - Represents an instance or class method declaration.
Represents a pointer to an Objective C object.
bool isSpecialized() const
Whether this type is specialized, meaning that it has type arguments.
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
void clear(CandidateSetKind CSK)
Clear out all of the candidates.
void AddDeferredTemplateCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, bool SuppressUserConversions, bool PartialOverloading, bool AllowExplicit, CallExpr::ADLCallKind IsADLCandidate, OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction)
bool isNewCandidate(Decl *F, OverloadCandidateParamOrder PO=OverloadCandidateParamOrder::Normal)
Determine when this overload candidate will be new to the overload set.
void AddDeferredConversionTemplateCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion)
void AddDeferredMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr * > Args, bool SuppressUserConversions, bool PartialOverloading, OverloadCandidateParamOrder PO)
void DisableResolutionByPerfectCandidate()
ConversionSequenceList allocateConversionSequences(unsigned NumConversions)
Allocate storage for conversion sequences for NumConversions conversions.
llvm::MutableArrayRef< Expr * > getPersistentArgsArray(unsigned N)
Provide storage for any Expr* arg that must be preserved until deferred template candidates are deduc...
OperatorRewriteInfo getRewriteInfo() const
bool shouldDeferTemplateArgumentDeduction(const LangOptions &Opts) const
@ CSK_AddressOfOverloadSet
C++ [over.match.call.general] Resolve a call through the address of an overload set.
@ CSK_InitByConstructor
C++ [over.match.ctor], [over.match.list] Initialization of an object of class type by constructor,...
@ CSK_InitByUserDefinedConversion
C++ [over.match.copy]: Copy-initialization of an object of class type by user-defined conversion.
@ CSK_Normal
Normal lookup.
@ CSK_Operator
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax.
SmallVectorImpl< OverloadCandidate >::iterator iterator
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
bool shouldDeferDiags(Sema &S, ArrayRef< Expr * > Args, SourceLocation OpLoc)
Whether diagnostics should be deferred.
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
void exclude(Decl *F)
Exclude a function from being considered by overload resolution.
SourceLocation getLocation() const
OverloadCandidate & addCandidate(unsigned NumConversions=0, ConversionSequenceList Conversions={})
Add a new candidate with NumConversions conversion sequence slots to the overload set.
void InjectNonDeducedTemplateCandidates(Sema &S)
CandidateSetKind getKind() const
size_t nonDeferredCandidatesCount() const
SmallVector< OverloadCandidate *, 32 > CompleteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, SourceLocation OpLoc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
NestedNameSpecifier getQualifier() const
Fetches the nested-name qualifier, if one was given.
SourceLocation getNameLoc() const
Gets the location of the name.
UnresolvedSetImpl::iterator decls_iterator
decls_iterator decls_begin() const
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments into the given structure.
decls_iterator decls_end() const
DeclarationName getName() const
Gets the name looked up.
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
ParenExpr - This represents a parenthesized expression, e.g.
Represents a parameter to a function.
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
bool isEquivalent(PointerAuthQualifier Other) const
std::string getAsString() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
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.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
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 getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
bool isMoreQualifiedThan(QualType Other, const ASTContext &Ctx) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
bool isConstQualified() const
Determine whether this type is const-qualified.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
A qualifier set is used to build a set of qualifiers.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
QualifiersAndAtomic withVolatile()
QualifiersAndAtomic withAtomic()
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
bool hasOnlyConst() const
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
void removeObjCLifetime()
bool compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const
Determines if these qualifiers compatibly include another set.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Returns true if address space A is equal to or a superset of B.
void removeAddressSpace()
void setAddressSpace(LangAS space)
PointerAuthQualifier getPointerAuth() const
bool hasObjCGCAttr() const
ObjCLifetime getObjCLifetime() const
std::string getAsString() const
LangAS getAddressSpace() const
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
field_range fields() const
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
Scope - A scope is a transient data structure that is used while parsing the program.
Smart pointer class that efficiently represents Objective-C method names.
unsigned getNumArgs() const
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool IsAllowedCall(const FunctionDecl *Caller, const FunctionDecl *Callee)
Determines whether Caller may invoke Callee, based on their CUDA host/device attributes.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
bool inferTargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, CXXMethodDecl *MemberDecl, bool ConstRHS, bool Diagnose)
Given a implicit special member, infer its CUDA target from the calls it needs to make to underlying ...
static bool isImplicitHostDeviceFunction(const FunctionDecl *D)
void EraseUnwantedMatches(const FunctionDecl *Caller, llvm::SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl * > > &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
CUDAFunctionPreference IdentifyPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)
Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...
bool isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast.
Abstract base class used to perform a contextual implicit conversion from an expression to any type p...
virtual SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for one of the candidate conversions.
virtual SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic complaining that the expression does not have integral or enumeration type.
virtual SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for the explicit conversion function.
virtual SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy)=0
Emits a diagnostic when the only matching conversion function is explicit.
virtual SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy)=0
Emits a diagnostic when we picked a conversion function (for cases when we are not allowed to pick a ...
virtual SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when there are multiple possible conversion functions.
virtual bool match(QualType T)=0
Determine whether the specified type is a valid destination type for this conversion.
virtual SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when the expression has incomplete class type.
For a defaulted function, the kind of defaulted function that it is.
bool isSpecialMember() const
bool isComparison() const
CXXSpecialMemberKind asSpecialMember() const
RAII class to control scope of DeferDiags.
bool match(QualType T) override
Match an integral or (possibly scoped) enumeration type.
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.
bool DiscardingCFIUncheckedCallee(QualType From, QualType To) const
Returns true if From is a function or pointer to a function with the cfi_unchecked_callee attribute b...
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, SourceLocation ConvLocation, CXXConversionDecl *Conv, Expr *Src)
bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function, const Expr *ThisArg, ArrayRef< const Expr * > Args, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any non-ArgDependent DiagnoseIf...
ExprResult PerformContextuallyConvertToObjCPointer(Expr *From)
PerformContextuallyConvertToObjCPointer - Perform a contextual conversion of the expression From to a...
bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, MultiExprArg Args, SourceLocation RParenLoc, OverloadCandidateSet *CandidateSet, ExprResult *Result)
Constructs and populates an OverloadedCandidateSet from the given function.
void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow)
Hides a using shadow declaration.
bool IsBuildingRecoveryCallExpr
Flag indicating if Sema is building a recovery call expression.
DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)
Determine the kind of defaulting that would be done for a given function.
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupUsingDeclName
Look up all declarations in a scope with the given name, including resolved using declarations.
@ LookupOperatorName
Look up of an operator name (e.g., operator+) for use with operator overloading.
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
void DiagnoseSentinelCalls(const NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, AllowedExplicit AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef< Expr * > Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to a literal operator descri...
bool IsStringInit(Expr *Init, const ArrayType *AT)
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr, bool ForFoldExpression=false)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, MultiExprArg Args)
void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet, OverloadedOperatorKind Op, const UnresolvedSetImpl &Fns, ArrayRef< Expr * > Args, bool RequiresADL=true)
Perform lookup for an overloaded binary operator.
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
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.
ReferenceCompareResult
ReferenceCompareResult - Expresses the result of comparing two types (cv1 T1 and cv2 T2) to determine...
@ Ref_Incompatible
Ref_Incompatible - The two types are incompatible, so direct reference binding is not possible.
@ Ref_Compatible
Ref_Compatible - The two types are reference-compatible.
@ Ref_Related
Ref_Related - The two types are reference-related, which means that their unqualified forms (T1 and T...
void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true)
Adds a conversion function template specialization candidate to the overload set, using template argu...
FunctionDecl * getMoreConstrainedFunction(FunctionDecl *FD1, FunctionDecl *FD2)
Returns the more constrained function according to the rules of partial ordering by constraints (C++ ...
void AddBuiltinCandidate(QualType *ParamTys, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool IsAssignmentOperator=false, unsigned NumContextualBoolArguments=0)
AddBuiltinCandidate - Add a candidate for a built-in operator.
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
void AddArgumentDependentLookupCandidates(DeclarationName Name, SourceLocation Loc, ArrayRef< Expr * > Args, TemplateArgumentListInfo *ExplicitTemplateArgs, OverloadCandidateSet &CandidateSet, bool PartialOverloading=false)
Add function candidates found via argument-dependent lookup to the set of overloading candidates.
ExprResult EvaluateConvertedConstantExpression(Expr *E, QualType T, APValue &Value, CCEKind CCE, bool RequireInt, const APValue &PreNarrowingValue)
EvaluateConvertedConstantExpression - Evaluate an Expression That is a converted constant expression ...
FPOptionsOverride CurFPFeatureOverrides()
ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound=nullptr)
BuildOverloadedArrowExpr - Build a call to an overloaded operator-> (if one exists),...
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallToMemberFunction - Build a call to a member function.
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
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...
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one.
DiagnosticsEngine & getDiagnostics() const
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
bool CheckNonDependentConversions(FunctionTemplateDecl *FunctionTemplate, ArrayRef< QualType > ParamTypes, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, ConversionSequenceList &Conversions, CheckNonDependentConversionsFlag UserConversionFlag, CXXRecordDecl *ActingContext=nullptr, QualType ObjectType=QualType(), Expr::Classification ObjectClassification={}, OverloadCandidateParamOrder PO={})
Check that implicit conversion sequences can be formed for each argument whose corresponding paramete...
bool isObjCPointerConversion(QualType FromType, QualType ToType, QualType &ConvertedType, bool &IncompatibleObjC)
isObjCPointerConversion - Determines whether this is an Objective-C pointer conversion.
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
bool FunctionParamTypesAreEqual(ArrayRef< QualType > Old, ArrayRef< QualType > New, unsigned *ArgPos=nullptr, bool Reversed=false)
FunctionParamTypesAreEqual - This routine checks two function proto types for equality of their param...
ExprResult PerformImplicitObjectArgumentInitialization(Expr *From, NestedNameSpecifier Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
PerformObjectArgumentInitialization - Perform initialization of the implicit object parameter for the...
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
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.
bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
IsIntegralPromotion - Determines whether the conversion from the expression From (whose potentially-a...
bool IsFloatingPointPromotion(QualType FromType, QualType ToType)
IsFloatingPointPromotion - Determines whether the conversion from FromType to ToType is a floating po...
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
void PopExpressionEvaluationContext()
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
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 FunctionNonObjectParamTypesAreEqual(const FunctionDecl *OldFunction, const FunctionDecl *NewFunction, unsigned *ArgPos=nullptr, bool Reversed=false)
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init....
llvm::SmallSetVector< CXXRecordDecl *, 16 > AssociatedClassSet
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, const SourceRange &, DeclAccessPair FoundDecl)
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool UseMemberUsingDeclRules)
Determine whether the given New declaration is an overload of the declarations in Old.
QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType)
bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType, bool InOverloadResolution, QualType &ConvertedType, bool &IncompatibleObjC)
IsPointerConversion - Determines whether the conversion of the expression From, which has the (possib...
@ Conversions
Allow explicit conversion functions but not explicit constructors.
void DiagnoseUseOfDeletedFunction(SourceLocation Loc, SourceRange Range, DeclarationName Name, OverloadCandidateSet &CandidateSet, FunctionDecl *Fn, MultiExprArg Args, bool IsMember=false)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool IsComplexPromotion(QualType FromType, QualType ToType)
Determine if a conversion is a complex promotion.
bool pushCodeSynthesisContext(CodeSynthesisContext Ctx)
Module * getOwningModule(const Decl *Entity)
Get the module owning an entity.
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
bool AddingCFIUncheckedCallee(QualType From, QualType To) const
Returns true if From is a function or pointer to a function without the cfi_unchecked_callee attribut...
void AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true, bool StrictPackMatch=false)
AddConversionCandidate - Add a C++ conversion function as a candidate in the candidate set (C++ [over...
bool IsBlockPointerConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc, ArrayRef< Expr * > Args, AssociatedNamespaceSet &AssociatedNamespaces, AssociatedClassSet &AssociatedClasses)
Find the associated classes and namespaces for argument-dependent lookup for a call with the given se...
void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, OverloadCandidateParamOrder PO={})
Add a C++ member function template as a candidate to the candidate set, using template argument deduc...
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
DiagnoseSelfMove - Emits a warning if a value is moved to itself.
bool isSameOrCompatibleFunctionType(QualType Param, QualType Arg)
Compare types for equality with respect to possibly compatible function types (noreturn adjustment,...
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, TranslationUnitKind TUKind=TU_Complete, CodeCompleteConsumer *CompletionConsumer=nullptr)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
const LangOptions & getLangOpts() const
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, const NamedDecl *B)
Determine if A and B are equivalent internal linkage declarations from different modules,...
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr * > Args={}, DeclContext *LookupCtx=nullptr)
Diagnose an empty lookup.
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, FunctionDecl *DefaultedFn)
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
bool CheckUseOfCXXMethodAsAddressOfOperand(SourceLocation OpLoc, const Expr *Op, const CXXMethodDecl *MD)
AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, DeclAccessPair FoundDecl)
Perform access-control checking on a previously-unresolved member access which has now been resolved ...
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions={}, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false, bool StrictPackMatch=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
const LangOptions & LangOpts
bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType, bool InOverloadResolution, QualType &ConvertedType)
IsMemberPointerConversion - Determines whether the conversion of the expression From,...
ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef< Expr * > Arg, SourceLocation RParenLoc, Expr *Config=nullptr, bool IsExecConfig=false, ADLCallKind UsesADL=ADLCallKind::NotADL)
BuildResolvedCallExpr - Build a call to a resolved expression, i.e.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl)
Wrap the expression in a ConstantExpr if it is a potential immediate invocation.
llvm::SmallSetVector< DeclContext *, 16 > AssociatedNamespaceSet
MemberPointerConversionDirection
bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any ArgDependent DiagnoseIfAttr...
ExprResult BuildConvertedConstantExpression(Expr *From, QualType T, CCEKind CCE, NamedDecl *Dest=nullptr)
void popCodeSynthesisContext()
bool AreConstraintExpressionsEqual(const NamedDecl *Old, const Expr *OldConstr, const TemplateCompareNewDeclInfo &New, const Expr *NewConstr)
ReferenceConversionsScope::ReferenceConversions ReferenceConversions
MemberPointerConversionResult CheckMemberPointerConversion(QualType FromType, const MemberPointerType *ToPtrType, CastKind &Kind, CXXCastPath &BasePath, SourceLocation CheckLoc, SourceRange OpRange, bool IgnoreBaseAccess, MemberPointerConversionDirection Direction)
CheckMemberPointerConversion - Check the member pointer conversion from the expression From to the ty...
Expr * BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit)
Build a CXXThisExpr and mark it referenced in the current context.
ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *input, bool RequiresADL=true)
Create a unary operation that may resolve to an overloaded operator.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading=false)
Add the overload candidates named by callee and/or found by argument dependent lookup to the given ov...
ExprResult DefaultLvalueConversion(Expr *E)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
void NoteOverloadCandidate(const NamedDecl *Found, const FunctionDecl *Fn, OverloadCandidateRewriteKind RewriteKind=OverloadCandidateRewriteKind(), QualType DestType=QualType(), bool TakingAddress=false)
bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType)
bool DiagnoseUseOfOverloadedDecl(NamedDecl *D, SourceLocation Loc)
void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc, ArrayRef< Expr * > Args, ADLResult &Functions)
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.
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, SourceLocation Loc={}, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
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.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
ObjCMethodDecl * SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance, SmallVectorImpl< ObjCMethodDecl * > &Methods)
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...
AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair FoundDecl)
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
EnableIfAttr * CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc, ArrayRef< Expr * > Args, bool MissingImplicitThis=false)
Check the enable_if expressions on the given function.
ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass, NestedNameSpecifierLoc NNSLoc, DeclarationNameInfo DNI, const UnresolvedSetImpl &Fns, bool PerformADL=true)
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
void AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversion=false, OverloadCandidateParamOrder PO={})
AddMethodCandidate - Adds a named decl (which is some kind of method) as a method candidate to the gi...
void diagnoseEquivalentInternalLinkageDeclarations(SourceLocation Loc, const NamedDecl *D, ArrayRef< const NamedDecl * > Equiv)
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, SourceLocation ColonLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr)
ActOnConditionalOp - Parse a ?
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"...
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
bool resolveAndFixAddressOfSingleOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
CallExpr::ADLCallKind ADLCallKind
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
bool anyAltivecTypes(QualType srcType, QualType destType)
bool isLaxVectorConversion(QualType srcType, QualType destType)
Is this a legal conversion between two types, one of which is known to be a vector type?
ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool AllowTypoCorrection=true, bool CalleesAddressIsTaken=false)
BuildOverloadedCallExpr - Given the call expression that calls Fn (which eventually refers to the dec...
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
ExprResult BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToObjectOfClassType - Build a call to an object of class type (C++ [over....
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool CanPerformAggregateInitializationForOverloadResolution(const InitializedEntity &Entity, InitListExpr *From)
Determine whether we can perform aggregate initialization for the purposes of overload resolution.
bool IsOverride(FunctionDecl *MD, FunctionDecl *BaseMD, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
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 AddFunctionCandidates(const UnresolvedSetImpl &Functions, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, bool SuppressUserConversions=false, bool PartialOverloading=false, bool FirstArgumentIsBase=false)
Add all of the function declarations in the given function set to the overload candidate set.
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType.
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType(), bool TakingAddress=false)
AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair FoundDecl)
void AddNonMemberOperatorCandidates(const UnresolvedSetImpl &Functions, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
Add all of the non-member operator function declarations in the given function set to the overload ca...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression's return type is complete.
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, ReferenceConversions *Conv=nullptr)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
MemberPointerConversionResult
SourceManager & SourceMgr
bool DiagnoseDependentMemberLookup(const LookupResult &R)
Diagnose a lookup that found results in an enclosing class during error recovery.
DiagnosticsEngine & Diags
NamespaceDecl * getStdNamespace() const
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
bool ResolveAndFixSingleFunctionTemplateSpecialization(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false, bool Complain=false, SourceRange OpRangeForComplaining=SourceRange(), QualType DestTypeForComplaining=QualType(), unsigned DiagIDForComplaining=0)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
void AddSurrogateCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, const FunctionProtoType *Proto, Expr *Object, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet)
AddSurrogateCandidate - Adds a "surrogate" candidate function that converts the given Object to a fun...
MemberExpr * BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl, bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo, QualType Ty, ExprValueKind VK, ExprObjectKind OK, const TemplateArgumentListInfo *TemplateArgs=nullptr)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(const NamedDecl *D1, ArrayRef< AssociatedConstraint > AC1, const NamedDecl *D2, ArrayRef< AssociatedConstraint > AC2)
If D1 was not at least as constrained as D2, but would've been if a pair of atomic constraints involv...
ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc, SourceLocation RangeLoc, const DeclarationNameInfo &NameInfo, LookupResult &MemberLookup, OverloadCandidateSet *CandidateSet, Expr *Range, ExprResult *CallExpr)
Build a call to 'begin' or 'end' for a C++11 for-range statement.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
ExprResult InitializeExplicitObjectArgument(Sema &S, Expr *Obj, FunctionDecl *Fun)
bool CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
bool DiagnoseInvalidExplicitObjectParameterInLambda(CXXMethodDecl *Method, SourceLocation CallLoc)
Returns true if the explicit object parameter was invalid.
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool ExecConfig=false)
ConvertArgumentsForCall - Converts the arguments specified in Args/NumArgs to the parameter types of ...
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
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...
bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, const FunctionProtoType *Proto)
CheckFunctionCall - Check a direct function call for various correctness and safety properties not st...
void AddMemberOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, OverloadCandidateParamOrder PO={})
Add overload candidates for overloaded operators that are member functions.
void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, bool IsDelete, bool CallCanBeVirtual, bool WarnOnNonAbstractTypes, SourceLocation DtorLoc)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, const Expr *ThisArg, ArrayRef< const Expr * > Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType)
Handles the checks for format strings, non-POD arguments to vararg functions, NULL arguments passed t...
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
A trivial tuple used to represent a source range.
SourceLocation getBegin() const
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3....
void dump() const
dump - Print this standard conversion sequence to standard error.
void setFromType(QualType T)
DeclAccessPair FoundCopyConstructor
bool isIdentityConversion() const
unsigned BindsToRvalue
Whether we're binding to an rvalue.
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion,...
QualType getFromType() const
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion,...
unsigned BindsImplicitObjectArgumentWithoutRefQualifier
Whether this binds an implicit object argument to a non-static member function without a ref-qualifie...
unsigned ReferenceBinding
ReferenceBinding - True when this is a reference binding (C++ [over.ics.ref]).
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion.
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
unsigned ObjCLifetimeConversionBinding
Whether this binds a reference to an object with a different Objective-C lifetime qualifier.
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
unsigned QualificationIncludesObjCLifetime
Whether the qualification conversion involves a change in the Objective-C lifetime (for automatic ref...
void setToType(unsigned Idx, QualType T)
bool isPointerConversionToBool() const
isPointerConversionToBool - Determines whether this conversion is a conversion of a pointer or pointe...
void * ToTypePtrs[3]
ToType - The types that this conversion is converting to in each step.
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType, bool IgnoreFloatToIntegralConversion=false) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
unsigned IsLvalueReference
Whether this is an lvalue reference binding (otherwise, it's an rvalue reference binding).
ImplicitConversionKind Dimension
Dimension - Between the second and third conversion a vector or matrix dimension conversion may occur...
unsigned BindsToFunctionLvalue
Whether we're binding to a function lvalue.
unsigned DirectBinding
DirectBinding - True when this is a reference binding that is a direct binding (C++ [dcl....
ImplicitConversionRank getRank() const
getRank - Retrieve the rank of this standard conversion sequence (C++ 13.3.3.1.1p3).
bool isPointerConversionToVoidPointer(ASTContext &Context) const
isPointerConversionToVoidPointer - Determines whether this conversion is a conversion of a pointer to...
void setAllToTypes(QualType T)
unsigned FromBracedInitList
Whether the source expression was originally a single element braced-init-list.
QualType getToType(unsigned Idx) const
SourceLocation getEndLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
StringRef getString() const
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
virtual bool hasIbm128Type() const
Determine whether the __ibm128 type is supported on this target.
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
A convenient class for passing around template argument information.
A template argument list.
Represents a template argument.
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
QualType getAsType() const
Retrieve the type for a type template argument.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
@ Template
The template argument is a template name that was provided for a template template parameter.
@ Pack
The template argument is actually a parameter pack.
ArgKind getKind() const
Return the kind of stored template argument.
The base class of all kinds of template declarations (e.g., class, function, etc.).
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.
@ Template
A single template declaration.
bool hasAssociatedConstraints() const
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
SmallVector< TemplateSpecCandidate, 16 >::iterator iterator
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
void clear()
Clear out all of the candidates.
SourceLocation getLocation() const
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Declaration of a template type parameter.
const Type * getTypeForDecl() const
The base class of the type hierarchy.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
bool isBlockPointerType() const
bool isBooleanType() const
bool isObjCBuiltinType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isIncompleteArrayType() const
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isFloat16Type() const
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isRValueReferenceType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isConstantArrayType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool isConvertibleToFixedPointType() const
Return true if this can be converted to (or from) a fixed point type.
CXXRecordDecl * castAsCXXRecordDecl() const
bool isArithmeticType() const
bool isPointerType() const
bool isArrayParameterType() const
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
bool isObjCQualifiedIdType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
bool isExtVectorBoolType() const
bool isObjCObjectOrInterfaceType() const
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isLValueReferenceType() const
bool isBitIntType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
const BuiltinType * getAsPlaceholderType() const
bool isMemberPointerType() const
bool isObjCIdType() const
bool isMatrixType() const
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
bool isBFloat16Type() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isVectorType() const
bool isObjCClassType() const
bool isRealFloatingType() const
Floating point categories.
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
bool isHLSLAttributedResourceType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode.
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
DeclarationName getMemberName() const
Retrieve the name of the member that this expression refers to.
QualType getBaseType() const
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getMemberLoc() const
Retrieve the location of the name of the member that this expression refers to.
A set of unresolved declarations.
ArrayRef< DeclAccessPair > pairs() const
void addDecl(NamedDecl *D)
The iterator over UnresolvedSets.
A set of unresolved declarations.
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
static UserDefinedLiteral * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation LitEndLoc, SourceLocation SuffixLoc, FPOptionsOverride FPFeatures)
unsigned getNumElements() const
QualType getElementType() const
Provides information about an attempted template argument deduction, whose success or failure was des...
TemplateArgumentList * takeSugared()
Take ownership of the deduced template argument lists.
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
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.
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
unsigned CallArgIndex
The index of the function argument that caused a deduction failure.
bool hasStrictPackMatch() const
specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are o...
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
@ Warning
Present this diagnostic as a warning.
@ Error
Present this diagnostic as an error.
bool Ret(InterpState &S, CodePtr &PC)
void checkAssignmentLifetime(Sema &SemaRef, const AssignedEntity &Entity, Expr *Init)
Check that the lifetime of the given expr (and its subobjects) is sufficient for assigning to the ent...
The JSON file list parser is used to communicate input to InstallAPI.
ImplicitConversionRank GetDimensionConversionRank(ImplicitConversionRank Base, ImplicitConversionKind Dimension)
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
@ NUM_OVERLOADED_OPERATORS
@ NonFunction
This is not an overload because the lookup results contain a non-function.
@ Match
This is not an overload because the signature exactly matches an existing declaration.
@ Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
bool isa(CodeGen::Address addr)
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
bool isBetterOverloadCandidate(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2, SourceLocation Loc, OverloadCandidateSet::CandidateSetKind Kind, bool PartialOverloading=false)
isBetterOverloadCandidate - Determines whether the first overload candidate is a better candidate tha...
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ ovl_fail_final_conversion_not_exact
This conversion function template specialization candidate is not viable because the final conversion...
@ ovl_fail_enable_if
This candidate function was not viable because an enable_if attribute disabled it.
@ ovl_fail_illegal_constructor
This conversion candidate was not considered because it is an illegal instantiation of a constructor ...
@ ovl_fail_bad_final_conversion
This conversion candidate is not viable because its result type is not implicitly convertible to the ...
@ ovl_fail_module_mismatched
This candidate was not viable because it has internal linkage and is from a different module unit tha...
@ ovl_fail_too_few_arguments
@ ovl_fail_addr_not_available
This candidate was not viable because its address could not be taken.
@ ovl_fail_too_many_arguments
@ ovl_non_default_multiversion_function
This candidate was not viable because it is a non-default multiversioned function.
@ ovl_fail_constraints_not_satisfied
This candidate was not viable because its associated constraints were not satisfied.
@ ovl_fail_bad_conversion
@ ovl_fail_bad_target
(CUDA) This candidate was not viable because the callee was not accessible from the caller's target (...
@ ovl_fail_inhctor_slice
This inherited constructor is not viable because it would slice the argument.
@ ovl_fail_object_addrspace_mismatch
This constructor/conversion candidate fail due to an address space mismatch between the object being ...
@ ovl_fail_explicit
This candidate constructor or conversion function is explicit but the context doesn't permit explicit...
@ ovl_fail_trivial_conversion
This conversion candidate was not considered because it duplicates the work of a trivial or derived-t...
@ Comparison
A comparison.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
ImplicitConversionRank
ImplicitConversionRank - The rank of an implicit conversion kind.
@ ICR_Conversion
Conversion.
@ ICR_Writeback_Conversion
ObjC ARC writeback conversion.
@ ICR_HLSL_Dimension_Reduction
HLSL Matching Dimension Reduction.
@ ICR_HLSL_Dimension_Reduction_Conversion
HLSL Dimension reduction with conversion.
@ ICR_HLSL_Scalar_Widening
HLSL Scalar Widening.
@ ICR_C_Conversion
Conversion only allowed in the C standard (e.g. void* to char*).
@ ICR_OCL_Scalar_Widening
OpenCL Scalar Widening.
@ ICR_Complex_Real_Conversion
Complex <-> Real conversion.
@ ICR_HLSL_Scalar_Widening_Conversion
HLSL Scalar Widening with conversion.
@ ICR_HLSL_Dimension_Reduction_Promotion
HLSL Dimension reduction with promotion.
@ ICR_Promotion
Promotion.
@ ICR_Exact_Match
Exact Match.
@ ICR_C_Conversion_Extension
Conversion not allowed by the C standard, but that we accept as an extension anyway.
@ ICR_HLSL_Scalar_Widening_Promotion
HLSL Scalar Widening with promotion.
OverloadCandidateDisplayKind
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_ViableCandidates
Requests that only viable candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
@ OK_Ordinary
An ordinary object is located at an address in memory.
Expr::ConstantExprKind ConstantExprKind
OverloadCandidateParamOrder
The parameter ordering that will be used for the candidate.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
OverloadsShown
Specifies which overload candidates to display when overload resolution fails.
@ Ovl_Best
Show just the "best" overload candidates.
llvm::MutableArrayRef< ImplicitConversionSequence > ConversionSequenceList
A list of implicit conversion sequences for the arguments of an OverloadCandidate.
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
OverloadCandidateRewriteKind
The kinds of rewrite we perform on overload candidates.
@ CRK_Reversed
Candidate is a rewritten candidate with a reversed order of parameters.
@ CRK_None
Candidate is not a rewritten candidate.
@ CRK_DifferentOperator
Candidate is a rewritten candidate with a different operator name.
MutableArrayRef< Expr * > MultiExprArg
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ Result
The result type of a method or function.
const FunctionProtoType * T
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter's...
@ ICK_Complex_Conversion
Complex conversions (C99 6.3.1.6)
@ ICK_Floating_Promotion
Floating point promotions (C++ [conv.fpprom])
@ ICK_Boolean_Conversion
Boolean conversions (C++ [conv.bool])
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Fixed_Point_Conversion
Fixed point type conversions according to N1169.
@ ICK_Vector_Conversion
Vector conversions.
@ ICK_Block_Pointer_Conversion
Block Pointer conversions.
@ ICK_Pointer_Member
Pointer-to-member conversions (C++ [conv.mem])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_HLSL_Array_RValue
HLSL non-decaying array rvalue cast.
@ ICK_SVE_Vector_Conversion
Arm SVE Vector conversions.
@ ICK_HLSL_Vector_Truncation
HLSL vector truncation.
@ ICK_Incompatible_Pointer_Conversion
C-only conversion between pointers with incompatible types.
@ ICK_Array_To_Pointer
Array-to-pointer conversion (C++ [conv.array])
@ ICK_RVV_Vector_Conversion
RISC-V RVV Vector conversions.
@ ICK_Complex_Promotion
Complex promotions (Clang extension)
@ ICK_Num_Conversion_Kinds
The number of conversion kinds.
@ ICK_Function_Conversion
Function pointer conversion (C++17 [conv.fctptr])
@ ICK_Vector_Splat
A vector splat from an arithmetic type.
@ ICK_Zero_Queue_Conversion
Zero constant to queue.
@ ICK_Identity
Identity conversion (no conversion)
@ ICK_Derived_To_Base
Derived-to-base (C++ [over.best.ics])
@ ICK_Lvalue_To_Rvalue
Lvalue-to-rvalue conversion (C++ [conv.lval])
@ ICK_Qualification
Qualification conversions (C++ [conv.qual])
@ ICK_Pointer_Conversion
Pointer conversions (C++ [conv.ptr])
@ ICK_TransparentUnionConversion
Transparent Union Conversions.
@ ICK_Integral_Promotion
Integral promotions (C++ [conv.prom])
@ ICK_Floating_Conversion
Floating point conversions (C++ [conv.double].
@ ICK_Compatible_Conversion
Conversions between compatible types in C99.
@ ICK_C_Only_Conversion
Conversions allowed in C, but not C++.
@ ICK_Writeback_Conversion
Objective-C ARC writeback conversion.
@ ICK_Zero_Event_Conversion
Zero constant to event (OpenCL1.2 6.12.10)
@ ICK_Complex_Real
Complex-real conversions (C99 6.3.1.7)
@ ICK_Function_To_Pointer
Function-to-pointer (C++ [conv.array])
@ Template
We are parsing a template declaration.
ActionResult< CXXBaseSpecifier * > BaseResult
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ IncompatiblePointer
IncompatiblePointer - The assignment is between two pointers types that are not compatible,...
@ CompatiblePointerDiscardsQualifiers
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
@ Compatible
Compatible - the types are compatible according to the standard.
@ IncompatiblePointerSign
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
@ FunctionTemplate
The name was classified as a function template name.
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
CXXSpecialMemberKind
Kinds of C++ special members.
OverloadedOperatorKind getRewrittenOverloadedOperator(OverloadedOperatorKind Kind)
Get the other overloaded operator that the given operator can be rewritten into, if any such operator...
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
bool shouldEnforceArgLimit(bool PartialOverloading, FunctionDecl *Function)
SmallVector< CXXBaseSpecifier *, 4 > CXXCastPath
A simple array of base specifiers.
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
NarrowingKind
NarrowingKind - The kind of narrowing conversion being performed by a standard conversion sequence ac...
@ NK_Not_Narrowing
Not a narrowing conversion.
@ NK_Constant_Narrowing
A narrowing conversion, because a constant expression got narrowed.
@ NK_Dependent_Narrowing
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
@ NK_Type_Narrowing
A narrowing conversion by virtue of the source and destination types.
@ NK_Variable_Narrowing
A narrowing conversion, because a non-constant-expression variable might have got narrowed.
@ TPOC_Conversion
Partial ordering of function templates for a call to a conversion function.
@ TPOC_Call
Partial ordering of function templates for a function call.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
TemplateDeductionResult
Describes the result of template argument deduction.
@ MiscellaneousDeductionFailure
Deduction failed; that's all we know.
@ NonDependentConversionFailure
Checking non-dependent argument conversions failed.
@ ConstraintsNotSatisfied
The deduced arguments did not satisfy the constraints associated with the template.
@ Underqualified
Template argument deduction failed due to inconsistent cv-qualifiers on a template parameter type tha...
@ InstantiationDepth
Template argument deduction exceeded the maximum template instantiation depth (which has already been...
@ InvalidExplicitArguments
The explicitly-specified template arguments were not valid template arguments for the given template.
@ 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.
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword.
U cast(CodeGen::Address addr)
ConstructorInfo getConstructorInfo(NamedDecl *ND)
CCEKind
Contexts in which a converted constant expression is required.
@ TemplateArg
Value of a non-type template parameter.
@ Noexcept
Condition in a noexcept(bool) specifier.
@ ArrayBound
Array bound in array declarator or new-expression.
@ TempArgStrict
As above, but applies strict template checking rules.
@ ExplicitBool
Condition in an explicit(bool) specifier.
ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind)
GetConversionRank - Retrieve the implicit conversion rank corresponding to the given implicit convers...
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
ActionResult< Expr * > ExprResult
@ EST_None
no exception specification
@ ForBuiltinOverloadedOp
A conversion for an operand of a builtin overloaded operator.
__DEVICE__ _Tp abs(const std::complex< _Tp > &__c)
Represents an ambiguous user-defined conversion sequence.
ConversionSet::const_iterator const_iterator
ConversionSet & conversions()
SmallVector< std::pair< NamedDecl *, FunctionDecl * >, 4 > ConversionSet
void setFromType(QualType T)
void setToType(QualType T)
void addConversion(NamedDecl *Found, FunctionDecl *D)
void copyFrom(const AmbiguousConversionSequence &)
const Expr * ConstraintExpr
UnsignedOrNone ArgPackSubstIndex
QualType getToType() const
QualType getFromType() const
OverloadFixItKind Kind
The type of fix applied.
unsigned NumConversionsFixed
The number of Conversions fixed.
void setConversionChecker(TypeComparisonFuncTy Foo)
Resets the default conversion checker method.
std::vector< FixItHint > Hints
The list of Hints generated so far.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
void setCXXOperatorNameRange(SourceRange R)
setCXXOperatorNameRange - Sets the range of the operator name (without the operator keyword).
const DeclarationNameLoc & getInfo() const
SourceLocation getCXXLiteralOperatorNameLoc() const
getCXXLiteralOperatorNameLoc - Returns the location of the literal operator name (not the operator ke...
A structure used to record information about a failed template argument deduction,...
void * Data
Opaque pointer containing additional data about this deduction failure.
const TemplateArgument * getSecondArg()
Return the second template argument this deduction failure refers to, if any.
unsigned Result
A Sema::TemplateDeductionResult.
PartialDiagnosticAt * getSFINAEDiagnostic()
Retrieve the diagnostic which caused this deduction failure, if any.
unsigned HasDiagnostic
Indicates whether a diagnostic is stored in Diagnostic.
TemplateDeductionResult getResult() const
void Destroy()
Free any memory associated with this deduction failure.
char Diagnostic[sizeof(PartialDiagnosticAt)]
A diagnostic indicating why deduction failed.
UnsignedOrNone getCallArgIndex()
Return the index of the call argument that this deduction failure refers to, if any.
TemplateParameter getTemplateParameter()
Retrieve the template parameter this deduction failure refers to, if any.
TemplateArgumentList * getTemplateArgumentList()
Retrieve the template argument list associated with this deduction failure, if any.
const TemplateArgument * getFirstArg()
Return the first template argument this deduction failure refers to, if any.
DeferredTemplateOverloadCandidate * Next
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Extra information about a function prototype.
FunctionEffectsRef FunctionEffects
const ExtParameterInfo * ExtParameterInfos
Information about operator rewrites to consider when adding operator functions to a candidate set.
bool shouldAddReversed(Sema &S, ArrayRef< Expr * > OriginalArgs, FunctionDecl *FD)
Determine whether we should add a rewritten candidate for FD with reversed parameter order.
bool allowsReversed(OverloadedOperatorKind Op)
Determine whether reversing parameter order is allowed for operator Op.
SourceLocation OpLoc
The source location of the operator.
bool AllowRewrittenCandidates
Whether we should include rewritten candidates in the overload set.
bool isReversible()
Determines whether this operator could be implemented by a function with reversed parameter order.
bool isAcceptableCandidate(const FunctionDecl *FD)
OverloadCandidateRewriteKind getRewriteKind(const FunctionDecl *FD, OverloadCandidateParamOrder PO)
Determine the kind of rewrite that should be performed for this candidate.
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
unsigned StrictPackMatch
Have we matched any packs on the parameter side, versus any non-packs on the argument side,...
unsigned IgnoreObjectArgument
IgnoreObjectArgument - True to indicate that the first argument's conversion, which for this function...
bool TryToFixBadConversion(unsigned Idx, Sema &S)
bool NotValidBecauseConstraintExprHasError() const
unsigned IsADLCandidate
True if the candidate was found using ADL.
unsigned IsSurrogate
IsSurrogate - True to indicate that this candidate is a surrogate for a conversion to a function poin...
QualType BuiltinParamTypes[3]
BuiltinParamTypes - Provides the parameter types of a built-in overload candidate.
DeclAccessPair FoundDecl
FoundDecl - The original declaration that was looked up / invented / otherwise found,...
FunctionDecl * Function
Function - The actual function that this candidate represents.
unsigned RewriteKind
Whether this is a rewritten candidate, and if so, of what kind?
ConversionFixItGenerator Fix
The FixIt hints which can be used to fix the Bad candidate.
unsigned Best
Whether this candidate is the best viable function, or tied for being the best viable function.
StandardConversionSequence FinalConversion
FinalConversion - For a conversion function (where Function is a CXXConversionDecl),...
unsigned getNumParams() const
unsigned HasFinalConversion
Whether FinalConversion has been set.
unsigned TookAddressOfOverload
unsigned FailureKind
FailureKind - The reason why this candidate is not viable.
unsigned ExplicitCallArguments
The number of call arguments that were explicitly provided, to be used while performing partial order...
ConversionSequenceList Conversions
The conversion sequences used to convert the function arguments to the function parameters.
DeductionFailureInfo DeductionFailure
unsigned Viable
Viable - True to indicate that this overload candidate is viable.
CXXConversionDecl * Surrogate
Surrogate - The conversion function for which this candidate is a surrogate, but only if IsSurrogate ...
OverloadCandidateRewriteKind getRewriteKind() const
Get RewriteKind value in OverloadCandidateRewriteKind type (This function is to workaround the spurio...
bool HasFormOfMemberPointer
OverloadExpr * Expression
bool SuppressUserConversions
Do not consider any user-defined conversions when constructing the initializing sequence.
bool OnlyInitializeNonUserDefinedConversions
Before constructing the initializing sequence, we check whether the parameter type and argument type ...
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
@ RewritingOperatorAsSpaceship
We are rewriting a comparison operator in terms of an operator<=>.
Decl * Entity
The entity that is being synthesized.
Abstract class used to diagnose incomplete types.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
const Type * Ty
The locally-unqualified type.
Qualifiers Quals
The local qualifiers.
TemplateSpecCandidate - This is a generalization of OverloadCandidate which keeps track of template a...
void NoteDeductionFailure(Sema &S, bool ForTakingAddress)
Diagnose a template argument deduction failure.
DeductionFailureInfo DeductionFailure
Template argument deduction info.
Decl * Specialization
Specialization - The actual specialization that this candidate represents.
DeclAccessPair FoundDecl
The declaration that was looked up, together with its access.
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
UserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13....
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion.
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ....
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
void dump() const
dump - Print this user-defined conversion sequence to standard error.
Describes an entity that is being assigned.