41 #include "llvm/ADT/DenseSet.h"
42 #include "llvm/ADT/STLExtras.h"
43 #include "llvm/ADT/STLForwardCompat.h"
44 #include "llvm/ADT/SmallPtrSet.h"
45 #include "llvm/ADT/SmallString.h"
46 #include "llvm/ADT/SmallVector.h"
47 #include "llvm/Support/Casting.h"
53 using namespace clang;
60 return P->hasAttr<PassObjectSizeAttr>();
81 if (HadMultipleCandidates)
92 CK_FunctionToPointerDecay);
96 bool InOverloadResolution,
99 bool AllowObjCWritebackConversion);
103 bool InOverloadResolution,
111 bool AllowObjCConversionOnExplicit);
177 static const char *
const Name[] = {
181 "Function-to-pointer",
182 "Function pointer conversion",
184 "Integral promotion",
185 "Floating point promotion",
187 "Integral conversion",
188 "Floating conversion",
189 "Complex conversion",
190 "Floating-integral conversion",
191 "Pointer conversion",
192 "Pointer-to-member conversion",
193 "Boolean conversion",
194 "Compatible-types conversion",
195 "Derived-to-base conversion",
197 "SVE Vector conversion",
198 "RVV Vector conversion",
200 "Complex-real conversion",
201 "Block Pointer conversion",
202 "Transparent Union Conversion",
203 "Writeback conversion",
204 "OpenCL Zero Event Conversion",
205 "OpenCL Zero Queue Conversion",
206 "C specific type conversion",
207 "Incompatible pointer conversion",
208 "Fixed point conversion",
209 "HLSL vector truncation",
210 "Non-decaying array conversion",
223 DeprecatedStringLiteralToCharPtr =
false;
224 QualificationIncludesObjCLifetime =
false;
225 ReferenceBinding =
false;
226 DirectBinding =
false;
227 IsLvalueReference =
true;
228 BindsToFunctionLvalue =
false;
229 BindsToRvalue =
false;
230 BindsImplicitObjectArgumentWithoutRefQualifier =
false;
231 ObjCLifetimeConversionBinding =
false;
261 (getFromType()->isPointerType() ||
262 getFromType()->isMemberPointerType() ||
263 getFromType()->isObjCObjectPointerType() ||
264 getFromType()->isBlockPointerType() ||
297 const Expr *Converted) {
300 if (
auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
307 while (
auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
308 switch (ICE->getCastKind()) {
310 case CK_IntegralCast:
311 case CK_IntegralToBoolean:
312 case CK_IntegralToFloating:
313 case CK_BooleanToSignedIntegral:
314 case CK_FloatingToIntegral:
315 case CK_FloatingToBoolean:
316 case CK_FloatingCast:
317 Converted = ICE->getSubExpr();
341 QualType &ConstantType,
bool IgnoreFloatToIntegralConversion)
const {
343 "narrowing check outside C++");
354 ToType = ET->getDecl()->getIntegerType();
360 goto FloatingIntegralConversion;
362 goto IntegralConversion;
373 FloatingIntegralConversion:
378 if (IgnoreFloatToIntegralConversion)
381 assert(
Initializer &&
"Unknown conversion expression");
387 if (std::optional<llvm::APSInt> IntConstantValue =
391 Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
392 llvm::APFloat::rmNearestTiesToEven);
396 Result.convertToInteger(ConvertedValue,
397 llvm::APFloat::rmTowardZero, &ignored);
399 if (*IntConstantValue != ConvertedValue) {
400 ConstantValue =
APValue(*IntConstantValue);
427 Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
430 ConstantValue = R.
Val;
431 assert(ConstantValue.
isFloat());
436 llvm::APFloat::opStatus ConvertStatus =
438 llvm::APFloat::rmNearestTiesToEven, &ignored);
440 llvm::APFloat::rmNearestTiesToEven, &ignored);
442 if (FloatVal.isNaN() && Converted.isNaN() &&
443 !FloatVal.isSignaling() && !Converted.isSignaling()) {
449 if (!Converted.bitwiseIsEqual(FloatVal)) {
456 if (ConvertStatus & llvm::APFloat::opOverflow) {
473 IntegralConversion: {
477 const unsigned FromWidth = Ctx.
getIntWidth(FromType);
481 if (FromWidth > ToWidth ||
482 (FromWidth == ToWidth && FromSigned != ToSigned) ||
483 (FromSigned && !ToSigned)) {
491 std::optional<llvm::APSInt> OptInitializerValue;
492 if (!(OptInitializerValue =
Initializer->getIntegerConstantExpr(Ctx))) {
497 bool Narrowing =
false;
498 if (FromWidth < ToWidth) {
501 if (InitializerValue.isSigned() && InitializerValue.isNegative())
506 InitializerValue = InitializerValue.extend(
507 InitializerValue.getBitWidth() + 1);
510 ConvertedValue = ConvertedValue.trunc(ToWidth);
511 ConvertedValue.setIsSigned(ToSigned);
512 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
513 ConvertedValue.setIsSigned(InitializerValue.isSigned());
515 if (ConvertedValue != InitializerValue)
520 ConstantValue =
APValue(InitializerValue);
536 ConstantValue = R.
Val;
537 assert(ConstantValue.
isFloat());
543 if (FloatVal.isNaN() && FloatVal.isSignaling()) {
559 raw_ostream &OS = llvm::errs();
560 bool PrintedSomething =
false;
563 PrintedSomething =
true;
567 if (PrintedSomething) {
573 OS <<
" (by copy constructor)";
574 }
else if (DirectBinding) {
575 OS <<
" (direct reference binding)";
576 }
else if (ReferenceBinding) {
577 OS <<
" (reference binding)";
579 PrintedSomething =
true;
583 if (PrintedSomething) {
587 PrintedSomething =
true;
590 if (!PrintedSomething) {
591 OS <<
"No conversions required";
598 raw_ostream &OS = llvm::errs();
599 if (Before.First || Before.Second || Before.Third) {
603 if (ConversionFunction)
604 OS <<
'\'' << *ConversionFunction <<
'\'';
606 OS <<
"aggregate initialization";
616 raw_ostream &OS = llvm::errs();
617 if (hasInitializerListContainerType())
618 OS <<
"Worst list element conversion: ";
619 switch (ConversionKind) {
620 case StandardConversion:
621 OS <<
"Standard conversion: ";
624 case UserDefinedConversion:
625 OS <<
"User-defined conversion: ";
628 case EllipsisConversion:
629 OS <<
"Ellipsis conversion";
631 case AmbiguousConversion:
632 OS <<
"Ambiguous conversion";
635 OS <<
"Bad conversion";
647 conversions().~ConversionSet();
660 struct DFIArguments {
666 struct DFIParamWithArguments : DFIArguments {
671 struct DFIDeducedMismatchArgs : DFIArguments {
673 unsigned CallArgIndex;
690 Result.Result =
static_cast<unsigned>(TDK);
691 Result.HasDiagnostic =
false;
699 Result.Data =
nullptr;
704 Result.Data = Info.
Param.getOpaqueValue();
710 auto *Saved =
new (Context) DFIDeducedMismatchArgs;
721 DFIArguments *Saved =
new (Context) DFIArguments;
733 DFIParamWithArguments *Saved =
new (Context) DFIParamWithArguments;
734 Saved->Param = Info.
Param;
747 Result.HasDiagnostic =
true;
752 CNSInfo *Saved =
new (Context) CNSInfo;
762 llvm_unreachable(
"not a deduction failure");
795 Diag->~PartialDiagnosticAt();
796 HasDiagnostic =
false;
804 Diag->~PartialDiagnosticAt();
805 HasDiagnostic =
false;
840 return TemplateParameter::getFromOpaqueValue(
Data);
845 return static_cast<DFIParamWithArguments*
>(
Data)->Param;
875 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->TemplateArgs;
881 return static_cast<CNSInfo*
>(
Data)->TemplateArgs;
913 return &
static_cast<DFIArguments*
>(
Data)->FirstArg;
945 return &
static_cast<DFIArguments*
>(
Data)->SecondArg;
960 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->CallArgIndex;
976 for (
unsigned I = 0; I <
X->getNumParams(); ++I)
980 if (
auto *FTX =
X->getDescribedFunctionTemplate()) {
985 FTY->getTemplateParameters()))
994 OverloadedOperatorKind::OO_EqualEqual);
1006 OverloadedOperatorKind::OO_ExclaimEqual);
1007 if (isa<CXXMethodDecl>(EqFD)) {
1014 Sema::LookupNameKind::LookupMemberName);
1024 auto *NotEqFD = Op->getAsFunction();
1025 if (
auto *UD = dyn_cast<UsingShadowDecl>(Op))
1026 NotEqFD = UD->getUnderlyingDecl()->getAsFunction();
1029 cast<Decl>(Op->getLexicalDeclContext())))
1037 if (!AllowRewrittenCandidates)
1039 return Op == OO_EqualEqual || Op == OO_Spaceship;
1045 if (!allowsReversed(Op))
1047 if (Op == OverloadedOperatorKind::OO_EqualEqual) {
1048 assert(OriginalArgs.size() == 2);
1050 S, OpLoc, OriginalArgs[1], FD))
1061 void OverloadCandidateSet::destroyCandidates() {
1062 for (
iterator i = begin(), e = end(); i != e; ++i) {
1063 for (
auto &C : i->Conversions)
1064 C.~ImplicitConversionSequence();
1066 i->DeductionFailure.Destroy();
1071 destroyCandidates();
1072 SlabAllocator.Reset();
1073 NumInlineBytesUsed = 0;
1080 class UnbridgedCastsSet {
1090 Entry entry = { &E, E };
1091 Entries.push_back(entry);
1097 i = Entries.begin(), e = Entries.end(); i != e; ++i)
1098 *i->Addr = i->Saved;
1112 UnbridgedCastsSet *unbridgedCasts =
nullptr) {
1116 if (placeholder->getKind() == BuiltinType::Overload)
return false;
1120 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
1122 unbridgedCasts->save(S, E);
1142 UnbridgedCastsSet &unbridged) {
1143 for (
unsigned i = 0, e = Args.size(); i != e; ++i)
1185 NamedDecl *&Match,
bool NewIsUsingDecl) {
1190 bool OldIsUsingDecl =
false;
1191 if (isa<UsingShadowDecl>(OldD)) {
1192 OldIsUsingDecl =
true;
1196 if (NewIsUsingDecl)
continue;
1198 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
1203 if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
1211 bool UseMemberUsingDeclRules =
1212 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
1216 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
1217 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
1218 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
1222 if (!isa<FunctionTemplateDecl>(OldD) &&
1223 !shouldLinkPossiblyHiddenDecl(*I, New))
1232 if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
1234 return Ovl_NonFunction;
1236 }
else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1240 }
else if (isa<TagDecl>(OldD)) {
1242 }
else if (
auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1249 if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1251 return Ovl_NonFunction;
1258 return Ovl_NonFunction;
1283 if (CheckFunctionTemplateSpecialization(New,
nullptr, TemplateSpecResult,
1286 return Ovl_Overload;
1293 return Ovl_Overload;
1298 bool UseMemberUsingDeclRules,
1299 bool ConsiderCudaAttrs,
1300 bool UseOverrideRules =
false) {
1317 if ((OldTemplate ==
nullptr) != (NewTemplate ==
nullptr))
1330 if (isa<FunctionNoProtoType>(OldQType.
getTypePtr()) ||
1331 isa<FunctionNoProtoType>(NewQType.
getTypePtr()))
1334 const auto *OldType = cast<FunctionProtoType>(OldQType);
1335 const auto *NewType = cast<FunctionProtoType>(NewQType);
1340 if (OldQType != NewQType && OldType->isVariadic() != NewType->isVariadic())
1355 OldDecl = OldTemplate;
1356 NewDecl = NewTemplate;
1374 bool ConstraintsInTemplateHead =
1385 if (UseMemberUsingDeclRules && ConstraintsInTemplateHead &&
1386 !SameTemplateParameterList)
1388 if (!UseMemberUsingDeclRules &&
1389 (!SameTemplateParameterList || !SameReturnType))
1393 const auto *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1394 const auto *NewMethod = dyn_cast<CXXMethodDecl>(New);
1396 int OldParamsOffset = 0;
1397 int NewParamsOffset = 0;
1415 !isa<CXXConstructorDecl>(NewMethod))
1421 auto BS =
Base.getNonReferenceType().getCanonicalType().split();
1422 BS.Quals = NormalizeQualifiers(OldMethod, BS.Quals);
1424 auto DS = D.getNonReferenceType().getCanonicalType().split();
1425 DS.Quals = NormalizeQualifiers(NewMethod, DS.Quals);
1427 if (BS.Quals != DS.Quals)
1430 if (OldMethod->isImplicitObjectMemberFunction() &&
1431 OldMethod->getParent() != NewMethod->getParent()) {
1444 if (
Base->isLValueReferenceType())
1446 return Base->isRValueReferenceType() == D->isRValueReferenceType();
1451 auto DiagnoseInconsistentRefQualifiers = [&]() {
1454 if (OldMethod->getRefQualifier() == NewMethod->getRefQualifier())
1456 if (OldMethod->isExplicitObjectMemberFunction() ||
1457 NewMethod->isExplicitObjectMemberFunction())
1459 if (!UseMemberUsingDeclRules && (OldMethod->getRefQualifier() ==
RQ_None ||
1460 NewMethod->getRefQualifier() ==
RQ_None)) {
1461 SemaRef.
Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1462 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1463 SemaRef.
Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1469 if (OldMethod && OldMethod->isExplicitObjectMemberFunction())
1471 if (NewMethod && NewMethod->isExplicitObjectMemberFunction())
1474 if (OldType->getNumParams() - OldParamsOffset !=
1475 NewType->getNumParams() - NewParamsOffset ||
1477 {OldType->param_type_begin() + OldParamsOffset,
1478 OldType->param_type_end()},
1479 {NewType->param_type_begin() + NewParamsOffset,
1480 NewType->param_type_end()},
1485 if (OldMethod && NewMethod && !OldMethod->isStatic() &&
1486 !NewMethod->isStatic()) {
1487 bool HaveCorrespondingObjectParameters = [&](
const CXXMethodDecl *Old,
1489 auto NewObjectType = New->getFunctionObjectParameterReferenceType();
1493 return F->getRefQualifier() ==
RQ_None &&
1494 !F->isExplicitObjectMemberFunction();
1497 if (IsImplicitWithNoRefQual(Old) != IsImplicitWithNoRefQual(New) &&
1498 CompareType(OldObjectType.getNonReferenceType(),
1499 NewObjectType.getNonReferenceType()))
1501 return CompareType(OldObjectType, NewObjectType);
1502 }(OldMethod, NewMethod);
1504 if (!HaveCorrespondingObjectParameters) {
1505 if (DiagnoseInconsistentRefQualifiers())
1510 if (!UseOverrideRules || (!NewMethod->isExplicitObjectMemberFunction() &&
1511 !OldMethod->isExplicitObjectMemberFunction()))
1516 if (!UseOverrideRules &&
1520 if ((NewRC !=
nullptr) != (OldRC !=
nullptr))
1527 if (NewMethod && OldMethod && OldMethod->isImplicitObjectMemberFunction() &&
1528 NewMethod->isImplicitObjectMemberFunction()) {
1529 if (DiagnoseInconsistentRefQualifiers())
1547 NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1548 if (NewI == NewE || OldI == OldE)
1550 llvm::FoldingSetNodeID NewID, OldID;
1552 OldI->getCond()->Profile(OldID, SemaRef.
Context,
true);
1557 if (SemaRef.
getLangOpts().CUDA && ConsiderCudaAttrs) {
1560 if (!isa<CXXDestructorDecl>(New)) {
1565 "Unexpected invalid target.");
1569 if (NewTarget != OldTarget)
1580 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs) {
1586 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs) {
1599 bool SuppressUserConversions,
1601 bool InOverloadResolution,
1603 bool AllowObjCWritebackConversion,
1604 bool AllowObjCConversionOnExplicit) {
1607 if (SuppressUserConversions) {
1618 Conversions, AllowExplicit,
1619 AllowObjCConversionOnExplicit)) {
1636 if (Constructor->isCopyConstructor() &&
1637 (FromCanon == ToCanon ||
1648 if (ToCanon != FromCanon)
1659 Cand != Conversions.
end(); ++Cand)
1702 bool SuppressUserConversions,
1704 bool InOverloadResolution,
1706 bool AllowObjCWritebackConversion,
1707 bool AllowObjCConversionOnExplicit) {
1710 ICS.
Standard, CStyle, AllowObjCWritebackConversion)){
1750 AllowExplicit, InOverloadResolution, CStyle,
1751 AllowObjCWritebackConversion,
1752 AllowObjCConversionOnExplicit);
1757 bool SuppressUserConversions,
1759 bool InOverloadResolution,
1761 bool AllowObjCWritebackConversion) {
1763 AllowExplicit, InOverloadResolution, CStyle,
1764 AllowObjCWritebackConversion,
1775 bool AllowExplicit) {
1780 bool AllowObjCWritebackConversion
1781 = getLangOpts().ObjCAutoRefCount &&
1782 (Action == AA_Passing || Action == AA_Sending);
1783 if (getLangOpts().ObjC)
1784 ObjC().CheckObjCBridgeRelatedConversions(From->
getBeginLoc(), ToType,
1787 *
this, From, ToType,
1791 false, AllowObjCWritebackConversion,
1793 return PerformImplicitConversion(From, ToType, ICS, Action);
1814 if (TyClass != CanFrom->getTypeClass())
return false;
1815 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1816 if (TyClass == Type::Pointer) {
1819 }
else if (TyClass == Type::BlockPointer) {
1822 }
else if (TyClass == Type::MemberPointer) {
1826 if (ToMPT->getClass() != FromMPT->
getClass())
1828 CanTo = ToMPT->getPointeeType();
1834 TyClass = CanTo->getTypeClass();
1835 if (TyClass != CanFrom->getTypeClass())
return false;
1836 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1840 const auto *FromFn = cast<FunctionType>(CanFrom);
1843 const auto *ToFn = cast<FunctionType>(CanTo);
1846 bool Changed =
false;
1855 if (
const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1856 const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1857 if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1858 FromFn = cast<FunctionType>(
1869 bool CanUseToFPT, CanUseFromFPT;
1871 CanUseFromFPT, NewParamInfos) &&
1872 CanUseToFPT && !CanUseFromFPT) {
1875 NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1877 FromFPT->getParamTypes(), ExtInfo);
1886 assert(
QualType(FromFn, 0).isCanonical());
1887 if (
QualType(FromFn, 0) != CanTo)
return false;
1915 if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
1916 &ToSem == &llvm::APFloat::IEEEquad()) ||
1917 (&FromSem == &llvm::APFloat::IEEEquad() &&
1918 &ToSem == &llvm::APFloat::PPCDoubleDouble()))
1973 bool InOverloadResolution,
bool CStyle) {
1990 if (FromElts < ToElts)
1992 if (FromElts == ToElts)
2041 !ToType->
hasAttr(attr::ArmMveStrictPolymorphism))) {
2046 !InOverloadResolution && !CStyle) {
2048 << FromType << ToType;
2059 bool InOverloadResolution,
2072 bool InOverloadResolution,
2075 bool AllowObjCWritebackConversion) {
2122 if (Method && !Method->
isStatic() &&
2125 "Non-unary operator on non-static member address");
2126 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode()
2128 "Non-address-of operator on non-static member address");
2129 const Type *ClassType
2133 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode() ==
2135 "Non-address-of operator for overloaded function expression");
2154 FromType =
Atomic->getValueType();
2202 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
2239 bool IncompatibleObjC =
false;
2294 }
else if (AllowObjCWritebackConversion &&
2298 FromType, IncompatibleObjC)) {
2304 InOverloadResolution, FromType)) {
2308 From, InOverloadResolution, CStyle)) {
2318 S, From, ToType, InOverloadResolution, SCS, CStyle)) {
2354 bool ObjCLifetimeConversion;
2360 ObjCLifetimeConversion)) {
2379 CanonFrom = CanonTo;
2384 if (CanonFrom == CanonTo)
2389 if (S.
getLangOpts().CPlusPlus || !InOverloadResolution)
2433 bool InOverloadResolution,
2443 for (
const auto *it : UD->
fields()) {
2446 ToType = it->getType();
2476 return To->
getKind() == BuiltinType::Int;
2479 return To->
getKind() == BuiltinType::UInt;
2503 if (FromEnumType->getDecl()->isScoped())
2510 if (FromEnumType->getDecl()->isFixed()) {
2511 QualType Underlying = FromEnumType->getDecl()->getIntegerType();
2513 IsIntegralPromotion(
nullptr, Underlying, ToType);
2520 ToType, FromEnumType->getDecl()->getPromotionType());
2554 for (
int Idx = 0; Idx < 6; ++Idx) {
2556 if (FromSize < ToSize ||
2557 (FromSize == ToSize &&
2558 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2583 std::optional<llvm::APSInt> BitWidth;
2586 MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
2587 llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
2591 if (*BitWidth < ToSize ||
2593 return To->
getKind() == BuiltinType::Int;
2599 return To->
getKind() == BuiltinType::UInt;
2631 ToBuiltin->getKind() == BuiltinType::Double)
2639 FromBuiltin->getKind() == BuiltinType::Double) &&
2640 (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2641 ToBuiltin->getKind() == BuiltinType::Float128 ||
2642 ToBuiltin->getKind() == BuiltinType::Ibm128))
2647 if (getLangOpts().
HLSL && FromBuiltin->getKind() == BuiltinType::Half &&
2649 ToBuiltin->getKind() == BuiltinType::Double))
2653 if (!getLangOpts().NativeHalfType &&
2654 FromBuiltin->getKind() == BuiltinType::Half &&
2692 bool StripObjCLifetime =
false) {
2695 "Invalid similarly-qualified pointer type");
2706 if (StripObjCLifetime)
2717 if (isa<ObjCObjectPointerType>(ToType))
2726 if (isa<ObjCObjectPointerType>(ToType))
2732 bool InOverloadResolution,
2738 return !InOverloadResolution;
2762 bool InOverloadResolution,
2764 bool &IncompatibleObjC) {
2765 IncompatibleObjC =
false;
2766 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2773 ConvertedType = ToType;
2780 ConvertedType = ToType;
2787 ConvertedType = ToType;
2795 ConvertedType = ToType;
2805 ConvertedType = ToType;
2813 !getLangOpts().ObjCAutoRefCount) {
2843 if (getLangOpts().MSVCCompat && FromPointeeType->
isFunctionType() &&
2877 IsDerivedFrom(From->
getBeginLoc(), FromPointeeType, ToPointeeType)) {
2914 bool &IncompatibleObjC) {
2915 if (!getLangOpts().ObjC)
2927 if (ToObjCPtr && FromObjCPtr) {
2938 if (getLangOpts().CPlusPlus && LHS && RHS &&
2940 FromObjCPtr->getPointeeType()))
2945 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2953 IncompatibleObjC =
true;
2957 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2969 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2997 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2998 IncompatibleObjC)) {
3000 IncompatibleObjC =
true;
3002 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
3009 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
3010 IncompatibleObjC)) {
3013 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
3025 if (FromFunctionType && ToFunctionType) {
3034 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
3035 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic() ||
3036 FromFunctionType->
getMethodQuals() != ToFunctionType->getMethodQuals())
3039 bool HasObjCConversion =
false;
3043 }
else if (isObjCPointerConversion(FromFunctionType->
getReturnType(),
3044 ToFunctionType->getReturnType(),
3045 ConvertedType, IncompatibleObjC)) {
3047 HasObjCConversion =
true;
3054 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
3055 ArgIdx != NumArgs; ++ArgIdx) {
3057 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3061 }
else if (isObjCPointerConversion(FromArgType, ToArgType,
3062 ConvertedType, IncompatibleObjC)) {
3064 HasObjCConversion =
true;
3071 if (HasObjCConversion) {
3075 IncompatibleObjC =
true;
3107 if (!FromFunctionType || !ToFunctionType)
3110 if (Context.
hasSameType(FromPointeeType, ToPointeeType))
3115 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
3116 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic())
3121 if (FromEInfo != ToEInfo)
3124 bool IncompatibleObjC =
false;
3126 ToFunctionType->getReturnType())) {
3130 QualType LHS = ToFunctionType->getReturnType();
3131 if ((!getLangOpts().CPlusPlus || !RHS->
isRecordType()) &&
3137 }
else if (isObjCPointerConversion(RHS, LHS,
3138 ConvertedType, IncompatibleObjC)) {
3139 if (IncompatibleObjC)
3148 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
3149 ArgIdx != NumArgs; ++ArgIdx) {
3150 IncompatibleObjC =
false;
3152 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3153 if (Context.
hasSameType(FromArgType, ToArgType)) {
3155 }
else if (isObjCPointerConversion(ToArgType, FromArgType,
3156 ConvertedType, IncompatibleObjC)) {
3157 if (IncompatibleObjC)
3166 bool CanUseToFPT, CanUseFromFPT;
3168 CanUseToFPT, CanUseFromFPT,
3172 ConvertedType = ToType;
3213 if (!Context.
hasSameType(FromMember->getClass(), ToMember->getClass())) {
3215 <<
QualType(FromMember->getClass(), 0);
3248 if (!FromFunction || !ToFunction) {
3253 if (FromFunction->
getNumParams() != ToFunction->getNumParams()) {
3261 if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
3263 << ToFunction->getParamType(ArgPos)
3270 ToFunction->getReturnType())) {
3276 if (FromFunction->
getMethodQuals() != ToFunction->getMethodQuals()) {
3286 cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
3306 assert(llvm::size(Old) == llvm::size(New) &&
3307 "Can't compare parameters of functions with different number of "
3310 for (
auto &&[Idx,
Type] : llvm::enumerate(Old)) {
3312 size_t J =
Reversed ? (llvm::size(New) - Idx - 1) : Idx;
3332 unsigned *ArgPos,
bool Reversed) {
3333 return FunctionParamTypesAreEqual(OldType->
param_types(),
3346 unsigned OldIgnore =
3348 unsigned NewIgnore =
3351 auto *OldPT = cast<FunctionProtoType>(OldFunction->
getFunctionType());
3352 auto *NewPT = cast<FunctionProtoType>(NewFunction->
getFunctionType());
3354 return FunctionParamTypesAreEqual(OldPT->param_types().slice(OldIgnore),
3355 NewPT->param_types().slice(NewIgnore),
3368 bool IgnoreBaseAccess,
3371 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
3375 if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->
isAnyPointerType() &&
3379 DiagRuntimeBehavior(From->
getExprLoc(), From,
3380 PDiag(diag::warn_impcast_bool_to_null_pointer)
3382 else if (!isUnevaluatedContext())
3391 if (FromPointeeType->
isRecordType() && ToPointeeType->isRecordType() &&
3395 unsigned InaccessibleID = 0;
3396 unsigned AmbiguousID = 0;
3398 InaccessibleID = diag::err_upcast_to_inaccessible_base;
3399 AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
3401 if (CheckDerivedToBaseConversion(
3402 FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
3404 &BasePath, IgnoreBaseAccess))
3408 Kind = CK_DerivedToBase;
3411 if (Diagnose && !IsCStyleOrFunctionalCast &&
3412 FromPointeeType->
isFunctionType() && ToPointeeType->isVoidType()) {
3413 assert(getLangOpts().MSVCCompat &&
3414 "this should only be possible with MSVCCompat!");
3426 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
3429 Kind = CK_BlockPointerToObjCPointerCast;
3431 Kind = CK_CPointerToObjCPointerCast;
3435 Kind = CK_AnyPointerToBlockPointerCast;
3441 Kind = CK_NullToPointer;
3453 bool InOverloadResolution,
3463 ConvertedType = ToType;
3478 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass)) {
3496 bool IgnoreBaseAccess) {
3503 "Expr must be null pointer constant!");
3504 Kind = CK_NullToMemberPointer;
3509 assert(ToPtrType &&
"No member pointer cast has a target type "
3510 "that is not a member pointer.");
3516 assert(FromClass->
isRecordType() &&
"Pointer into non-class.");
3517 assert(ToClass->
isRecordType() &&
"Pointer into non-class.");
3521 bool DerivationOkay =
3522 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass, Paths);
3523 assert(DerivationOkay &&
3524 "Should not have been called if derivation isn't OK.");
3525 (void)DerivationOkay;
3528 getUnqualifiedType())) {
3529 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3531 << 0 << FromClass << ToClass << PathDisplayStr << From->
getSourceRange();
3535 if (
const RecordType *VBase = Paths.getDetectedVirtual()) {
3537 << FromClass << ToClass <<
QualType(VBase, 0)
3542 if (!IgnoreBaseAccess)
3543 CheckBaseClassAccess(From->
getExprLoc(), FromClass, ToClass,
3545 diag::err_downcast_from_inaccessible_base);
3549 Kind = CK_BaseToDerivedMemberPointer;
3572 bool CStyle,
bool IsTopLevel,
3573 bool &PreviousToQualsIncludeConst,
3574 bool &ObjCLifetimeConversion) {
3586 ObjCLifetimeConversion =
true;
3622 !PreviousToQualsIncludeConst)
3640 PreviousToQualsIncludeConst =
3641 PreviousToQualsIncludeConst && ToQuals.
hasConst();
3654 bool CStyle,
bool &ObjCLifetimeConversion) {
3657 ObjCLifetimeConversion =
false;
3667 bool PreviousToQualsIncludeConst =
true;
3668 bool UnwrappedAnyPointer =
false;
3671 FromType, ToType, CStyle, !UnwrappedAnyPointer,
3672 PreviousToQualsIncludeConst, ObjCLifetimeConversion))
3674 UnwrappedAnyPointer =
true;
3691 bool InOverloadResolution,
3700 InOverloadResolution, InnerSCS,
3717 if (CtorType->getNumParams() > 0) {
3718 QualType FirstArg = CtorType->getParamType(0);
3730 bool AllowExplicit) {
3737 bool Usable = !Info.Constructor->isInvalidDecl() &&
3740 bool SuppressUserConversions =
false;
3741 if (Info.ConstructorTmpl)
3744 CandidateSet, SuppressUserConversions,
3749 CandidateSet, SuppressUserConversions,
3750 false, AllowExplicit);
3754 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3757 switch (
auto Result =
3763 QualType ThisType = Constructor->getFunctionObjectParameterType();
3781 llvm_unreachable(
"Invalid OverloadResult!");
3803 bool AllowObjCConversionOnExplicit) {
3804 assert(AllowExplicit != AllowedExplicit::None ||
3805 !AllowObjCConversionOnExplicit);
3809 bool ConstructorsOnly =
false;
3825 ConstructorsOnly =
true;
3830 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3832 Expr **Args = &From;
3833 unsigned NumArgs = 1;
3834 bool ListInitializing =
false;
3835 if (
InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3838 S, From, ToType, ToRecordDecl, User, CandidateSet,
3848 Args = InitList->getInits();
3849 NumArgs = InitList->getNumInits();
3850 ListInitializing =
true;
3858 bool Usable = !Info.Constructor->isInvalidDecl();
3859 if (!ListInitializing)
3860 Usable = Usable && Info.Constructor->isConvertingConstructor(
3863 bool SuppressUserConversions = !ConstructorsOnly;
3871 if (SuppressUserConversions && ListInitializing) {
3872 SuppressUserConversions =
3873 NumArgs == 1 && isa<InitListExpr>(Args[0]) &&
3877 if (Info.ConstructorTmpl)
3879 Info.ConstructorTmpl, Info.FoundDecl,
3881 CandidateSet, SuppressUserConversions,
3889 SuppressUserConversions,
3898 if (ConstructorsOnly || isa<InitListExpr>(From)) {
3901 }
else if (
const RecordType *FromRecordType =
3904 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3906 const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3907 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3911 if (isa<UsingShadowDecl>(D))
3912 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3916 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3919 Conv = cast<CXXConversionDecl>(D);
3923 ConvTemplate, FoundDecl, ActingContext, From, ToType,
3924 CandidateSet, AllowObjCConversionOnExplicit,
3925 AllowExplicit != AllowedExplicit::None);
3928 CandidateSet, AllowObjCConversionOnExplicit,
3929 AllowExplicit != AllowedExplicit::None);
3934 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3937 switch (
auto Result =
3943 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3950 if (isa<InitListExpr>(From)) {
3954 if (Best->Conversions[0].isEllipsis())
3957 User.
Before = Best->Conversions[0].Standard;
3970 = dyn_cast<CXXConversionDecl>(Best->Function)) {
3977 User.
Before = Best->Conversions[0].Standard;
3992 User.
After = Best->FinalConversion;
3995 llvm_unreachable(
"Not a constructor or conversion function?");
4004 llvm_unreachable(
"Invalid OverloadResult!");
4029 diag::err_typecheck_nonviable_condition_incomplete,
4036 *
this, From, Cands);
4062 if (!Conv1 || !Conv2)
4077 if (Block1 != Block2)
4090 if (Conv1FuncRet && Conv2FuncRet &&
4101 CallOpProto->isVariadic(),
false);
4103 CallOpProto->isVariadic(),
true);
4105 CallingConv PrefOrder[] = {DefaultFree, DefaultMember, CallOpCC};
4200 if (!ICS1.
isBad()) {
4201 bool StdInit1 =
false, StdInit2 =
false;
4208 if (StdInit1 != StdInit2)
4219 CAT2->getElementType())) {
4221 if (CAT1->getSize() != CAT2->getSize())
4223 return CAT1->getSize().ult(CAT2->getSize())
4352 if (!Enum->isFixed())
4355 QualType UnderlyingType = Enum->getIntegerType();
4365 "Either both elements should be vectors or neither should.");
4367 LHS = VT->getElementType();
4370 RHS = VT->getElementType();
4406 else if (Rank2 < Rank1)
4441 bool SCS1ConvertsToVoid
4443 bool SCS2ConvertsToVoid
4445 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
4450 }
else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
4456 }
else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
4485 if (FromObjCPtr1 && FromObjCPtr2) {
4490 if (AssignLeft != AssignRight) {
4525 if (UnqualT1 == UnqualT2) {
4537 if (isa<ArrayType>(T1) && T1Quals)
4539 if (isa<ArrayType>(T2) && T2Quals)
4587 if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
4588 return SCS1IsCompatibleVectorConversion
4595 bool SCS1IsCompatibleSVEVectorConversion =
4597 bool SCS2IsCompatibleSVEVectorConversion =
4600 if (SCS1IsCompatibleSVEVectorConversion !=
4601 SCS2IsCompatibleSVEVectorConversion)
4602 return SCS1IsCompatibleSVEVectorConversion
4609 bool SCS1IsCompatibleRVVVectorConversion =
4611 bool SCS2IsCompatibleRVVVectorConversion =
4614 if (SCS1IsCompatibleRVVVectorConversion !=
4615 SCS2IsCompatibleRVVVectorConversion)
4616 return SCS1IsCompatibleRVVVectorConversion
4672 if (UnqualT1 == UnqualT2)
4690 bool ObjCLifetimeConversion;
4700 if (CanPick1 != CanPick2)
4754 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4762 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4779 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4786 bool FromAssignRight
4795 if (ToPtr1->isObjCIdType() &&
4796 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4798 if (ToPtr2->isObjCIdType() &&
4799 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4804 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4806 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4811 if (ToPtr1->isObjCClassType() &&
4812 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4814 if (ToPtr2->isObjCClassType() &&
4815 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4820 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4822 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4828 (ToAssignLeft != ToAssignRight)) {
4839 }
else if (IsSecondSame)
4848 (FromAssignLeft != FromAssignRight))
4862 const Type *FromPointeeType1 = FromMemPointer1->getClass();
4863 const Type *ToPointeeType1 = ToMemPointer1->
getClass();
4864 const Type *FromPointeeType2 = FromMemPointer2->
getClass();
4865 const Type *ToPointeeType2 = ToMemPointer2->
getClass();
4871 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4878 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4916 if (!
T.getQualifiers().hasUnaligned())
4936 "T1 must be the pointee type of the reference type");
4937 assert(!OrigT2->
isReferenceType() &&
"T2 cannot be a reference type");
4961 if (UnqualT1 == UnqualT2) {
4965 Conv |= ReferenceConversions::DerivedToBase;
4972 Conv |= ReferenceConversions::Function;
4976 bool ConvertedReferent = Conv != 0;
4980 bool PreviousToQualsIncludeConst =
true;
4981 bool TopLevel =
true;
4987 Conv |= ReferenceConversions::Qualification;
4993 Conv |= ReferenceConversions::NestedQualification;
5001 bool ObjCLifetimeConversion =
false;
5003 PreviousToQualsIncludeConst,
5004 ObjCLifetimeConversion))
5010 if (ObjCLifetimeConversion)
5011 Conv |= ReferenceConversions::ObjCLifetime;
5030 bool AllowExplicit) {
5031 assert(T2->
isRecordType() &&
"Can only find conversions of record types.");
5036 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
5037 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5040 if (isa<UsingShadowDecl>(D))
5041 D = cast<UsingShadowDecl>(D)->getTargetDecl();
5044 = dyn_cast<FunctionTemplateDecl>(D);
5049 Conv = cast<CXXConversionDecl>(D);
5061 if (!ConvTemplate &&
5085 ConvTemplate, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
5086 false, AllowExplicit);
5089 Conv, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
5090 false, AllowExplicit);
5093 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5108 if (!Best->FinalConversion.DirectBinding)
5120 "Expected a direct reference binding!");
5126 Cand != CandidateSet.
end(); ++Cand)
5138 llvm_unreachable(
"Invalid OverloadResult!");
5146 bool SuppressUserConversions,
5147 bool AllowExplicit) {
5148 assert(DeclType->
isReferenceType() &&
"Reference init needs a reference");
5175 auto SetAsReferenceBinding = [&](
bool BindsDirectly) {
5180 ICS.
Standard.
Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
5190 Sema::ReferenceConversions::NestedQualification)
5204 (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
5227 SetAsReferenceBinding(
true);
5276 SetAsReferenceBinding(S.
getLangOpts().CPlusPlus11 ||
5351 Init->Classify(S.
Context).isLValue()) {
5367 AllowedExplicit::None,
5392 if (isRValRef && LValRefType) {
5410 bool SuppressUserConversions,
5411 bool InOverloadResolution,
5412 bool AllowObjCWritebackConversion,
5413 bool AllowExplicit =
false);
5419 bool SuppressUserConversions,
5420 bool InOverloadResolution,
5421 bool AllowObjCWritebackConversion) {
5434 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
5436 InitTy = IAT->getElementType();
5462 if (From->
getNumInits() == 1 && !IsDesignatedInit) {
5468 SuppressUserConversions,
5469 InOverloadResolution,
5470 AllowObjCWritebackConversion);
5478 Result.setStandard();
5479 Result.Standard.setAsIdentityConversion();
5480 Result.Standard.setFromType(ToType);
5481 Result.Standard.setAllToTypes(ToType);
5506 bool IsUnbounded =
false;
5510 if (CT->getSize().ult(e)) {
5514 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5517 if (CT->getSize().ugt(e)) {
5523 S, &EmptyList, InitTy, SuppressUserConversions,
5524 InOverloadResolution, AllowObjCWritebackConversion);
5525 if (DfltElt.
isBad()) {
5529 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5534 assert(isa<IncompleteArrayType>(AT) &&
"Expected incomplete array");
5540 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5549 Result.setStandard();
5550 Result.Standard.setAsIdentityConversion();
5551 Result.Standard.setFromType(InitTy);
5552 Result.Standard.setAllToTypes(InitTy);
5553 for (
unsigned i = 0; i < e; ++i) {
5556 S, Init, InitTy, SuppressUserConversions, InOverloadResolution,
5557 AllowObjCWritebackConversion);
5567 if (Result.isBad()) {
5568 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5578 S, From->
getEndLoc(), DfltElt, Result) ==
5582 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5596 AllowedExplicit::None,
5597 InOverloadResolution,
false,
5598 AllowObjCWritebackConversion,
5616 Result.setUserDefined();
5617 Result.UserDefined.Before.setAsIdentityConversion();
5619 Result.UserDefined.Before.setFromType(
QualType());
5620 Result.UserDefined.Before.setAllToTypes(
QualType());
5622 Result.UserDefined.After.setAsIdentityConversion();
5623 Result.UserDefined.After.setFromType(ToType);
5624 Result.UserDefined.After.setAllToTypes(ToType);
5625 Result.UserDefined.ConversionFunction =
nullptr;
5642 if (From->
getNumInits() == 1 && !IsDesignatedInit) {
5653 Init, ToType,
false, Found))
5663 SuppressUserConversions,
5671 InOverloadResolution,
5672 AllowObjCWritebackConversion);
5673 if (Result.isFailure())
5675 assert(!Result.isEllipsis() &&
5676 "Sub-initialization cannot result in ellipsis conversion.");
5682 Result.UserDefined.After;
5703 if (NumInits == 1 && !isa<InitListExpr>(From->
getInit(0)))
5705 SuppressUserConversions,
5706 InOverloadResolution,
5707 AllowObjCWritebackConversion);
5710 else if (NumInits == 0) {
5711 Result.setStandard();
5712 Result.Standard.setAsIdentityConversion();
5713 Result.Standard.setFromType(ToType);
5714 Result.Standard.setAllToTypes(ToType);
5733 bool SuppressUserConversions,
5734 bool InOverloadResolution,
5735 bool AllowObjCWritebackConversion,
5736 bool AllowExplicit) {
5737 if (
InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
5739 InOverloadResolution,AllowObjCWritebackConversion);
5744 SuppressUserConversions, AllowExplicit);
5747 SuppressUserConversions,
5748 AllowedExplicit::None,
5749 InOverloadResolution,
5751 AllowObjCWritebackConversion,
5764 return !ICS.
isBad();
5773 const CXXRecordDecl *ActingContext,
bool InOverloadResolution =
false,
5775 bool SuppressUserConversion =
false) {
5783 assert(FromClassification.
isLValue());
5795 if (ExplicitParameterType.isNull())
5798 ValueKindFromClassification(FromClassification));
5800 S, &TmpExpr, ExplicitParameterType, SuppressUserConversion,
5818 if (isa<CXXDestructorDecl>(Method) || Method->
isStatic()) {
5855 FromType, ImplicitParamType);
5864 FromType, ImplicitParamType);
5879 FromType, ImplicitParamType);
5899 if (!FromClassification.
isRValue()) {
5939 FromRecordType = From->
getType();
5940 DestType = ImplicitParamRecordType;
5964 << Method->
getDeclName() << FromRecordType << (CVR - 1)
5975 bool IsRValueQualified =
5979 << IsRValueQualified;
5991 llvm_unreachable(
"Lists are not objects");
5994 return Diag(From->
getBeginLoc(), diag::err_member_function_call_bad_type)
5995 << ImplicitParamRecordType << FromRecordType
6004 From = FromRes.
get();
6013 CK = CK_AddressSpaceConversion;
6038 AllowedExplicit::Conversions,
6119 llvm_unreachable(
"found a first conversion kind in Second");
6123 llvm_unreachable(
"found a third conversion kind in Second");
6129 llvm_unreachable(
"unknown conversion kind");
6141 "converted constant expression outside C++11");
6174 diag::err_typecheck_converted_constant_expression)
6180 llvm_unreachable(
"bad conversion in converted constant expression");
6186 diag::err_typecheck_converted_constant_expression_disallowed)
6192 diag::err_typecheck_converted_constant_expression_indirect)
6202 diag::err_reference_bind_to_bitfield_in_cce)
6212 "unexpected class type converted constant expr");
6215 T, cast<NonTypeTemplateParmDecl>(Dest)),
6220 if (Result.isInvalid())
6227 CCE == Sema::CCEKind::CCEK_TemplateArg);
6228 if (Result.isInvalid())
6232 bool ReturnPreNarrowingValue =
false;
6235 PreNarrowingType)) {
6248 PreNarrowingValue.
isInt()) {
6251 ReturnPreNarrowingValue =
true;
6263 << CCE << 0 << From->
getType() <<
T;
6266 if (!ReturnPreNarrowingValue)
6267 PreNarrowingValue = {};
6284 if (Result.isInvalid() || Result.get()->isValueDependent()) {
6289 RequireInt, PreNarrowingValue);
6315 if (!R.isInvalid() && !R.get()->isValueDependent())
6326 const APValue &PreNarrowingValue) {
6343 (RequireInt && !Eval.
Val.
isInt())) {
6350 if (Notes.empty()) {
6352 Expr *E = Result.get();
6353 if (
const auto *CE = dyn_cast<ConstantExpr>(E)) {
6357 "ConstantExpr has no value associated with it");
6363 Value = std::move(PreNarrowingValue);
6369 if (Notes.size() == 1 &&
6370 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
6371 Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
6372 }
else if (!Notes.empty() && Notes[0].second.getDiagID() ==
6373 diag::note_constexpr_invalid_template_arg) {
6374 Notes[0].second.setDiagID(diag::err_constexpr_invalid_template_arg);
6375 for (
unsigned I = 0; I < Notes.size(); ++I)
6376 Diag(Notes[I].first, Notes[I].second);
6380 for (
unsigned I = 0; I < Notes.size(); ++I)
6381 Diag(Notes[I].first, Notes[I].second);
6408 AllowedExplicit::Conversions,
6451 assert((isa<UnresolvedMemberExpr, MemberExpr>(MemExprE)) &&
6452 "expected a member expression");
6454 if (
const auto M = dyn_cast<UnresolvedMemberExpr>(MemExprE);
6455 M && !M->isImplicitAccess())
6456 Base = M->getBase();
6457 else if (
const auto M = dyn_cast<MemberExpr>(MemExprE);
6458 M && !M->isImplicitAccess())
6459 Base = M->getBase();
6498 "Method is not an explicit member function");
6499 assert(NewArgs.empty() &&
"NewArgs should be empty");
6501 NewArgs.reserve(Args.size() + 1);
6503 NewArgs.push_back(
This);
6504 NewArgs.append(Args.begin(), Args.end());
6507 Method, Object->getBeginLoc());
6526 for (
unsigned I = 0, N = ViableConversions.
size(); I != N; ++I) {
6528 cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
6540 if (ExplicitConversions.
size() == 1 && !Converter.
Suppress) {
6548 std::string TypeStr;
6553 "static_cast<" + TypeStr +
">(")
6565 HadMultipleCandidates);
6566 if (Result.isInvalid())
6572 From, Result.get()->getType());
6573 if (Result.isInvalid())
6575 From = Result.get();
6598 HadMultipleCandidates);
6599 if (Result.isInvalid())
6603 CK_UserDefinedConversion, Result.get(),
6604 nullptr, Result.get()->getValueKind(),
6623 for (
unsigned I = 0, N = ViableConversions.
size(); I != N; ++I) {
6627 if (isa<UsingShadowDecl>(D))
6628 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6632 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
6635 Conv = cast<CXXConversionDecl>(D);
6639 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
6643 ToType, CandidateSet,
6678 From = result.
get();
6705 : Converter(Converter), From(From) {}
6710 } IncompleteDiagnoser(Converter, From);
6720 const auto &Conversions =
6721 cast<CXXRecordDecl>(RecordTy->
getDecl())->getVisibleConversionFunctions();
6723 bool HadMultipleCandidates =
6724 (
std::distance(Conversions.begin(), Conversions.end()) > 1);
6728 bool HasUniqueTargetType =
true;
6731 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
6741 Conversion = cast<CXXConversionDecl>(D);
6744 "Conversion operator templates are considered potentially "
6748 if (Converter.
match(CurToType) || ConvTemplate) {
6754 ExplicitConversions.
addDecl(I.getDecl(), I.getAccess());
6759 else if (HasUniqueTargetType &&
6761 HasUniqueTargetType =
false;
6763 ViableConversions.
addDecl(I.getDecl(), I.getAccess());
6781 HadMultipleCandidates,
6782 ExplicitConversions))
6788 if (!HasUniqueTargetType)
6807 HadMultipleCandidates, Found))
6816 HadMultipleCandidates,
6817 ExplicitConversions))
6825 switch (ViableConversions.
size()) {
6828 HadMultipleCandidates,
6829 ExplicitConversions))
6839 HadMultipleCandidates, Found))
6870 if (Proto->getNumParams() < 1)
6874 QualType ArgType = Proto->getParamType(0).getNonReferenceType();
6879 if (Proto->getNumParams() < 2)
6883 QualType ArgType = Proto->getParamType(1).getNonReferenceType();
6903 unsigned SeenAt = 0;
6905 bool HasDefault =
false;
6914 return HasDefault || SeenAt != 0;
6928 bool PartialOverloading,
bool AllowExplicit,
bool AllowExplicitConversions,
6933 assert(Proto &&
"Functions without a prototype cannot be overloaded");
6934 assert(!
Function->getDescribedFunctionTemplate() &&
6935 "Use AddTemplateOverloadCandidate for function templates");
6938 if (!isa<CXXConstructorDecl>(Method)) {
6948 CandidateSet, SuppressUserConversions,
6949 PartialOverloading, EarlyConversions, PO);
6963 if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
6964 Constructor->isMoveConstructor())
6984 CandidateSet.
addCandidate(Args.size(), EarlyConversions);
6999 Candidate.
Viable =
false;
7012 if (
auto *SpecInfo =
Function->getTemplateSpecializationInfo())
7013 ND = SpecInfo->getTemplate();
7016 Candidate.
Viable =
false;
7023 Candidate.
Viable =
false;
7033 if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
7037 Candidate.
Viable =
false;
7049 auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
7050 if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
7051 Constructor->getParamDecl(0)->getType()->isReferenceType()) {
7052 QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
7058 Candidate.
Viable =
false;
7067 Constructor->getMethodQualifiers().getAddressSpace(),
7069 Candidate.
Viable =
false;
7082 Candidate.
Viable =
false;
7092 unsigned MinRequiredArgs =
Function->getMinRequiredArguments();
7093 if (!AggregateCandidateDeduction && Args.size() < MinRequiredArgs &&
7094 !PartialOverloading) {
7096 Candidate.
Viable =
false;
7110 Candidate.
Viable =
false;
7116 if (
Function->getTrailingRequiresClause()) {
7121 Candidate.
Viable =
false;
7129 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7132 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7135 }
else if (ArgIdx < NumParams) {
7142 *
this, Args[ArgIdx], ParamType, SuppressUserConversions,
7145 getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
7147 Candidate.
Viable =
false;
7159 if (EnableIfAttr *FailedAttr =
7161 Candidate.
Viable =
false;
7171 if (Methods.size() <= 1)
7174 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7182 if (Args.size() < NumNamedArgs)
7185 for (
unsigned i = 0; i < NumNamedArgs; i++) {
7187 if (Args[i]->isTypeDependent()) {
7193 Expr *argExpr = Args[i];
7194 assert(argExpr &&
"SelectBestMethod(): missing expression");
7199 !param->
hasAttr<CFConsumedAttr>())
7217 if (ConversionState.
isBad() ||
7227 for (
unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
7228 if (Args[i]->isTypeDependent()) {
7241 if (Args.size() != NumNamedArgs)
7243 else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
7246 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7247 QualType ReturnT = Methods[
b]->getReturnType();
7266 assert(!isa<CXXConstructorDecl>(Method) &&
7267 "Shouldn't have `this` for ctors!");
7268 assert(!Method->
isStatic() &&
"Shouldn't have `this` for static methods!");
7270 ThisArg,
nullptr, Method, Method);
7273 ConvertedThis = R.
get();
7275 if (
auto *MD = dyn_cast<CXXMethodDecl>(
Function)) {
7277 assert((MissingImplicitThis || MD->isStatic() ||
7278 isa<CXXConstructorDecl>(MD)) &&
7279 "Expected `this` for non-ctor instance methods");
7281 ConvertedThis =
nullptr;
7289 for (
unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
7298 ConvertedArgs.push_back(R.
get());
7306 for (
unsigned i = Args.size(), e =
Function->getNumParams(); i != e; ++i) {
7308 if (!
P->hasDefaultArg())
7313 ConvertedArgs.push_back(R.
get());
7325 bool MissingImplicitThis) {
7326 auto EnableIfAttrs =
Function->specific_attrs<EnableIfAttr>();
7327 if (EnableIfAttrs.begin() == EnableIfAttrs.end())
7333 Expr *DiscardedThis;
7335 *
this,
Function,
nullptr, CallLoc, Args, Trap,
7336 true, DiscardedThis, ConvertedArgs))
7337 return *EnableIfAttrs.begin();
7339 for (
auto *EIA : EnableIfAttrs) {
7343 if (EIA->getCond()->isValueDependent() ||
7344 !EIA->getCond()->EvaluateWithSubstitution(
7348 if (!Result.isInt() || !Result.getInt().getBoolValue())
7354 template <
typename CheckFn>
7357 CheckFn &&IsSuccessful) {
7360 if (ArgDependent == DIA->getArgDependent())
7361 Attrs.push_back(DIA);
7368 auto WarningBegin = std::stable_partition(
7369 Attrs.begin(), Attrs.end(),
7370 [](
const DiagnoseIfAttr *DIA) { return DIA->isError(); });
7374 auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
7376 if (ErrAttr != WarningBegin) {
7377 const DiagnoseIfAttr *DIA = *ErrAttr;
7378 S.
Diag(
Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
7379 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7380 << DIA->getParent() << DIA->getCond()->getSourceRange();
7384 for (
const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
7385 if (IsSuccessful(DIA)) {
7386 S.
Diag(
Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
7387 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7388 << DIA->getParent() << DIA->getCond()->getSourceRange();
7395 const Expr *ThisArg,
7400 [&](
const DiagnoseIfAttr *DIA) {
7405 if (!DIA->getCond()->EvaluateWithSubstitution(
7406 Result,
Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
7408 return Result.isInt() && Result.getInt().getBoolValue();
7415 *
this, ND,
false,
Loc,
7416 [&](
const DiagnoseIfAttr *DIA) {
7429 bool SuppressUserConversions,
7430 bool PartialOverloading,
7431 bool FirstArgumentIsBase) {
7440 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
7443 if (Args.size() > 0) {
7444 if (
Expr *E = Args[0]) {
7454 FunctionArgs = Args.slice(1);
7458 FunTmpl, F.getPair(),
7460 ExplicitTemplateArgs, ObjectType, ObjectClassification,
7461 FunctionArgs, CandidateSet, SuppressUserConversions,
7462 PartialOverloading);
7465 cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
7466 ObjectClassification, FunctionArgs, CandidateSet,
7467 SuppressUserConversions, PartialOverloading);
7474 if (Args.size() > 0 &&
7475 (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
7476 !isa<CXXConstructorDecl>(FD)))) {
7477 assert(cast<CXXMethodDecl>(FD)->isStatic());
7478 FunctionArgs = Args.slice(1);
7482 ExplicitTemplateArgs, FunctionArgs,
7483 CandidateSet, SuppressUserConversions,
7484 PartialOverloading);
7487 SuppressUserConversions, PartialOverloading);
7499 bool SuppressUserConversions,
7504 if (isa<UsingShadowDecl>(
Decl))
7505 Decl = cast<UsingShadowDecl>(
Decl)->getTargetDecl();
7508 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
7509 "Expected a member function template");
7511 nullptr, ObjectType,
7512 ObjectClassification, Args, CandidateSet,
7513 SuppressUserConversions,
false, PO);
7516 ObjectType, ObjectClassification, Args, CandidateSet,
7517 SuppressUserConversions,
false, std::nullopt, PO);
7534 bool SuppressUserConversions,
7535 bool PartialOverloading,
7540 assert(Proto &&
"Methods without a prototype cannot be overloaded");
7541 assert(!isa<CXXConstructorDecl>(Method) &&
7542 "Use AddOverloadCandidate for constructors");
7560 CandidateSet.
addCandidate(Args.size() + 1, EarlyConversions);
7578 Candidate.
Viable =
false;
7589 if (Args.size() < MinRequiredArgs && !PartialOverloading) {
7591 Candidate.
Viable =
false;
7611 Candidate.
Conversions[FirstConvIdx].setStaticObjectArgument();
7616 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7617 Method, ActingContext,
true);
7618 if (Candidate.
Conversions[FirstConvIdx].isBad()) {
7619 Candidate.
Viable =
false;
7629 Candidate.
Viable =
false;
7639 Candidate.
Viable =
false;
7647 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7650 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7653 }
else if (ArgIdx < NumParams) {
7661 SuppressUserConversions,
7666 Candidate.
Viable =
false;
7678 if (EnableIfAttr *FailedAttr =
7680 Candidate.
Viable =
false;
7687 Candidate.
Viable =
false;
7719 PartialOverloading,
false, ObjectType,
7720 ObjectClassification,
7723 MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
7724 SuppressUserConversions, ActingContext, ObjectType,
7725 ObjectClassification, PO);
7729 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7732 Candidate.
Viable =
false;
7737 cast<CXXMethodDecl>(Candidate.
Function)->isStatic() ||
7752 assert(
Specialization &&
"Missing member function template specialization?");
7754 "Specialization is not a member function?");
7756 ActingContext, ObjectType, ObjectClassification, Args,
7757 CandidateSet, SuppressUserConversions, PartialOverloading,
7774 bool PartialOverloading,
bool AllowExplicit,
ADLCallKind IsADLCandidate,
7786 Candidate.
Viable =
false;
7805 FunctionTemplate, ExplicitTemplateArgs, Args,
Specialization, Info,
7806 PartialOverloading, AggregateCandidateDeduction,
7811 FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions,
7812 SuppressUserConversions,
nullptr,
QualType(), {}, PO);
7816 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7819 Candidate.
Viable =
false;
7827 isa<CXXMethodDecl>(Candidate.
Function) &&
7828 !isa<CXXConstructorDecl>(Candidate.
Function);
7842 assert(
Specialization &&
"Missing function template specialization?");
7844 Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
7845 PartialOverloading, AllowExplicit,
7846 false, IsADLCandidate, Conversions, PO,
7862 const bool AllowExplicit =
false;
7865 auto *Method = dyn_cast<CXXMethodDecl>(FD);
7866 bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
7867 unsigned ThisConversions = HasThisConversion ? 1 : 0;
7879 if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
7882 if (!FD->hasCXXExplicitFunctionObjectParameter() ||
7883 !ParamTypes[0]->isDependentType()) {
7885 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7886 Method, ActingContext,
true,
7887 FD->hasCXXExplicitFunctionObjectParameter() ? ParamTypes[0]
7889 if (Conversions[ConvIdx].isBad())
7897 for (
unsigned I = 0, N =
std::min(ParamTypes.size() -
Offset, Args.size());
7903 ConvIdx = Args.size() - 1 - I;
7904 assert(Args.size() + ThisConversions == 2 &&
7905 "number of args (including 'this') must be exactly 2 for "
7909 assert(!HasThisConversion || (ConvIdx == 0 && I == 0));
7912 ConvIdx = ThisConversions + I;
7914 Conversions[ConvIdx]
7916 SuppressUserConversions,
7921 if (Conversions[ConvIdx].isBad())
7943 bool AllowObjCPointerConversion) {
7951 bool ObjCLifetimeConversion;
7953 ObjCLifetimeConversion))
7958 if (!AllowObjCPointerConversion)
7962 bool IncompatibleObjC =
false;
7978 bool AllowExplicit,
bool AllowResultConversion) {
7980 "Conversion function templates use AddTemplateConversionCandidate");
7995 if (!AllowResultConversion &&
8007 AllowObjCConversionOnExplicit))
8029 if (!AllowExplicit && Conversion->
isExplicit()) {
8030 Candidate.
Viable =
false;
8045 const auto *ConversionContext =
8059 Candidate.
Viable =
false;
8068 Candidate.
Viable =
false;
8080 if (FromCanon == ToCanon ||
8082 Candidate.
Viable =
false;
8099 CK_FunctionToPointerDecay, &ConversionRef,
8104 Candidate.
Viable =
false;
8118 Buffer, &ConversionFn, CallResultType, VK, From->
getBeginLoc());
8136 Candidate.
Viable =
false;
8148 Candidate.
Viable =
false;
8155 Candidate.
Viable =
false;
8161 "Can only end up with a standard conversion sequence or failure");
8164 if (EnableIfAttr *FailedAttr =
8166 Candidate.
Viable =
false;
8173 Candidate.
Viable =
false;
8187 bool AllowExplicit,
bool AllowResultConversion) {
8189 "Only conversion function templates permitted here");
8201 Candidate.
Viable =
false;
8212 FunctionTemplate, ObjectType, ObjectClassification, ToType,
8218 Candidate.
Viable =
false;
8230 assert(
Specialization &&
"Missing function template specialization?");
8232 CandidateSet, AllowObjCConversionOnExplicit,
8233 AllowExplicit, AllowResultConversion);
8274 *
this, CandidateSet.
getLocation(), Object->getType(),
8275 Object->Classify(
Context), Conversion, ActingContext);
8278 if (ObjectInit.
isBad()) {
8279 Candidate.
Viable =
false;
8290 Candidate.
Conversions[0].UserDefined.EllipsisConversion =
false;
8291 Candidate.
Conversions[0].UserDefined.HadMultipleCandidates =
false;
8292 Candidate.
Conversions[0].UserDefined.ConversionFunction = Conversion;
8293 Candidate.
Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
8296 Candidate.
Conversions[0].UserDefined.After.setAsIdentityConversion();
8304 if (Args.size() > NumParams && !Proto->
isVariadic()) {
8305 Candidate.
Viable =
false;
8312 if (Args.size() < NumParams) {
8314 Candidate.
Viable =
false;
8321 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8322 if (ArgIdx < NumParams) {
8335 Candidate.
Viable =
false;
8352 Candidate.
Viable =
false;
8358 if (EnableIfAttr *FailedAttr =
8360 Candidate.
Viable =
false;
8385 assert(!isa<CXXMethodDecl>(FD) &&
8386 "unqualified operator lookup found a member function");
8390 FunctionArgs, CandidateSet);
8393 FunTmpl, F.getPair(), ExplicitTemplateArgs,
8394 {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
false,
false,
8397 if (ExplicitTemplateArgs)
8402 FD, F.getPair(), {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
8443 if (!T1Rec->getDecl()->getDefinition())
8451 OperEnd = Operators.
end();
8452 Oper != OperEnd; ++Oper) {
8453 if (Oper->getAsFunction() &&
8456 *
this, {Args[1], Args[0]}, Oper->getAsFunction()))
8459 Args[0]->Classify(
Context), Args.slice(1),
8460 CandidateSet,
false, PO);
8475 bool IsAssignmentOperator,
8476 unsigned NumContextualBoolArguments) {
8493 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8506 if (ArgIdx < NumContextualBoolArguments) {
8508 "Contextual conversion to bool requires bool type");
8514 ArgIdx == 0 && IsAssignmentOperator,
8520 Candidate.
Viable =
false;
8533 class BuiltinCandidateTypeSet {
8539 TypeSet PointerTypes;
8543 TypeSet MemberPointerTypes;
8547 TypeSet EnumerationTypes;
8551 TypeSet VectorTypes;
8555 TypeSet MatrixTypes;
8558 TypeSet BitIntTypes;
8561 bool HasNonRecordTypes;
8565 bool HasArithmeticOrEnumeralTypes;
8569 bool HasNullPtrType;
8578 bool AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8580 bool AddMemberPointerWithMoreQualifiedTypeVariants(
QualType Ty);
8584 typedef TypeSet::iterator iterator;
8587 : HasNonRecordTypes(
false),
8588 HasArithmeticOrEnumeralTypes(
false),
8589 HasNullPtrType(
false),
8593 void AddTypesConvertedFrom(
QualType Ty,
8595 bool AllowUserConversions,
8596 bool AllowExplicitConversions,
8597 const Qualifiers &VisibleTypeConversionsQuals);
8599 llvm::iterator_range<iterator> pointer_types() {
return PointerTypes; }
8600 llvm::iterator_range<iterator> member_pointer_types() {
8601 return MemberPointerTypes;
8603 llvm::iterator_range<iterator> enumeration_types() {
8604 return EnumerationTypes;
8606 llvm::iterator_range<iterator> vector_types() {
return VectorTypes; }
8607 llvm::iterator_range<iterator> matrix_types() {
return MatrixTypes; }
8608 llvm::iterator_range<iterator> bitint_types() {
return BitIntTypes; }
8610 bool containsMatrixType(
QualType Ty)
const {
return MatrixTypes.count(Ty); }
8611 bool hasNonRecordTypes() {
return HasNonRecordTypes; }
8612 bool hasArithmeticOrEnumeralTypes() {
return HasArithmeticOrEnumeralTypes; }
8613 bool hasNullPtrType()
const {
return HasNullPtrType; }
8628 BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8632 if (!PointerTypes.insert(Ty))
8637 bool buildObjCPtr =
false;
8641 buildObjCPtr =
true;
8653 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
8659 if ((CVR | BaseCVR) != CVR)
continue;
8681 PointerTypes.insert(QPointerTy);
8697 BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
8700 if (!MemberPointerTypes.insert(Ty))
8704 assert(PointerTy &&
"type was not a member pointer type!");
8719 if ((CVR | BaseCVR) != CVR)
continue;
8722 MemberPointerTypes.insert(
8738 BuiltinCandidateTypeSet::AddTypesConvertedFrom(
QualType Ty,
8740 bool AllowUserConversions,
8741 bool AllowExplicitConversions,
8760 HasNonRecordTypes = HasNonRecordTypes || !TyRec;
8763 HasArithmeticOrEnumeralTypes =
8767 PointerTypes.insert(Ty);
8771 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
8775 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
8778 HasArithmeticOrEnumeralTypes =
true;
8779 EnumerationTypes.insert(Ty);
8781 HasArithmeticOrEnumeralTypes =
true;
8782 BitIntTypes.insert(Ty);
8786 HasArithmeticOrEnumeralTypes =
true;
8787 VectorTypes.insert(Ty);
8791 HasArithmeticOrEnumeralTypes =
true;
8792 MatrixTypes.insert(Ty);
8794 HasNullPtrType =
true;
8795 }
else if (AllowUserConversions && TyRec) {
8802 if (isa<UsingShadowDecl>(D))
8803 D = cast<UsingShadowDecl>(D)->getTargetDecl();
8807 if (isa<FunctionTemplateDecl>(D))
8811 if (AllowExplicitConversions || !Conv->
isExplicit()) {
8874 if (isa<UsingShadowDecl>(D))
8875 D = cast<UsingShadowDecl>(D)->getTargetDecl();
8909 if (Available.hasAtomic()) {
8910 Available.removeAtomic();
8917 if (Available.hasVolatile()) {
8918 Available.removeVolatile();
8952 class BuiltinOperatorOverloadBuilder {
8957 bool HasArithmeticOrEnumeralCandidateType;
8961 static constexpr
int ArithmeticTypesCap = 26;
8967 unsigned FirstIntegralType,
8969 unsigned FirstPromotedIntegralType,
8970 LastPromotedIntegralType;
8971 unsigned FirstPromotedArithmeticType,
8972 LastPromotedArithmeticType;
8973 unsigned NumArithmeticTypes;
8975 void InitArithmeticTypes() {
8977 FirstPromotedArithmeticType = 0;
8987 FirstIntegralType = ArithmeticTypes.size();
8988 FirstPromotedIntegralType = ArithmeticTypes.size();
9011 llvm::for_each(CandidateTypes, [&BitIntCandidates](
9012 BuiltinCandidateTypeSet &Candidate) {
9013 for (
QualType BitTy : Candidate.bitint_types())
9016 llvm::move(BitIntCandidates, std::back_inserter(ArithmeticTypes));
9017 LastPromotedIntegralType = ArithmeticTypes.size();
9018 LastPromotedArithmeticType = ArithmeticTypes.size();
9032 LastIntegralType = ArithmeticTypes.size();
9033 NumArithmeticTypes = ArithmeticTypes.size();
9040 assert(ArithmeticTypes.size() - BitIntCandidates.size() <=
9041 ArithmeticTypesCap &&
9042 "Enough inline storage for all arithmetic types.");
9047 void addPlusPlusMinusMinusStyleOverloads(
QualType CandidateTy,
9096 BuiltinOperatorOverloadBuilder(
9099 bool HasArithmeticOrEnumeralCandidateType,
9103 VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
9104 HasArithmeticOrEnumeralCandidateType(
9105 HasArithmeticOrEnumeralCandidateType),
9106 CandidateTypes(CandidateTypes),
9107 CandidateSet(CandidateSet) {
9109 InitArithmeticTypes();
9132 if (!HasArithmeticOrEnumeralCandidateType)
9135 for (
unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
9136 const auto TypeOfT = ArithmeticTypes[Arith];
9138 if (Op == OO_MinusMinus)
9140 if (Op == OO_PlusPlus && S.
getLangOpts().CPlusPlus17)
9143 addPlusPlusMinusMinusStyleOverloads(
9160 void addPlusPlusMinusMinusPointerOverloads() {
9161 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9163 if (!PtrTy->getPointeeType()->isObjectType())
9166 addPlusPlusMinusMinusStyleOverloads(
9168 (!PtrTy.isVolatileQualified() &&
9170 (!PtrTy.isRestrictQualified() &&
9185 void addUnaryStarPointerOverloads() {
9186 for (
QualType ParamTy : CandidateTypes[0].pointer_types()) {
9192 if (Proto->getMethodQuals() || Proto->getRefQualifier())
9205 void addUnaryPlusOrMinusArithmeticOverloads() {
9206 if (!HasArithmeticOrEnumeralCandidateType)
9209 for (
unsigned Arith = FirstPromotedArithmeticType;
9210 Arith < LastPromotedArithmeticType; ++Arith) {
9211 QualType ArithTy = ArithmeticTypes[Arith];
9216 for (
QualType VecTy : CandidateTypes[0].vector_types())
9225 void addUnaryPlusPointerOverloads() {
9226 for (
QualType ParamTy : CandidateTypes[0].pointer_types())
9235 void addUnaryTildePromotedIntegralOverloads() {
9236 if (!HasArithmeticOrEnumeralCandidateType)
9239 for (
unsigned Int = FirstPromotedIntegralType;
9240 Int < LastPromotedIntegralType; ++
Int) {
9246 for (
QualType VecTy : CandidateTypes[0].vector_types())
9256 void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
9260 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9261 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9266 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9270 if (CandidateTypes[ArgIdx].hasNullPtrType()) {
9272 if (AddedTypes.insert(NullPtrTy).second) {
9273 QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
9292 void addGenericBinaryPointerOrEnumeralOverloads(
bool IsSpaceship) {
9306 UserDefinedBinaryOperators;
9308 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9309 if (!CandidateTypes[ArgIdx].enumeration_types().empty()) {
9311 CEnd = CandidateSet.
end();
9313 if (!
C->Viable || !
C->Function ||
C->Function->getNumParams() != 2)
9316 if (
C->Function->isFunctionTemplateSpecialization())
9323 QualType FirstParamType =
C->Function->getParamDecl(Reversed ? 1 : 0)
9325 .getUnqualifiedType();
9326 QualType SecondParamType =
C->Function->getParamDecl(Reversed ? 0 : 1)
9328 .getUnqualifiedType();
9336 UserDefinedBinaryOperators.insert(
9346 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9347 for (
QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9351 if (IsSpaceship && PtrTy->isFunctionPointerType())
9354 QualType ParamTypes[2] = {PtrTy, PtrTy};
9357 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9362 if (!AddedTypes.insert(CanonType).second ||
9363 UserDefinedBinaryOperators.count(std::make_pair(CanonType,
9366 QualType ParamTypes[2] = {EnumTy, EnumTy};
9393 for (
int Arg = 0; Arg < 2; ++Arg) {
9394 QualType AsymmetricParamTypes[2] = {
9398 for (
QualType PtrTy : CandidateTypes[Arg].pointer_types()) {
9403 AsymmetricParamTypes[Arg] = PtrTy;
9404 if (Arg == 0 || Op == OO_Plus) {
9409 if (Op == OO_Minus) {
9414 QualType ParamTypes[2] = {PtrTy, PtrTy};
9450 void addGenericBinaryArithmeticOverloads() {
9451 if (!HasArithmeticOrEnumeralCandidateType)
9454 for (
unsigned Left = FirstPromotedArithmeticType;
9455 Left < LastPromotedArithmeticType; ++Left) {
9456 for (
unsigned Right = FirstPromotedArithmeticType;
9457 Right < LastPromotedArithmeticType; ++Right) {
9458 QualType LandR[2] = { ArithmeticTypes[Left],
9459 ArithmeticTypes[Right] };
9466 for (
QualType Vec1Ty : CandidateTypes[0].vector_types())
9467 for (
QualType Vec2Ty : CandidateTypes[1].vector_types()) {
9468 QualType LandR[2] = {Vec1Ty, Vec2Ty};
9478 void addMatrixBinaryArithmeticOverloads() {
9479 if (!HasArithmeticOrEnumeralCandidateType)
9482 for (
QualType M1 : CandidateTypes[0].matrix_types()) {
9483 AddCandidate(M1, cast<MatrixType>(M1)->getElementType());
9484 AddCandidate(M1, M1);
9487 for (
QualType M2 : CandidateTypes[1].matrix_types()) {
9488 AddCandidate(cast<MatrixType>(M2)->getElementType(), M2);
9489 if (!CandidateTypes[0].containsMatrixType(M2))
9490 AddCandidate(M2, M2);
9525 void addThreeWayArithmeticOverloads() {
9526 addGenericBinaryArithmeticOverloads();
9543 void addBinaryBitwiseArithmeticOverloads() {
9544 if (!HasArithmeticOrEnumeralCandidateType)
9547 for (
unsigned Left = FirstPromotedIntegralType;
9548 Left < LastPromotedIntegralType; ++Left) {
9549 for (
unsigned Right = FirstPromotedIntegralType;
9550 Right < LastPromotedIntegralType; ++Right) {
9551 QualType LandR[2] = { ArithmeticTypes[Left],
9552 ArithmeticTypes[Right] };
9565 void addAssignmentMemberPointerOrEnumeralOverloads() {
9569 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9570 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9577 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9602 void addAssignmentPointerOverloads(
bool isEqualOp) {
9606 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9610 else if (!PtrTy->getPointeeType()->isObjectType())
9621 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9631 if (!PtrTy.isRestrictQualified() &&
9651 for (
QualType PtrTy : CandidateTypes[1].pointer_types()) {
9665 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9675 if (!PtrTy.isRestrictQualified() &&
9708 void addAssignmentArithmeticOverloads(
bool isEqualOp) {
9709 if (!HasArithmeticOrEnumeralCandidateType)
9712 for (
unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
9713 for (
unsigned Right = FirstPromotedArithmeticType;
9714 Right < LastPromotedArithmeticType; ++Right) {
9716 ParamTypes[1] = ArithmeticTypes[Right];
9718 S, ArithmeticTypes[Left], Args[0]);
9731 for (
QualType Vec1Ty : CandidateTypes[0].vector_types())
9732 for (
QualType Vec2Ty : CandidateTypes[0].vector_types()) {
9734 ParamTypes[1] = Vec2Ty;
9762 void addAssignmentIntegralOverloads() {
9763 if (!HasArithmeticOrEnumeralCandidateType)
9766 for (
unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
9767 for (
unsigned Right = FirstPromotedIntegralType;
9768 Right < LastPromotedIntegralType; ++Right) {
9770 ParamTypes[1] = ArithmeticTypes[Right];
9772 S, ArithmeticTypes[Left], Args[0]);
9791 void addExclaimOverload() {
9797 void addAmpAmpOrPipePipeOverload() {
9814 void addSubscriptOverloads() {
9815 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9825 for (
QualType PtrTy : CandidateTypes[1].pointer_types()) {
9845 void addArrowStarOverloads() {
9846 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9851 if (!isa<RecordType>(C1))
9860 for (
QualType MemPtrTy : CandidateTypes[1].member_pointer_types()) {
9866 QualType ParamTypes[2] = {PtrTy, MemPtrTy};
9870 T.isVolatileQualified())
9873 T.isRestrictQualified())
9891 void addConditionalOperatorOverloads() {
9895 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9896 for (
QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9900 QualType ParamTypes[2] = {PtrTy, PtrTy};
9904 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9908 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9913 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9920 QualType ParamTypes[2] = {EnumTy, EnumTy};
9944 VisibleTypeConversionsQuals.
addConst();
9945 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9947 if (Args[ArgIdx]->getType()->isAtomicType())
9948 VisibleTypeConversionsQuals.
addAtomic();
9951 bool HasNonRecordCandidateType =
false;
9952 bool HasArithmeticOrEnumeralCandidateType =
false;
9954 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9955 CandidateTypes.emplace_back(*
this);
9956 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
9959 (Op == OO_Exclaim ||
9962 VisibleTypeConversionsQuals);
9963 HasNonRecordCandidateType = HasNonRecordCandidateType ||
9964 CandidateTypes[ArgIdx].hasNonRecordTypes();
9965 HasArithmeticOrEnumeralCandidateType =
9966 HasArithmeticOrEnumeralCandidateType ||
9967 CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
9975 if (!HasNonRecordCandidateType &&
9976 !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
9980 BuiltinOperatorOverloadBuilder OpBuilder(*
this, Args,
9981 VisibleTypeConversionsQuals,
9982 HasArithmeticOrEnumeralCandidateType,
9983 CandidateTypes, CandidateSet);
9989 llvm_unreachable(
"Expected an overloaded operator");
9994 case OO_Array_Delete:
9997 "Special operators don't use AddBuiltinOperatorCandidates");
10009 if (Args.size() == 1)
10010 OpBuilder.addUnaryPlusPointerOverloads();
10014 if (Args.size() == 1) {
10015 OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
10017 OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
10018 OpBuilder.addGenericBinaryArithmeticOverloads();
10019 OpBuilder.addMatrixBinaryArithmeticOverloads();
10024 if (Args.size() == 1)
10025 OpBuilder.addUnaryStarPointerOverloads();
10027 OpBuilder.addGenericBinaryArithmeticOverloads();
10028 OpBuilder.addMatrixBinaryArithmeticOverloads();
10033 OpBuilder.addGenericBinaryArithmeticOverloads();
10037 case OO_MinusMinus:
10038 OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
10039 OpBuilder.addPlusPlusMinusMinusPointerOverloads();
10042 case OO_EqualEqual:
10043 case OO_ExclaimEqual:
10044 OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
10045 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10046 OpBuilder.addGenericBinaryArithmeticOverloads();
10052 case OO_GreaterEqual:
10053 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10054 OpBuilder.addGenericBinaryArithmeticOverloads();
10058 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
true);
10059 OpBuilder.addThreeWayArithmeticOverloads();
10066 case OO_GreaterGreater:
10067 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10071 if (Args.size() == 1)
10077 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10081 OpBuilder.addUnaryTildePromotedIntegralOverloads();
10085 OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
10089 case OO_MinusEqual:
10090 OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
10094 case OO_SlashEqual:
10095 OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
10098 case OO_PercentEqual:
10099 case OO_LessLessEqual:
10100 case OO_GreaterGreaterEqual:
10102 case OO_CaretEqual:
10104 OpBuilder.addAssignmentIntegralOverloads();
10108 OpBuilder.addExclaimOverload();
10113 OpBuilder.addAmpAmpOrPipePipeOverload();
10117 if (Args.size() == 2)
10118 OpBuilder.addSubscriptOverloads();
10122 OpBuilder.addArrowStarOverloads();
10125 case OO_Conditional:
10126 OpBuilder.addConditionalOperatorOverloads();
10127 OpBuilder.addGenericBinaryArithmeticOverloads();
10145 bool PartialOverloading) {
10160 CandEnd = CandidateSet.
end();
10161 Cand != CandEnd; ++Cand)
10162 if (Cand->Function) {
10163 Fns.
erase(Cand->Function);
10165 Fns.
erase(FunTmpl);
10174 if (ExplicitTemplateArgs)
10178 FD, FoundDecl, Args, CandidateSet,
false,
10179 PartialOverloading,
true,
10183 FD, FoundDecl, {Args[1], Args[0]}, CandidateSet,
10184 false, PartialOverloading,
10190 auto *FTD = cast<FunctionTemplateDecl>(*I);
10192 FTD, FoundDecl, ExplicitTemplateArgs, Args, CandidateSet,
10193 false, PartialOverloading,
10196 *
this, Args, FTD->getTemplatedDecl())) {
10198 FTD, FoundDecl, ExplicitTemplateArgs, {Args[1], Args[0]},
10199 CandidateSet,
false, PartialOverloading,
10208 enum class Comparison {
Equal, Better, Worse };
10225 bool Cand1Attr = Cand1->
hasAttr<EnableIfAttr>();
10226 bool Cand2Attr = Cand2->
hasAttr<EnableIfAttr>();
10227 if (!Cand1Attr || !Cand2Attr) {
10228 if (Cand1Attr == Cand2Attr)
10229 return Comparison::Equal;
10230 return Cand1Attr ? Comparison::Better : Comparison::Worse;
10236 llvm::FoldingSetNodeID Cand1ID, Cand2ID;
10237 for (
auto Pair : zip_longest(Cand1Attrs, Cand2Attrs)) {
10238 std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
10239 std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
10244 return Comparison::Worse;
10246 return Comparison::Better;
10251 (*Cand1A)->getCond()->Profile(Cand1ID, S.
getASTContext(),
true);
10252 (*Cand2A)->getCond()->Profile(Cand2ID, S.
getASTContext(),
true);
10253 if (Cand1ID != Cand2ID)
10254 return Comparison::Worse;
10257 return Comparison::Equal;
10265 return Comparison::Equal;
10271 return Comparison::Equal;
10272 return Comparison::Worse;
10275 return Comparison::Better;
10281 const auto *Cand1CPUSpec = Cand1.
Function->
getAttr<CPUSpecificAttr>();
10282 const auto *Cand2CPUSpec = Cand2.
Function->
getAttr<CPUSpecificAttr>();
10284 if (!Cand1CPUDisp && !Cand2CPUDisp && !Cand1CPUSpec && !Cand2CPUSpec)
10285 return Comparison::Equal;
10287 if (Cand1CPUDisp && !Cand2CPUDisp)
10288 return Comparison::Better;
10289 if (Cand2CPUDisp && !Cand1CPUDisp)
10290 return Comparison::Worse;
10292 if (Cand1CPUSpec && Cand2CPUSpec) {
10293 if (Cand1CPUSpec->cpus_size() != Cand2CPUSpec->cpus_size())
10294 return Cand1CPUSpec->cpus_size() < Cand2CPUSpec->cpus_size()
10295 ? Comparison::Better
10296 : Comparison::Worse;
10298 std::pair<CPUSpecificAttr::cpus_iterator, CPUSpecificAttr::cpus_iterator>
10299 FirstDiff = std::mismatch(
10300 Cand1CPUSpec->cpus_begin(), Cand1CPUSpec->cpus_end(),
10301 Cand2CPUSpec->cpus_begin(),
10303 return LHS->getName() == RHS->getName();
10306 assert(FirstDiff.first != Cand1CPUSpec->cpus_end() &&
10307 "Two different cpu-specific versions should not have the same "
10308 "identifier list, otherwise they'd be the same decl!");
10309 return (*FirstDiff.first)->getName() < (*FirstDiff.second)->
getName()
10310 ? Comparison::Better
10311 : Comparison::Worse;
10313 llvm_unreachable(
"No way to get here unless both had cpu_dispatch");
10319 static std::optional<QualType>
10321 if (!isa<CXXMethodDecl>(F) || isa<CXXConstructorDecl>(F))
10322 return std::nullopt;
10324 auto *M = cast<CXXMethodDecl>(F);
10328 return M->getFunctionObjectParameterReferenceType();
10342 PT2->getInstantiatedFromMemberTemplate()))
10353 assert(I < F->getNumParams());
10357 unsigned F1NumParams = F1->
getNumParams() + isa<CXXMethodDecl>(F1);
10358 unsigned F2NumParams = F2->
getNumParams() + isa<CXXMethodDecl>(F2);
10360 if (F1NumParams != F2NumParams)
10363 unsigned I1 = 0, I2 = 0;
10364 for (
unsigned I = 0; I != F1NumParams; ++I) {
10365 QualType T1 = NextParam(F1, I1, I == 0);
10366 QualType T2 = NextParam(F2, I2, I == 0);
10367 assert(!T1.
isNull() && !T2.
isNull() &&
"Unexpected null param types");
10395 auto *Mem1 = dyn_cast<CXXMethodDecl>(Fn1);
10396 auto *Mem2 = dyn_cast<CXXMethodDecl>(Fn2);
10397 if (Mem1 && Mem2) {
10400 if (Mem1->getParent() != Mem2->getParent())
10404 if (Mem1->isInstance() && Mem2->isInstance() &&
10406 Mem1->getFunctionObjectParameterReferenceType(),
10407 Mem1->getFunctionObjectParameterReferenceType()))
10463 bool IsCand1ImplicitHD =
10465 bool IsCand2ImplicitHD =
10480 auto EmitThreshold =
10481 (S.
getLangOpts().CUDAIsDevice && IsCallerImplicitHD &&
10482 (IsCand1ImplicitHD || IsCand2ImplicitHD))
10485 auto Cand1Emittable = P1 > EmitThreshold;
10486 auto Cand2Emittable = P2 > EmitThreshold;
10487 if (Cand1Emittable && !Cand2Emittable)
10489 if (!Cand1Emittable && Cand2Emittable)
10500 unsigned StartArg = 0;
10507 return ICS.isStandard() &&
10519 assert(Cand2.
Conversions.size() == NumArgs &&
"Overload candidate mismatch");
10520 bool HasBetterConversion =
false;
10521 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10522 bool Cand1Bad = IsIllFormedConversion(Cand1.
Conversions[ArgIdx]);
10523 bool Cand2Bad = IsIllFormedConversion(Cand2.
Conversions[ArgIdx]);
10524 if (Cand1Bad != Cand2Bad) {
10527 HasBetterConversion =
true;
10531 if (HasBetterConversion)
10538 bool HasWorseConversion =
false;
10539 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10545 HasBetterConversion =
true;
10564 HasWorseConversion =
true;
10579 if (HasBetterConversion && !HasWorseConversion)
10590 isa<CXXConversionDecl>(Cand1.
Function) &&
10591 isa<CXXConversionDecl>(Cand2.
Function)) {
10619 isa<CXXConstructorDecl>(Cand1.
Function) !=
10620 isa<CXXConstructorDecl>(Cand2.
Function))
10621 return isa<CXXConstructorDecl>(Cand1.
Function);
10625 bool Cand1IsSpecialization = Cand1.
Function &&
10627 bool Cand2IsSpecialization = Cand2.
Function &&
10629 if (Cand1IsSpecialization != Cand2IsSpecialization)
10630 return Cand2IsSpecialization;
10636 if (Cand1IsSpecialization && Cand2IsSpecialization) {
10637 const auto *Obj1Context =
10639 const auto *Obj2Context =
10647 Obj1Context ?
QualType(Obj1Context->getTypeForDecl(), 0)
10649 Obj2Context ?
QualType(Obj2Context->getTypeForDecl(), 0)
10658 if (!Cand1IsSpecialization && !Cand2IsSpecialization &&
10668 bool Cand1IsInherited =
10670 bool Cand2IsInherited =
10672 if (Cand1IsInherited != Cand2IsInherited)
10673 return Cand2IsInherited;
10674 else if (Cand1IsInherited) {
10675 assert(Cand2IsInherited);
10678 if (Cand1Class->isDerivedFrom(Cand2Class))
10680 if (Cand2Class->isDerivedFrom(Cand1Class))
10697 auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.
Function);
10698 auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.
Function);
10699 if (Guide1 && Guide2) {
10701 if (Guide1->isImplicit() != Guide2->isImplicit())
10702 return Guide2->isImplicit();
10712 const auto *Constructor1 = Guide1->getCorrespondingConstructor();
10713 const auto *Constructor2 = Guide2->getCorrespondingConstructor();
10714 if (Constructor1 && Constructor2) {
10715 bool isC1Templated = Constructor1->getTemplatedKind() !=
10716 FunctionDecl::TemplatedKind::TK_NonTemplate;
10717 bool isC2Templated = Constructor2->getTemplatedKind() !=
10718 FunctionDecl::TemplatedKind::TK_NonTemplate;
10719 if (isC1Templated != isC2Templated)
10720 return isC2Templated;
10728 if (Cmp != Comparison::Equal)
10729 return Cmp == Comparison::Better;
10732 bool HasPS1 = Cand1.
Function !=
nullptr &&
10734 bool HasPS2 = Cand2.
Function !=
nullptr &&
10736 if (HasPS1 != HasPS2 && HasPS1)
10740 if (MV == Comparison::Better)
10742 if (MV == Comparison::Worse)
10757 const auto *CD1 = dyn_cast_or_null<CXXConstructorDecl>(Cand1.
Function);
10758 const auto *CD2 = dyn_cast_or_null<CXXConstructorDecl>(Cand2.
Function);
10760 LangAS AS1 = CD1->getMethodQualifiers().getAddressSpace();
10761 LangAS AS2 = CD2->getMethodQualifiers().getAddressSpace();
10782 auto *VA = dyn_cast_or_null<ValueDecl>(A);
10783 auto *VB = dyn_cast_or_null<ValueDecl>(B);
10789 if (!VA->getDeclContext()->getRedeclContext()->Equals(
10790 VB->getDeclContext()->getRedeclContext()) ||
10792 VA->isExternallyVisible() || VB->isExternallyVisible())
10805 if (
auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
10806 if (
auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
10809 auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
10810 auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
10811 if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
10813 EnumB->getIntegerType()))
10816 return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
10826 assert(D &&
"Unknown declaration");
10827 Diag(
Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
10833 for (
auto *E : Equiv) {
10835 Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
10844 static_cast<CNSInfo *
>(DeductionFailure.Data)
10845 ->Satisfaction.ContainsErrors;
10862 std::transform(begin(), end(), std::back_inserter(Candidates),
10878 bool ContainsSameSideCandidate =
10882 S.
CUDA().IdentifyPreference(Caller, Cand->
Function) ==
10885 if (ContainsSameSideCandidate) {
10892 llvm::erase_if(Candidates, IsWrongSideCandidate);
10898 for (
auto *Cand : Candidates) {
10899 Cand->
Best =
false;
10901 if (Best == end() ||
10921 PendingBest.push_back(&*Best);
10926 while (!PendingBest.empty()) {
10927 auto *Curr = PendingBest.pop_back_val();
10928 for (
auto *Cand : Candidates) {
10931 PendingBest.push_back(Cand);
10936 EquivalentCands.push_back(Cand->
Function);
10948 if (Best->Function && Best->Function->isDeleted())
10951 if (!EquivalentCands.empty())
10960 enum OverloadCandidateKind {
10963 oc_reversed_binary_operator,
10965 oc_implicit_default_constructor,
10966 oc_implicit_copy_constructor,
10967 oc_implicit_move_constructor,
10968 oc_implicit_copy_assignment,
10969 oc_implicit_move_assignment,
10970 oc_implicit_equality_comparison,
10971 oc_inherited_constructor
10974 enum OverloadCandidateSelect {
10977 ocs_described_template,
10980 static std::pair<OverloadCandidateKind, OverloadCandidateSelect>
10984 std::string &Description) {
10993 OverloadCandidateSelect Select = [&]() {
10994 if (!Description.empty())
10995 return ocs_described_template;
10996 return isTemplate ? ocs_template : ocs_non_template;
10999 OverloadCandidateKind
Kind = [&]() {
11001 return oc_implicit_equality_comparison;
11004 return oc_reversed_binary_operator;
11006 if (
const auto *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
11007 if (!Ctor->isImplicit()) {
11008 if (isa<ConstructorUsingShadowDecl>(Found))
11009 return oc_inherited_constructor;
11011 return oc_constructor;
11014 if (Ctor->isDefaultConstructor())
11015 return oc_implicit_default_constructor;
11017 if (Ctor->isMoveConstructor())
11018 return oc_implicit_move_constructor;
11020 assert(Ctor->isCopyConstructor() &&
11021 "unexpected sort of implicit constructor");
11022 return oc_implicit_copy_constructor;
11025 if (
const auto *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
11028 if (!Meth->isImplicit())
11031 if (Meth->isMoveAssignmentOperator())
11032 return oc_implicit_move_assignment;
11034 if (Meth->isCopyAssignmentOperator())
11035 return oc_implicit_copy_assignment;
11037 assert(isa<CXXConversionDecl>(Meth) &&
"expected conversion");
11041 return oc_function;
11044 return std::make_pair(
Kind, Select);
11047 void MaybeEmitInheritedConstructorNote(
Sema &S,
const Decl *FoundDecl) {
11050 if (
const auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
11052 diag::note_ovl_candidate_inherited_constructor)
11053 << Shadow->getNominatedBaseClass();
11062 if (EnableIf->getCond()->isValueDependent() ||
11063 !EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
11080 bool InOverloadResolution,
11084 if (!FD->
hasAttr<SYCLDeviceIndirectlyCallableAttr>()) {
11086 diag::err_sycl_taking_address_of_wrong_function,
11093 if (InOverloadResolution)
11095 diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
11097 S.
Diag(
Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
11108 if (InOverloadResolution) {
11111 TemplateArgString +=
" ";
11113 FunTmpl->getTemplateParameters(),
11118 diag::note_ovl_candidate_unsatisfied_constraints)
11119 << TemplateArgString;
11121 S.
Diag(
Loc, diag::err_addrof_function_constraints_not_satisfied)
11130 return P->hasAttr<PassObjectSizeAttr>();
11138 if (InOverloadResolution)
11140 diag::note_ovl_candidate_has_pass_object_size_params)
11143 S.
Diag(
Loc, diag::err_address_of_function_with_pass_object_size_params)
11167 const auto *ConvD = dyn_cast<CXXConversionDecl>(Fn);
11171 const auto *RD = cast<CXXRecordDecl>(Fn->
getParent());
11172 if (!RD->isLambda())
11182 return ConvToCC != CallOpCC;
11188 QualType DestType,
bool TakingAddress) {
11192 !Fn->
getAttr<TargetAttr>()->isDefaultVersion())
11195 !Fn->
getAttr<TargetVersionAttr>()->isDefaultVersion())
11200 std::string FnDesc;
11201 std::pair<OverloadCandidateKind, OverloadCandidateSelect> KSPair =
11202 ClassifyOverloadCandidate(*
this, Found, Fn, RewriteKind, FnDesc);
11204 << (
unsigned)KSPair.first << (
unsigned)KSPair.second
11209 MaybeEmitInheritedConstructorNote(*
this, Found);
11227 FunctionDecl *FirstCand =
nullptr, *SecondCand =
nullptr;
11228 for (
auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
11232 if (
auto *Template = I->Function->getPrimaryTemplate())
11233 Template->getAssociatedConstraints(AC);
11235 I->Function->getAssociatedConstraints(AC);
11238 if (FirstCand ==
nullptr) {
11239 FirstCand = I->Function;
11241 }
else if (SecondCand ==
nullptr) {
11242 SecondCand = I->Function;
11255 SecondCand, SecondAC))
11264 bool TakingAddress) {
11274 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
11278 = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
11292 << Ambiguous.getFromType() << Ambiguous.getToType();
11293 unsigned CandsShown = 0;
11295 for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
11307 unsigned I,
bool TakingCandidateAddress) {
11309 assert(Conv.
isBad());
11310 assert(Cand->
Function &&
"for now, candidate must be a function");
11316 bool isObjectArgument =
false;
11317 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
11319 isObjectArgument =
true;
11324 std::string FnDesc;
11325 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11336 bool HasParamPack =
11338 return Parm->isParameterPack();
11340 if (!isObjectArgument && !HasParamPack)
11344 assert(FromExpr &&
"overload set argument came from implicit argument?");
11346 if (isa<UnaryOperator>(E))
11347 E = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
11351 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11352 << ToParamRange << ToTy << Name << I + 1;
11353 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11362 CToTy = RT->getPointeeType();
11367 CFromTy = FromPT->getPointeeType();
11368 CToTy = ToPT->getPointeeType();
11378 if (isObjectArgument)
11379 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_addrspace_this)
11380 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11384 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11387 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11393 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11396 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11402 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11405 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11410 assert(CVR &&
"expected qualifiers mismatch");
11412 if (isObjectArgument) {
11414 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11415 << FromTy << (CVR - 1);
11418 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11419 << ToParamRange << FromTy << (CVR - 1) << I + 1;
11421 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11427 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_value_category)
11428 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11429 << (
unsigned)isObjectArgument << I + 1
11432 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11438 if (FromExpr && isa<InitListExpr>(FromExpr)) {
11439 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_list_argument)
11440 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11441 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11446 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11458 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
11459 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11460 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11461 << (
unsigned)(Cand->
Fix.
Kind);
11463 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11468 unsigned BaseToDerivedConversion = 0;
11471 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11472 FromPtrTy->getPointeeType()) &&
11473 !FromPtrTy->getPointeeType()->isIncompleteType() &&
11474 !ToPtrTy->getPointeeType()->isIncompleteType() &&
11476 FromPtrTy->getPointeeType()))
11477 BaseToDerivedConversion = 1;
11485 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11486 FromPtrTy->getPointeeType()) &&
11487 FromIface->isSuperClassOf(ToIface))
11488 BaseToDerivedConversion = 2;
11490 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
11492 !ToRefTy->getPointeeType()->isIncompleteType() &&
11494 BaseToDerivedConversion = 3;
11498 if (BaseToDerivedConversion) {
11499 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv)
11500 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11501 << ToParamRange << (BaseToDerivedConversion - 1) << FromTy << ToTy
11503 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11507 if (isa<ObjCObjectPointerType>(CFromTy) &&
11508 isa<PointerType>(CToTy)) {
11513 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11514 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument
11516 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11521 if (TakingCandidateAddress &&
11527 FDiag << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11528 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11529 << (
unsigned)(Cand->
Fix.
Kind);
11540 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11547 unsigned NumArgs) {
11560 if (NumArgs < MinParams) {
11577 unsigned NumFormalArgs) {
11578 assert(isa<FunctionDecl>(D) &&
11579 "The templated declaration should at least be a function"
11580 " when diagnosing bad template argument deduction due to too many"
11581 " or too few arguments");
11591 unsigned ParamCount = FnTy->getNumParams() - (HasExplicitObjectParam ? 1 : 0);
11592 unsigned mode, modeCount;
11593 if (NumFormalArgs < MinParams) {
11594 if (MinParams != ParamCount || FnTy->isVariadic() ||
11595 FnTy->isTemplateVariadic())
11599 modeCount = MinParams;
11601 if (MinParams != ParamCount)
11605 modeCount = ParamCount;
11608 std::string Description;
11609 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11610 ClassifyOverloadCandidate(S, Found, Fn,
CRK_None, Description);
11612 if (modeCount == 1 &&
11615 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11616 << Description << mode
11617 << Fn->
getParamDecl(HasExplicitObjectParam ? 1 : 0) << NumFormalArgs
11621 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11622 << Description << mode << modeCount << NumFormalArgs
11625 MaybeEmitInheritedConstructorNote(S, Found);
11630 unsigned NumFormalArgs) {
11638 llvm_unreachable(
"Unsupported: Getting the described template declaration"
11639 " for bad deduction diagnosis");
11646 bool TakingCandidateAddress) {
11652 switch (DeductionFailure.
getResult()) {
11655 "TemplateDeductionResult::Success while diagnosing bad deduction");
11657 llvm_unreachable(
"TemplateDeductionResult::NonDependentConversionFailure "
11658 "while diagnosing bad deduction");
11664 assert(ParamD &&
"no parameter found for incomplete deduction result");
11666 diag::note_ovl_candidate_incomplete_deduction)
11668 MaybeEmitInheritedConstructorNote(S, Found);
11673 assert(ParamD &&
"no parameter found for incomplete deduction result");
11675 diag::note_ovl_candidate_incomplete_deduction_pack)
11679 MaybeEmitInheritedConstructorNote(S, Found);
11684 assert(ParamD &&
"no parameter found for bad qualifiers deduction result");
11702 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_underqualified)
11703 << ParamD->
getDeclName() << Arg << NonCanonParam;
11704 MaybeEmitInheritedConstructorNote(S, Found);
11709 assert(ParamD &&
"no parameter found for inconsistent deduction result");
11711 if (isa<TemplateTypeParmDecl>(ParamD))
11713 else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
11723 diag::note_ovl_candidate_inconsistent_deduction_types)
11726 MaybeEmitInheritedConstructorNote(S, Found);
11746 diag::note_ovl_candidate_inconsistent_deduction)
11749 MaybeEmitInheritedConstructorNote(S, Found);
11754 assert(ParamD &&
"no parameter found for invalid explicit arguments");
11757 diag::note_ovl_candidate_explicit_arg_mismatch_named)
11762 index = TTP->getIndex();
11764 = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
11765 index = NTTP->getIndex();
11767 index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
11769 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
11772 MaybeEmitInheritedConstructorNote(S, Found);
11779 TemplateArgString =
" ";
11782 if (TemplateArgString.size() == 1)
11783 TemplateArgString.clear();
11785 diag::note_ovl_candidate_unsatisfied_constraints)
11786 << TemplateArgString;
11789 static_cast<CNSInfo*
>(DeductionFailure.
Data)->Satisfaction);
11799 diag::note_ovl_candidate_instantiation_depth);
11800 MaybeEmitInheritedConstructorNote(S, Found);
11808 TemplateArgString =
" ";
11811 if (TemplateArgString.size() == 1)
11812 TemplateArgString.clear();
11818 diag::err_typename_nested_not_found_enable_if) {
11821 S.
Diag(
PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
11822 <<
"'enable_if'" << TemplateArgString;
11828 diag::err_typename_nested_not_found_requirement) {
11830 diag::note_ovl_candidate_disabled_by_requirement)
11841 SFINAEArgString =
": ";
11847 diag::note_ovl_candidate_substitution_failure)
11848 << TemplateArgString << SFINAEArgString << R;
11849 MaybeEmitInheritedConstructorNote(S, Found);
11859 TemplateArgString =
" ";
11862 if (TemplateArgString.size() == 1)
11863 TemplateArgString.clear();
11866 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_deduced_mismatch)
11869 << TemplateArgString
11894 diag::note_ovl_candidate_non_deduced_mismatch_qualified)
11901 if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
11910 diag::note_ovl_candidate_non_deduced_mismatch)
11911 << FirstTA << SecondTA;
11917 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_bad_deduction);
11918 MaybeEmitInheritedConstructorNote(S, Found);
11922 diag::note_cuda_ovl_candidate_target_mismatch);
11930 bool TakingCandidateAddress) {
11949 std::string FnDesc;
11950 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11951 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Callee,
11954 S.
Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
11955 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
11957 << llvm::to_underlying(CalleeTarget) << llvm::to_underlying(CallerTarget);
11962 if (Meth !=
nullptr && Meth->
isImplicit()) {
11966 switch (FnKindPair.first) {
11969 case oc_implicit_default_constructor:
11972 case oc_implicit_copy_constructor:
11975 case oc_implicit_move_constructor:
11978 case oc_implicit_copy_assignment:
11981 case oc_implicit_move_assignment:
11986 bool ConstRHS =
false;
11990 ConstRHS = RT->getPointeeType().isConstQualified();
12004 S.
Diag(Callee->getLocation(),
12005 diag::note_ovl_candidate_disabled_by_function_cond_attr)
12006 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
12011 assert(ES.
isExplicit() &&
"not an explicit candidate");
12015 case Decl::Kind::CXXConstructor:
12018 case Decl::Kind::CXXConversion:
12021 case Decl::Kind::CXXDeductionGuide:
12025 llvm_unreachable(
"invalid Decl");
12034 First = Pattern->getFirstDecl();
12037 diag::note_ovl_candidate_explicit)
12059 bool TakingCandidateAddress,
12075 std::string FnDesc;
12076 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12077 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12081 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
12083 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12099 TakingCandidateAddress);
12102 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_illegal_constructor)
12104 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12112 diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch)
12113 << QualsForPrinting;
12114 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12125 for (
unsigned N = Cand->
Conversions.size(); I != N; ++I)
12146 if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
12149 diag::note_ovl_candidate_inherited_constructor_slice)
12152 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12158 assert(!Available);
12166 std::string FnDesc;
12167 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12168 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12172 diag::note_ovl_candidate_constraints_not_satisfied)
12173 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
12191 bool isLValueReference =
false;
12192 bool isRValueReference =
false;
12193 bool isPointer =
false;
12197 isLValueReference =
true;
12201 isRValueReference =
true;
12217 diag::note_ovl_surrogate_constraints_not_satisfied)
12231 assert(Cand->
Conversions.size() <= 2 &&
"builtin operator is not binary");
12232 std::string TypeStr(
"operator");
12238 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12243 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12250 if (ICS.
isBad())
break;
12254 S, OpLoc, S.
PDiag(diag::note_ambiguous_type_conversion));
12271 llvm_unreachable(
"non-deduction failure while diagnosing bad deduction");
12301 llvm_unreachable(
"Unhandled deduction result");
12306 struct CompareOverloadCandidatesForDisplay {
12312 CompareOverloadCandidatesForDisplay(
12315 : S(S), NumArgs(NArgs), CSK(CSK) {}
12325 if (NumArgs >
C->Function->getNumParams() && !
C->Function->isVariadic())
12327 if (NumArgs < C->
Function->getMinRequiredArguments())
12337 if (L == R)
return false;
12341 if (!R->
Viable)
return true;
12343 if (
int Ord = CompareConversions(*L, *R))
12363 if (LDist == RDist) {
12364 if (LFailureKind == RFailureKind)
12372 return LDist < RDist;
12390 numLFixes = (numLFixes == 0) ?
UINT_MAX : numLFixes;
12391 numRFixes = (numRFixes == 0) ?
UINT_MAX : numRFixes;
12392 if (numLFixes != numRFixes) {
12393 return numLFixes < numRFixes;
12397 if (
int Ord = CompareConversions(*L, *R))
12409 if (LRank != RRank)
12410 return LRank < RRank;
12436 struct ConversionSignals {
12437 unsigned KindRank = 0;
12441 ConversionSignals Sig;
12442 Sig.KindRank =
Seq.getKindRank();
12443 if (
Seq.isStandard())
12444 Sig.Rank =
Seq.Standard.getRank();
12445 else if (
Seq.isUserDefined())
12446 Sig.Rank =
Seq.UserDefined.After.getRank();
12452 static ConversionSignals ForObjectArgument() {
12468 for (
unsigned I = 0, N = L.
Conversions.size(); I != N; ++I) {
12470 ? ConversionSignals::ForObjectArgument()
12471 : ConversionSignals::ForSequence(L.Conversions[I]);
12473 ? ConversionSignals::ForObjectArgument()
12474 : ConversionSignals::ForSequence(R.Conversions[I]);
12475 if (std::tie(LS.KindRank, LS.Rank) != std::tie(RS.KindRank, RS.Rank))
12476 return std::tie(LS.KindRank, LS.Rank) < std::tie(RS.KindRank, RS.Rank)
12501 bool Unfixable =
false;
12509 assert(ConvIdx != ConvCount &&
"no bad conversion in candidate");
12510 if (Cand->
Conversions[ConvIdx].isInitialized() &&
12519 bool SuppressUserConversions =
false;
12521 unsigned ConvIdx = 0;
12522 unsigned ArgIdx = 0;
12537 if (isa<CXXMethodDecl>(Cand->
Function) &&
12550 assert(ConvCount <= 3);
12556 ConvIdx != ConvCount;
12558 assert(ArgIdx < Args.size() &&
"no argument for this arg conversion");
12559 if (Cand->
Conversions[ConvIdx].isInitialized()) {
12561 }
else if (
ParamIdx < ParamTypes.size()) {
12562 if (ParamTypes[
ParamIdx]->isDependentType())
12563 Cand->
Conversions[ConvIdx].setAsIdentityConversion(
12564 Args[ArgIdx]->getType());
12568 SuppressUserConversions,
12573 if (!Unfixable && Cand->
Conversions[ConvIdx].isBad())
12589 for (
iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
12594 if (!Cand->Viable) {
12595 if (!Cand->Function && !Cand->IsSurrogate) {
12615 Cands.push_back(Cand);
12619 Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(),
Kind));
12626 bool DeferHint =
false;
12630 auto WrongSidedCands =
12632 return (Cand.Viable ==
false &&
12635 Cand.Function->template hasAttr<CUDAHostAttr>() &&
12636 Cand.Function->template hasAttr<CUDADeviceAttr>());
12638 DeferHint = !WrongSidedCands.empty();
12650 auto Cands = CompleteCandidates(S, OCD, Args, OpLoc,
Filter);
12652 S.
Diag(PD.first, PD.second, shouldDeferDiags(S, Args, OpLoc));
12656 bool NoteCands =
true;
12657 for (
const Expr *Arg : Args) {
12658 if (Arg->getType()->isWebAssemblyTableType())
12663 NoteCandidates(S, Args, Cands, Opc, OpLoc);
12672 bool ReportedAmbiguousConversions =
false;
12675 unsigned CandsShown = 0;
12676 auto I = Cands.begin(), E = Cands.end();
12677 for (; I != E; ++I) {
12693 "Non-viable built-in candidates are not added to Cands.");
12700 if (!ReportedAmbiguousConversions) {
12702 ReportedAmbiguousConversions =
true;
12715 S.
Diag(OpLoc, diag::note_ovl_too_many_candidates,
12716 shouldDeferDiags(S, Args, OpLoc))
12727 struct CompareTemplateSpecCandidatesForDisplay {
12729 CompareTemplateSpecCandidatesForDisplay(
Sema &S) : S(S) {}
12763 bool ForTakingAddress) {
12765 DeductionFailure, 0, ForTakingAddress);
12768 void TemplateSpecCandidateSet::destroyCandidates() {
12769 for (iterator i = begin(), e = end(); i != e; ++i) {
12770 i->DeductionFailure.Destroy();
12775 destroyCandidates();
12776 Candidates.clear();
12789 Cands.reserve(size());
12790 for (
iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
12791 if (Cand->Specialization)
12792 Cands.push_back(Cand);
12797 llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S));
12804 unsigned CandsShown = 0;
12805 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
12811 if (CandsShown >= 4 && ShowOverloads ==
Ovl_Best)
12816 "Non-matching built-in candidates are not added to Cands.");
12821 S.
Diag(
Loc, diag::note_ovl_too_many_candidates) <<
int(E - I);
12834 Ret = ToTypePtr->getPointeeType();
12837 Ret = ToTypeRef->getPointeeType();
12840 Ret = MemTypePtr->getPointeeType();
12847 bool Complain =
true) {
12864 class AddressOfFunctionResolver {
12874 bool TargetTypeIsNonStaticMemberFunction;
12875 bool FoundNonTemplateFunction;
12876 bool StaticMemberFunctionFromBoundPointer;
12877 bool HasComplained;
12886 AddressOfFunctionResolver(
Sema &S,
Expr *SourceExpr,
12887 const QualType &TargetType,
bool Complain)
12888 : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
12890 TargetTypeIsNonStaticMemberFunction(
12892 FoundNonTemplateFunction(
false),
12893 StaticMemberFunctionFromBoundPointer(
false),
12894 HasComplained(
false),
12897 FailedCandidates(OvlExpr->getNameLoc(),
true) {
12898 ExtractUnqualifiedFunctionTypeFromTargetType();
12902 if (!UME->isImplicitAccess() &&
12904 StaticMemberFunctionFromBoundPointer =
true;
12908 OvlExpr,
false, &dap)) {
12914 TargetTypeIsNonStaticMemberFunction =
true;
12922 Matches.push_back(std::make_pair(dap, Fn));
12930 if (FindAllFunctionsThatMatchTargetTypeExactly()) {
12933 if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
12934 if (FoundNonTemplateFunction)
12935 EliminateAllTemplateMatches();
12937 EliminateAllExceptMostSpecializedTemplate();
12942 EliminateSuboptimalCudaMatches();
12945 bool hasComplained()
const {
return HasComplained; }
12948 bool candidateHasExactlyCorrectType(
const FunctionDecl *FD) {
12960 return candidateHasExactlyCorrectType(A) &&
12961 (!candidateHasExactlyCorrectType(B) ||
12967 bool eliminiateSuboptimalOverloadCandidates() {
12970 auto Best = Matches.begin();
12971 for (
auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
12972 if (isBetterCandidate(I->second, Best->second))
12976 auto IsBestOrInferiorToBest = [
this, BestFn](
12977 const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
12978 return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
12983 if (!llvm::all_of(Matches, IsBestOrInferiorToBest))
12985 Matches[0] = *Best;
12990 bool isTargetTypeAFunction()
const {
12999 void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
13010 bool CanConvertToFunctionPointer =
13012 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13015 else if (TargetTypeIsNonStaticMemberFunction)
13027 FunctionTemplate, &OvlExplicitTemplateArgs, TargetFunctionType,
13028 Specialization, Info,
true);
13047 Matches.push_back(std::make_pair(CurAccessFunPair, Specialization));
13051 bool AddMatchingNonTemplateFunction(
NamedDecl* Fn,
13056 bool CanConvertToFunctionPointer =
13058 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13061 else if (TargetTypeIsNonStaticMemberFunction)
13064 if (
FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
13071 if (FunDecl->isMultiVersion()) {
13072 const auto *TA = FunDecl->
getAttr<TargetAttr>();
13073 if (TA && !TA->isDefaultVersion())
13075 const auto *TVA = FunDecl->getAttr<TargetVersionAttr>();
13076 if (TVA && !TVA->isDefaultVersion())
13084 HasComplained |= Complain;
13093 candidateHasExactlyCorrectType(FunDecl)) {
13094 Matches.push_back(std::make_pair(
13095 CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
13096 FoundNonTemplateFunction =
true;
13104 bool FindAllFunctionsThatMatchTargetTypeExactly() {
13109 if (IsInvalidFormOfPointerToMemberFunction())
13125 = dyn_cast<FunctionTemplateDecl>(Fn)) {
13126 if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
13131 AddMatchingNonTemplateFunction(Fn, I.getPair()))
13134 assert(
Ret || Matches.empty());
13138 void EliminateAllExceptMostSpecializedTemplate() {
13151 for (
unsigned I = 0, E = Matches.size(); I != E; ++I)
13152 MatchesCopy.
addDecl(Matches[I].second, Matches[I].first.getAccess());
13157 MatchesCopy.
begin(), MatchesCopy.
end(), FailedCandidates,
13159 S.
PDiag(diag::err_addr_ovl_ambiguous)
13160 << Matches[0].second->getDeclName(),
13161 S.
PDiag(diag::note_ovl_candidate)
13162 << (
unsigned)oc_function << (
unsigned)ocs_described_template,
13163 Complain, TargetFunctionType);
13165 if (Result != MatchesCopy.
end()) {
13167 Matches[0].first = Matches[Result - MatchesCopy.
begin()].first;
13168 Matches[0].second = cast<FunctionDecl>(*Result);
13171 HasComplained |= Complain;
13174 void EliminateAllTemplateMatches() {
13177 for (
unsigned I = 0, N = Matches.size(); I != N; ) {
13178 if (Matches[I].second->getPrimaryTemplate() ==
nullptr)
13181 Matches[I] = Matches[--N];
13187 void EliminateSuboptimalCudaMatches() {
13193 void ComplainNoMatchesFound()
const {
13194 assert(Matches.empty());
13196 << OvlExpr->
getName() << TargetFunctionType
13198 if (FailedCandidates.
empty())
13209 dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
13217 bool IsInvalidFormOfPointerToMemberFunction()
const {
13218 return TargetTypeIsNonStaticMemberFunction &&
13222 void ComplainIsInvalidFormOfPointerToMemberFunction()
const {
13230 bool IsStaticMemberFunctionFromBoundPointer()
const {
13231 return StaticMemberFunctionFromBoundPointer;
13234 void ComplainIsStaticMemberFunctionFromBoundPointer()
const {
13236 diag::err_invalid_form_pointer_member_function)
13240 void ComplainOfInvalidConversion()
const {
13242 << OvlExpr->
getName() << TargetType;
13245 void ComplainMultipleMatchesFound()
const {
13246 assert(Matches.size() > 1);
13253 bool hadMultipleCandidates()
const {
return (OvlExpr->
getNumDecls() > 1); }
13255 int getNumMatches()
const {
return Matches.size(); }
13258 if (Matches.size() != 1)
return nullptr;
13259 return Matches[0].second;
13263 if (Matches.size() != 1)
return nullptr;
13264 return &Matches[0].first;
13289 bool *pHadMultipleCandidates) {
13292 AddressOfFunctionResolver Resolver(*
this, AddressOfExpr, TargetType,
13294 int NumMatches = Resolver.getNumMatches();
13296 bool ShouldComplain = Complain && !Resolver.hasComplained();
13297 if (NumMatches == 0 && ShouldComplain) {
13298 if (Resolver.IsInvalidFormOfPointerToMemberFunction())
13299 Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
13301 Resolver.ComplainNoMatchesFound();
13303 else if (NumMatches > 1 && ShouldComplain)
13304 Resolver.ComplainMultipleMatchesFound();
13305 else if (NumMatches == 1) {
13306 Fn = Resolver.getMatchingFunctionDecl();
13310 FoundResult = *Resolver.getMatchingFunctionAccessPair();
13312 if (Resolver.IsStaticMemberFunctionFromBoundPointer())
13313 Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
13319 if (pHadMultipleCandidates)
13320 *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
13335 bool IsResultAmbiguous =
false;
13351 auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
13359 auto FoundBetter = [&]() {
13360 IsResultAmbiguous =
false;
13372 int PreferenceByCUDA = CheckCUDAPreference(FD, Result);
13374 if (PreferenceByCUDA != 0) {
13376 if (PreferenceByCUDA > 0)
13384 if (MoreConstrained != FD) {
13385 if (!MoreConstrained) {
13386 IsResultAmbiguous =
true;
13387 AmbiguousDecls.push_back(FD);
13396 if (IsResultAmbiguous)
13425 ExprResult &SrcExpr,
bool DoFunctionPointerConversion) {
13490 = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
13525 if (FoundResult) *FoundResult = I.getPair();
13544 ExprResult &SrcExpr,
bool doFunctionPointerConversion,
bool complain,
13546 unsigned DiagIDForComplaining) {
13565 isa<CXXMethodDecl>(fn) &&
13566 cast<CXXMethodDecl>(fn)->isInstance()) {
13567 if (!complain)
return false;
13570 diag::err_bound_member_function)
13583 SingleFunctionExpression =
13587 if (doFunctionPointerConversion) {
13588 SingleFunctionExpression =
13590 if (SingleFunctionExpression.
isInvalid()) {
13597 if (!SingleFunctionExpression.
isUsable()) {
13599 Diag(OpRangeForComplaining.
getBegin(), DiagIDForComplaining)
13601 << DestTypeForComplaining
13602 << OpRangeForComplaining
13613 SrcExpr = SingleFunctionExpression;
13623 bool PartialOverloading,
13625 NamedDecl *Callee = FoundDecl.getDecl();
13626 if (isa<UsingShadowDecl>(Callee))
13627 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
13630 if (ExplicitTemplateArgs) {
13631 assert(!KnownValid &&
"Explicit template arguments?");
13640 PartialOverloading);
13645 = dyn_cast<FunctionTemplateDecl>(Callee)) {
13647 ExplicitTemplateArgs, Args, CandidateSet,
13649 PartialOverloading);
13653 assert(!KnownValid &&
"unhandled case in overloaded call candidate");
13661 bool PartialOverloading) {
13684 assert(!(*I)->getDeclContext()->isRecord());
13685 assert(isa<UsingShadowDecl>(*I) ||
13686 !(*I)->getDeclContext()->isFunctionOrMethod());
13687 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
13697 ExplicitTemplateArgs = &TABuffer;
13703 CandidateSet, PartialOverloading,
13708 Args, ExplicitTemplateArgs,
13709 CandidateSet, PartialOverloading);
13719 CandidateSet,
false,
false);
13725 switch (Name.getCXXOverloadedOperator()) {
13726 case OO_New:
case OO_Array_New:
13727 case OO_Delete:
case OO_Array_Delete:
13750 if (DC->isTransparentContext())
13766 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC)) {
13771 if (FoundInClass) {
13772 *FoundInClass = RD;
13775 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
13792 AssociatedNamespaces,
13793 AssociatedClasses);
13797 for (Sema::AssociatedNamespaceSet::iterator
13798 it = AssociatedNamespaces.begin(),
13799 end = AssociatedNamespaces.end(); it != end; ++it) {
13801 if (
Std &&
Std->Encloses(*it))
13811 SuggestedNamespaces.insert(*it);
13817 if (SuggestedNamespaces.empty()) {
13819 diag::note_not_found_by_two_phase_lookup)
13821 }
else if (SuggestedNamespaces.size() == 1) {
13823 diag::note_not_found_by_two_phase_lookup)
13830 diag::note_not_found_by_two_phase_lookup)
13862 class BuildRecoveryCallExprRAII {
13867 BuildRecoveryCallExprRAII(
Sema &S) :
SemaRef(S), SatStack(S) {
13889 bool EmptyLookup,
bool AllowTypoCorrection) {
13897 BuildRecoveryCallExprRAII RCE(
SemaRef);
13907 ExplicitTemplateArgs = &TABuffer;
13915 ExplicitTemplateArgs, Args, &FoundInClass)) {
13917 }
else if (EmptyLookup) {
13922 ExplicitTemplateArgs !=
nullptr,
13923 dyn_cast<MemberExpr>(Fn));
13925 AllowTypoCorrection
13946 assert(!R.
empty() &&
"lookup results empty despite recovery");
13957 if ((*R.
begin())->isCXXClassMember())
13959 ExplicitTemplateArgs, S);
13960 else if (ExplicitTemplateArgs || TemplateKWLoc.
isValid())
13962 ExplicitTemplateArgs);
13989 assert(!ULE->
getQualifier() &&
"qualified name with ADL");
13996 (F = dyn_cast<FunctionDecl>(*ULE->
decls_begin())) &&
13998 llvm_unreachable(
"performing ADL for builtin");
14005 UnbridgedCastsSet UnbridgedCasts;
14020 if (CandidateSet->
empty() ||
14036 if (CandidateSet->
empty())
14039 UnbridgedCasts.restore();
14046 std::optional<QualType> Result;
14049 if (!Candidate.Function)
14051 if (Candidate.Function->isInvalidDecl())
14053 QualType T = Candidate.Function->getReturnType();
14058 else if (Result !=
T)
14066 if (Best && *Best != CS.
end())
14067 ConsiderCandidate(**Best);
14070 for (
const auto &C : CS)
14072 ConsiderCandidate(C);
14075 for (
const auto &C : CS)
14076 ConsiderCandidate(C);
14080 auto Value = *Result;
14081 if (
Value.isNull() ||
Value->isUndeducedType())
14098 bool AllowTypoCorrection) {
14099 switch (OverloadResult) {
14110 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14111 false, (*Best)->IsADLCandidate);
14119 CandidateSet->
empty(),
14120 AllowTypoCorrection);
14127 for (
const Expr *Arg : Args) {
14128 if (!Arg->getType()->isFunctionType())
14130 if (
auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
14131 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
14134 Arg->getExprLoc()))
14142 SemaRef.
PDiag(diag::err_ovl_no_viable_function_in_call)
14160 *CandidateSet, FDecl, Args);
14169 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14170 false, (*Best)->IsADLCandidate);
14176 SubExprs.append(Args.begin(), Args.end());
14183 for (
auto I = CS.
begin(), E = CS.
end(); I != E; ++I) {
14204 bool AllowTypoCorrection,
14205 bool CalleesAddressIsTaken) {
14216 if (CalleesAddressIsTaken)
14230 if (
const auto *TP =
14240 ExecConfig, &CandidateSet, &Best,
14241 OverloadResult, AllowTypoCorrection);
14250 PerformADL, Fns.
begin(), Fns.
end(),
14256 bool HadMultipleCandidates) {
14264 FoundDecl, Method);
14273 auto *CE = dyn_cast<CastExpr>(SubE);
14274 if (CE && CE->getCastKind() == CK_NoOp)
14275 SubE = CE->getSubExpr();
14277 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
14278 SubE = BE->getSubExpr();
14279 if (isa<LambdaExpr>(SubE)) {
14307 Expr *ObjectParam = Exp.
get();
14320 Exp.
get()->getEndLoc(),
14349 Expr *Input,
bool PerformADL) {
14351 assert(Op !=
OO_None &&
"Invalid opcode for overloaded unary operator");
14359 Expr *Args[2] = { Input,
nullptr };
14360 unsigned NumArgs = 1;
14365 if (Opc == UO_PostInc || Opc == UO_PostDec) {
14379 if (Opc == UO_PreDec || Opc == UO_PreInc || Opc == UO_Deref)
14416 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
14431 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14439 Input,
nullptr, Best->FoundDecl, Method);
14442 Base = Input = InputInit.
get();
14453 Input = InputInit.
get();
14458 Base, HadMultipleCandidates,
14470 Context, Op, FnExpr.
get(), ArgsArray, ResultTy, VK, OpLoc,
14485 Input, Best->BuiltinParamTypes[0], Best->Conversions[0],
AA_Passing,
14489 Input = InputRes.
get();
14509 PDiag(diag::err_ovl_ambiguous_oper_unary)
14526 << (Msg !=
nullptr)
14527 << (Msg ? Msg->
getString() : StringRef())
14575 if (Op != OO_Equal && PerformADL) {
14631 Expr *RHS,
bool PerformADL,
14632 bool AllowRewrittenCandidates,
14634 Expr *Args[2] = { LHS, RHS };
14638 AllowRewrittenCandidates =
false;
14644 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
14674 if (Opc == BO_PtrMemD) {
14675 auto CheckPlaceholder = [&](
Expr *&Arg) {
14684 if (CheckPlaceholder(Args[0]) || CheckPlaceholder(Args[1]))
14705 if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
14711 Op, OpLoc, AllowRewrittenCandidates));
14713 CandidateSet.
exclude(DefaultedFn);
14716 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
14725 bool IsReversed = Best->isReversed();
14727 std::swap(Args[0], Args[1]);
14744 if (Best->RewriteKind && ChosenOp == OO_EqualEqual &&
14748 Diag(OpLoc, IsExtension ? diag::ext_ovl_rewrite_equalequal_not_bool
14749 : diag::err_ovl_rewrite_equalequal_not_bool)
14757 if (AllowRewrittenCandidates && !IsReversed &&
14765 if (Cand.Viable && Cand.Function && Cand.isReversed() &&
14767 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
14769 *
this, OpLoc, Cand.Conversions[ArgIdx],
14770 Best->Conversions[ArgIdx]) ==
14772 AmbiguousWith.push_back(Cand.Function);
14779 if (!AmbiguousWith.empty()) {
14780 bool AmbiguousWithSelf =
14781 AmbiguousWith.size() == 1 &&
14783 Diag(OpLoc, diag::ext_ovl_ambiguous_oper_binary_reversed)
14785 << Args[0]->
getType() << Args[1]->
getType() << AmbiguousWithSelf
14787 if (AmbiguousWithSelf) {
14789 diag::note_ovl_ambiguous_oper_binary_reversed_self);
14794 if (
auto *MD = dyn_cast<CXXMethodDecl>(FnDecl))
14795 if (Op == OverloadedOperatorKind::OO_EqualEqual &&
14797 !MD->hasCXXExplicitFunctionObjectParameter() &&
14799 MD->getFunctionObjectParameterType(),
14800 MD->getParamDecl(0)->getType().getNonReferenceType()) &&
14802 MD->getFunctionObjectParameterType(),
14805 MD->getFunctionObjectParameterType(),
14808 diag::note_ovl_ambiguous_eqeq_reversed_self_non_const);
14811 diag::note_ovl_ambiguous_oper_binary_selected_candidate);
14812 for (
auto *F : AmbiguousWith)
14813 Diag(F->getLocation(),
14814 diag::note_ovl_ambiguous_oper_binary_reversed_candidate);
14822 if (Op == OO_Equal)
14824 Args[1]->getType(), OpLoc);
14827 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14838 Args[0],
nullptr, Best->FoundDecl, Method);
14871 Best->FoundDecl,
Base,
14872 HadMultipleCandidates, OpLoc);
14883 const Expr *ImplicitThis =
nullptr;
14888 Context, ChosenOp, FnExpr.
get(), Args, ResultTy, VK, OpLoc,
14891 if (
const auto *Method = dyn_cast<CXXMethodDecl>(FnDecl);
14894 ImplicitThis = ArgsArray[0];
14895 ArgsArray = ArgsArray.slice(1);
14903 if (Op == OO_Equal)
14906 if (ImplicitThis) {
14909 cast<CXXMethodDecl>(FnDecl)->getFunctionObjectParameterType());
14911 CheckArgAlignment(OpLoc, FnDecl,
"'this'", ThisType,
14915 checkCall(FnDecl,
nullptr, ImplicitThis, ArgsArray,
14930 (Op == OO_Spaceship && IsReversed)) {
14931 if (Op == OO_ExclaimEqual) {
14932 assert(ChosenOp == OO_EqualEqual &&
"unexpected operator name");
14935 assert(ChosenOp == OO_Spaceship &&
"unexpected operator name");
14937 Expr *ZeroLiteral =
14946 OpLoc, Opc, Fns, IsReversed ? ZeroLiteral : R.
get(),
14947 IsReversed ? R.
get() : ZeroLiteral,
true,
14955 assert(ChosenOp == Op &&
"unexpected operator name");
14959 if (Best->RewriteKind !=
CRK_None)
14968 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
14972 Args[0] = ArgsRes0.
get();
14975 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
14979 Args[1] = ArgsRes1.
get();
14989 if (Opc == BO_Comma)
14994 if (DefaultedFn && Opc == BO_Cmp) {
14996 Args[1], DefaultedFn);
15011 Opc >= BO_Assign && Opc <= BO_OrAssign) {
15012 Diag(OpLoc, diag::err_ovl_no_viable_oper)
15015 if (Args[0]->getType()->isIncompleteType()) {
15016 Diag(OpLoc, diag::note_assign_lhs_incomplete)
15032 assert(Result.isInvalid() &&
15033 "C++ binary operator overloading is missing candidates!");
15042 << Args[0]->getType()
15043 << Args[1]->getType()
15055 Diag(OpLoc, diag::err_ovl_deleted_special_oper)
15060 Diag(OpLoc, diag::err_ovl_deleted_comparison)
15061 << Args[0]->
getType() << DeletedFD;
15074 PDiag(diag::err_ovl_deleted_oper)
15076 .getCXXOverloadedOperator())
15077 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef())
15102 "cannot use prvalue expressions more than once");
15103 Expr *OrigLHS = LHS;
15104 Expr *OrigRHS = RHS;
15117 if (
Eq.isInvalid())
15121 true, DefaultedFn);
15122 if (
Less.isInvalid())
15134 struct Comparison {
15149 for (; I >= 0; --I) {
15151 auto *VI = Info->lookupValueInfo(Comparisons[I].Result);
15161 if (Result.get()) {
15163 ThisResult.
get(), Result.get());
15164 if (Result.isInvalid())
15167 Result = ThisResult;
15174 Context, OrigLHS, OrigRHS, BO_Cmp, Result.get()->getType(),
15175 Result.get()->getValueKind(), Result.get()->getObjectKind(), OpLoc,
15177 Expr *SemanticForm[] = {LHS, RHS, Result.get()};
15187 unsigned NumArgsSlots =
15188 MethodArgs.size() + std::max<unsigned>(Args.size(), NumParams);
15191 MethodArgs.reserve(MethodArgs.size() + NumArgsSlots);
15192 bool IsError =
false;
15195 for (
unsigned i = 0; i != NumParams; i++) {
15197 if (i < Args.size()) {
15215 MethodArgs.push_back(Arg);
15225 Args.push_back(
Base);
15226 for (
auto *e : ArgExpr) {
15235 ArgExpr.back()->getEndLoc());
15257 UnbridgedCastsSet UnbridgedCasts;
15270 if (Args.size() == 2)
15273 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15298 Args[0] = Res.
get();
15302 Args[0],
nullptr, Best->FoundDecl, Method);
15306 MethodArgs.push_back(Arg0.
get());
15310 *
this, MethodArgs, Method, ArgExpr, LLoc);
15318 *
this, FnDecl, Best->FoundDecl,
Base, HadMultipleCandidates,
15329 Context, OO_Subscript, FnExpr.
get(), MethodArgs, ResultTy, VK, RLoc,
15346 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
15350 Args[0] = ArgsRes0.
get();
15353 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
15357 Args[1] = ArgsRes1.
get();
15365 CandidateSet.
empty()
15366 ? (
PDiag(diag::err_ovl_no_oper)
15367 << Args[0]->getType() << 0
15368 << Args[0]->getSourceRange() <<
Range)
15369 : (
PDiag(diag::err_ovl_no_viable_subscript)
15370 << Args[0]->getType() << Args[0]->getSourceRange() <<
Range);
15377 if (Args.size() == 2) {
15380 LLoc,
PDiag(diag::err_ovl_ambiguous_oper_binary)
15381 <<
"[]" << Args[0]->getType() << Args[1]->getType()
15387 PDiag(diag::err_ovl_ambiguous_subscript_call)
15388 << Args[0]->getType()
15398 PDiag(diag::err_ovl_deleted_oper)
15399 <<
"[]" << (Msg !=
nullptr)
15400 << (Msg ? Msg->
getString() : StringRef())
15422 Expr *ExecConfig,
bool IsExecConfig,
15423 bool AllowRecovery) {
15432 if (
BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
15434 assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
15447 QualType objectType = op->getLHS()->getType();
15448 if (op->getOpcode() == BO_PtrMemI)
15452 Qualifiers difference = objectQuals - funcQuals;
15456 std::string qualsString = difference.
getAsString();
15457 Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
15460 << (qualsString.find(
' ') == std::string::npos ? 1 : 2);
15464 Context, MemExprE, Args, resultType, valueKind, RParenLoc,
15474 if (CheckOtherCall(call, proto))
15484 if (!AllowRecovery)
15486 std::vector<Expr *> SubExprs = {MemExprE};
15487 llvm::append_range(SubExprs, Args);
15491 if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
15495 UnbridgedCastsSet UnbridgedCasts;
15501 bool HadMultipleCandidates =
false;
15504 if (isa<MemberExpr>(NakedMemExpr)) {
15505 MemExpr = cast<MemberExpr>(NakedMemExpr);
15509 UnbridgedCasts.restore();
15527 TemplateArgs = &TemplateArgsBuffer;
15531 E = UnresExpr->
decls_end(); I != E; ++I) {
15533 QualType ExplicitObjectType = ObjectType;
15537 if (isa<UsingShadowDecl>(
Func))
15538 Func = cast<UsingShadowDecl>(
Func)->getTargetDecl();
15540 bool HasExplicitParameter =
false;
15541 if (
const auto *M = dyn_cast<FunctionDecl>(
Func);
15542 M && M->hasCXXExplicitFunctionObjectParameter())
15543 HasExplicitParameter =
true;
15544 else if (
const auto *M = dyn_cast<FunctionTemplateDecl>(
Func);
15546 M->getTemplatedDecl()->hasCXXExplicitFunctionObjectParameter())
15547 HasExplicitParameter =
true;
15549 if (HasExplicitParameter)
15557 }
else if ((Method = dyn_cast<CXXMethodDecl>(
Func))) {
15564 ObjectClassification, Args, CandidateSet,
15568 I.getPair(), ActingDC, TemplateArgs,
15569 ExplicitObjectType, ObjectClassification,
15570 Args, CandidateSet,
15575 HadMultipleCandidates = (CandidateSet.
size() > 1);
15579 UnbridgedCasts.restore();
15582 bool Succeeded =
false;
15586 Method = cast<CXXMethodDecl>(Best->Function);
15587 FoundDecl = Best->FoundDecl;
15597 if (Method != FoundDecl.getDecl() &&
15607 PDiag(diag::err_ovl_no_viable_member_function_in_call)
15614 PDiag(diag::err_ovl_ambiguous_member_call)
15621 CandidateSet, Best->Function, Args,
true);
15632 MemExprE = Res.
get();
15638 ExecConfig, IsExecConfig);
15648 assert(Method &&
"Member call to something that isn't a method?");
15661 HadMultipleCandidates, MemExpr->
getExprLoc());
15673 MemExpr->
getBase(), Qualifier, FoundDecl, Method);
15679 Proto->getNumParams());
15685 return BuildRecoveryExpr(ResultType);
15690 return BuildRecoveryExpr(ResultType);
15700 if (
auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
15701 if (
const EnableIfAttr *
Attr =
15703 Diag(MemE->getMemberLoc(),
15704 diag::err_ovl_no_viable_member_function_in_call)
15707 diag::note_ovl_candidate_disabled_by_function_cond_attr)
15708 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
15713 if (isa<CXXConstructorDecl, CXXDestructorDecl>(
CurContext) &&
15714 TheCall->getDirectCallee()->isPureVirtual()) {
15720 diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
15731 if (
auto *DD = dyn_cast<CXXDestructorDecl>(TheCall->getDirectCallee())) {
15735 CallCanBeVirtual,
true,
15740 TheCall->getDirectCallee());
15756 UnbridgedCastsSet UnbridgedCasts;
15760 assert(Object.get()->getType()->isRecordType() &&
15761 "Requires object type argument");
15775 diag::err_incomplete_object_call, Object.get()))
15781 R.suppressAccessDiagnostics();
15784 Oper != OperEnd; ++Oper) {
15786 Object.get()->Classify(
Context), Args, CandidateSet,
15798 bool IgnoreSurrogateFunctions =
false;
15799 if (CandidateSet.
size() == 1 &&
Record->getAsCXXRecordDecl()->isLambda()) {
15801 if (!Candidate.
Viable &&
15803 IgnoreSurrogateFunctions =
true;
15823 const auto &Conversions =
15824 cast<CXXRecordDecl>(
Record->getDecl())->getVisibleConversionFunctions();
15825 for (
auto I = Conversions.begin(), E = Conversions.end();
15826 !IgnoreSurrogateFunctions && I != E; ++I) {
15829 if (isa<UsingShadowDecl>(D))
15830 D = cast<UsingShadowDecl>(D)->getTargetDecl();
15834 if (isa<FunctionTemplateDecl>(D))
15848 Object.get(), Args, CandidateSet);
15853 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15866 CandidateSet.
empty()
15867 ? (
PDiag(diag::err_ovl_no_oper)
15868 << Object.get()->getType() << 1
15869 << Object.get()->getSourceRange())
15870 : (
PDiag(diag::err_ovl_no_viable_object_call)
15871 << Object.get()->getType() << Object.get()->getSourceRange());
15878 if (!R.isAmbiguous())
15881 PDiag(diag::err_ovl_ambiguous_object_call)
15882 << Object.get()->getType()
15883 << Object.get()->getSourceRange()),
15894 PDiag(diag::err_ovl_deleted_object_call)
15895 << Object.get()->getType() << (Msg !=
nullptr)
15896 << (Msg ? Msg->
getString() : StringRef())
15897 << Object.get()->getSourceRange()),
15903 if (Best == CandidateSet.
end())
15906 UnbridgedCasts.restore();
15908 if (Best->Function ==
nullptr) {
15912 = cast<CXXConversionDecl>(
15913 Best->Conversions[0].UserDefined.ConversionFunction);
15919 assert(Conv == Best->FoundDecl.getDecl() &&
15920 "Found Decl & conversion-to-functionptr should be same, right?!");
15928 Conv, HadMultipleCandidates);
15929 if (Call.isInvalid())
15933 Context, Call.get()->getType(), CK_UserDefinedConversion, Call.get(),
15936 return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
15944 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
15957 Obj, HadMultipleCandidates,
15964 MethodArgs.reserve(NumParams + 1);
15966 bool IsError =
false;
15974 Object.get(),
nullptr, Best->FoundDecl, Method);
15979 MethodArgs.push_back(Object.get());
15983 *
this, MethodArgs, Method, Args, LParenLoc);
15986 if (Proto->isVariadic()) {
15988 for (
unsigned i = NumParams, e = Args.size(); i < e; i++) {
15992 MethodArgs.push_back(Arg.
get());
16007 Context, OO_Call, NewFn.
get(), MethodArgs, ResultTy, VK, RParenLoc,
16024 bool *NoArrowOperatorFound) {
16025 assert(
Base->getType()->isRecordType() &&
16026 "left-hand side must have class type");
16044 diag::err_typecheck_incomplete_tag,
Base))
16052 Oper != OperEnd; ++Oper) {
16054 std::nullopt, CandidateSet,
16058 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16069 if (CandidateSet.
empty()) {
16071 if (NoArrowOperatorFound) {
16074 *NoArrowOperatorFound =
true;
16077 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
16078 << BaseType <<
Base->getSourceRange();
16080 Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
16084 Diag(OpLoc, diag::err_ovl_no_viable_oper)
16085 <<
"operator->" <<
Base->getSourceRange();
16093 <<
"->" <<
Base->getType()
16094 <<
Base->getSourceRange()),
16102 <<
"->" << (Msg !=
nullptr)
16103 << (Msg ? Msg->
getString() : StringRef())
16104 <<
Base->getSourceRange()),
16113 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
16122 Base,
nullptr, Best->FoundDecl, Method);
16130 Base, HadMultipleCandidates, OpLoc);
16166 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16179 PDiag(diag::err_ovl_no_viable_function_in_call)
16194 nullptr, HadMultipleCandidates,
16203 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
16209 ConvArgs[ArgIdx] = InputInit.
get();
16243 Scope *S =
nullptr;
16246 if (!MemberLookup.
empty()) {
16274 if (CandidateSet->
empty() || CandidateSetError) {
16287 Loc,
nullptr, CandidateSet, &Best,
16306 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
16311 if (SubExpr.
get() == PE->getSubExpr())
16315 ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.
get());
16325 "Implicit cast type cannot be determined from overload");
16326 assert(ICE->path_empty() &&
"fixing up hierarchy conversion?");
16327 if (SubExpr.
get() == ICE->getSubExpr())
16335 if (
auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
16336 if (!GSE->isResultDependent()) {
16341 if (SubExpr.
get() == GSE->getResultExpr())
16348 unsigned ResultIdx = GSE->getResultIndex();
16349 AssocExprs[ResultIdx] = SubExpr.
get();
16351 if (GSE->isExprPredicate())
16353 Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
16354 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16355 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16358 Context, GSE->getGenericLoc(), GSE->getControllingType(),
16359 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16360 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16369 assert(UnOp->getOpcode() == UO_AddrOf &&
16370 "Can only take the address of an overloaded function");
16383 if (SubExpr.
get() == UnOp->getSubExpr())
16387 SubExpr.
get(), Method))
16390 assert(isa<DeclRefExpr>(SubExpr.
get()) &&
16391 "fixed to something other than a decl ref");
16392 assert(cast<DeclRefExpr>(SubExpr.
get())->getQualifier() &&
16393 "fixed to a member ref with no nested name qualifier");
16408 UnOp->getOperatorLoc(),
false,
16416 if (SubExpr.
get() == UnOp->getSubExpr())
16426 if (ULE->hasExplicitTemplateArgs()) {
16427 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
16428 TemplateArgs = &TemplateArgsBuffer;
16443 Fn,
Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
16444 Found.
getDecl(), ULE->getTemplateKeywordLoc(), TemplateArgs);
16452 if (MemExpr->hasExplicitTemplateArgs()) {
16453 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
16454 TemplateArgs = &TemplateArgsBuffer;
16461 if (MemExpr->isImplicitAccess()) {
16462 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16465 MemExpr->getQualifierLoc(), Found.
getDecl(),
16466 MemExpr->getTemplateKeywordLoc(), TemplateArgs);
16471 if (MemExpr->getQualifier())
16472 Loc = MemExpr->getQualifierLoc().getBeginLoc();
16477 Base = MemExpr->getBase();
16481 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16490 Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
16491 MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
16492 true, MemExpr->getMemberNameInfo(),
16496 llvm_unreachable(
"Invalid reference to overloaded function");
16507 if (!PartialOverloading || !
Function)
16511 if (
const auto *Proto =
16512 dyn_cast<FunctionProtoType>(
Function->getFunctionType()))
16513 if (Proto->isTemplateVariadic())
16515 if (
auto *Pattern =
Function->getTemplateInstantiationPattern())
16516 if (
const auto *Proto =
16517 dyn_cast<FunctionProtoType>(Pattern->getFunctionType()))
16518 if (Proto->isTemplateVariadic())
16531 << IsMember << Name << (Msg !=
nullptr)
16532 << (Msg ? Msg->
getString() : StringRef())
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the Diagnostic-related interfaces.
static bool isBooleanType(QualType Ty)
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result, EvalInfo &Info)
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.
static std::string getName(const CallEvent &Call)
This file declares semantic analysis for CUDA constructs.
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
static bool isRecordType(QualType T)
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 isNullPointerConstantForConversion(Expr *Expr, bool InOverloadResolution, ASTContext &Context)
static bool shouldSkipNotingLambdaConversionDecl(const FunctionDecl *Fn)
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 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 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 bool isQualificationConversionStep(QualType FromType, QualType ToType, bool CStyle, bool IsTopLevel, bool &PreviousToQualsIncludeConst, bool &ObjCLifetimeConversion)
Perform a single iteration of the loop for checking if a qualification conversion is valid.
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 bool hasDeprecatedStringLiteralToCharPtrConversion(const ImplicitConversionSequence &ICS)
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From, QualType T, APValue &Value, Sema::CCEKind CCE, bool RequireInt, NamedDecl *Dest)
CheckConvertedConstantExpression - Check that the expression From is a converted constant expression ...
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 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 const FunctionProtoType * tryGetFunctionProtoType(QualType FromType)
Attempts to get the FunctionProtoType from a Type.
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 ImplicitConversionSequence::CompareKind compareStandardConversionSubsets(ASTContext &Context, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
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 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 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 void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D, unsigned NumFormalArgs)
General arity mismatch diagnosis over a candidate in a candidate set.
static const FunctionType * getConversionOpReturnTyAsFunction(CXXConversionDecl *Conv)
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 ExprResult BuildConvertedConstantExpression(Sema &S, Expr *From, QualType T, Sema::CCEKind CCE, NamedDecl *Dest, APValue &PreNarrowingValue)
BuildConvertedConstantExpression - Check that the expression From is a converted constant expression ...
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 bool IsVectorElementConversion(Sema &S, QualType FromType, QualType ToType, ImplicitConversionKind &ICK, Expr *From)
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 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 Expr * GetExplicitObjectExpr(Sema &S, Expr *Obj, const FunctionDecl *Fun)
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 ImplicitConversionSequence TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, AllowedExplicit AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
Tries a user-defined conversion from From to ToType.
static void markUnaddressableCandidatesUnviable(Sema &S, OverloadCandidateSet &CS)
static QualType GetExplicitObjectType(Sema &S, const Expr *MemExprE)
static bool sameFunctionParameterTypeLists(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2)
We're allowed to use constraints partial ordering only if the candidates have the same parameter type...
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 ImplicitConversionSequence::CompareKind HLSLCompareFloatingRank(QualType LHS, QualType RHS)
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 const char * GetImplicitConversionName(ImplicitConversionKind Kind)
GetImplicitConversionName - Return the name of this kind of implicit conversion.
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 CheckArityMismatch(Sema &S, OverloadCandidate *Cand, unsigned NumArgs)
Additional arity mismatch diagnosis specific to a function overload candidates.
static bool shouldAddReversedEqEq(Sema &S, SourceLocation OpLoc, Expr *FirstOperand, FunctionDecl *EqFD)
static bool isFunctionAlwaysEnabled(const ASTContext &Ctx, const FunctionDecl *FD)
static TemplateDecl * getDescribedTemplate(Decl *Templated)
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 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 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 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 bool PrepareArgumentsForCallToObjectOfClassType(Sema &S, SmallVectorImpl< Expr * > &MethodArgs, CXXMethodDecl *Method, MultiExprArg Args, SourceLocation LParenLoc)
This file declares semantic analysis for SYCL constructs.
Defines the SourceManager interface.
Allows QualTypes to be sorted and hence used in maps and sets.
C Language Family Type Representation.
__DEVICE__ int min(int __a, int __b)
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 ...
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
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
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
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.
bool hasSimilarType(QualType T1, QualType T2)
Determine if two types are similar, according to the C++ rules.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
DeclarationNameTable DeclarationNames
QualType getRecordType(const RecordDecl *Decl) const
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 mergeExtParameterInfo(const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType, bool &CanUseFirst, bool &CanUseSecond, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &NewParamInfos)
This function merges the ExtParameterInfo lists of two functions.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
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 getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Builtin::Context & BuiltinInfo
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 ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType removePtrSizeAddrSpace(QualType T) const
Remove the existing address space on the type if it is a pointer size address space and return the ty...
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...
bool canBindObjCObjectType(QualType To, QualType From)
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
const LangOptions & getLangOpts() const
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>.
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>,...
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
CanQualType UnsignedLongTy
QualType getRestrictType(QualType T) const
Return the uniqued reference to the type for a restrict qualified type.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CanQualType BoundMemberTy
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 getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
const TargetInfo & getTargetInfo() const
bool UnwrapSimilarTypes(QualType &T1, QualType &T2, bool AllowPiMismatch=true)
Attempt to unwrap two types that may be similar (C++ [conv.qual]).
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...
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...
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 ...
const TargetInfo * getAuxTargetInfo() const
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
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
bool isCompoundAssignmentOp() const
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
This class is used for builtin types like 'int'.
bool isDirectlyAddressable(unsigned ID) const
Determines whether this builtin can have its address taken with no special action required.
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a C++ constructor within a class.
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...
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
unsigned getNumExplicitParams() const
QualType getFunctionObjectParameterReferenceType() const
Return the type of the object pointed by this.
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
QualType getThisType() const
Return the type of the this pointer.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Qualifiers getMethodQualifiers() const
QualType getFunctionObjectParameterType() const
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.
void markDependentForPostponedNameLookup()
Used by Sema to implement MSVC-compatible delayed name lookup.
static CallExpr * CreateTemporary(void *Mem, Expr *Fn, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, ADLCallKind UsesADL=NotADL)
Create a temporary call expression with no arguments in the memory pointed to by Mem.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
static CanQual< Type > CreateUnsafe(QualType Other)
Builds a canonical type from a QualType.
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 isAtLeastAsQualifiedAs(CanQual< T > Other) const
Determines whether this canonical type is at least as qualified as the Other canonical type.
bool isVolatileQualified() const
const ComparisonCategoryInfo * lookupInfoForType(QualType Ty) const
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...
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
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.
Decl::Kind getDeclKind() const
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.
bool isTemplateDecl() const
returns true if this declaration is a template
specific_attr_iterator< T > specific_attr_end() const
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible.
unsigned getTemplateDepth() const
Determine the number of levels of template parameter surrounding this declaration.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
bool isInvalidDecl() const
SourceLocation getLocation() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
AccessSpecifier getAccess() const
specific_attr_iterator< T > specific_attr_begin() const
DeclContext * getDeclContext()
DeclarationNameLoc - Additional source/type location info for a declaration name.
The name of a declaration.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
NameKind getNameKind() const
Determine what kind of name this is.
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
SourceLocation getBeginLoc() const LLVM_READONLY
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
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
RAII object that enters a new expression evaluation context.
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
Store information needed for an explicit specifier.
bool isExplicit() const
Determine whether this specifier is known to correspond to an explicit declaration.
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, modifiably lvalue.
This represents one expression.
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, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) 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.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
@ 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.
@ ClassTemplateArgument
A class template argument. Such a value is used for code generation.
@ Normal
An integer constant expression (an array bound, enumerator, case value, bit-field width,...
@ NonClassTemplateArgument
A non-class template argument.
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.
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.
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
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
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
unsigned getMinRequiredExplicitArguments() const
Returns the minimum number of non-object arguments needed to call this function.
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.
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
bool isDeleted() const
Whether this function has been deleted.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
unsigned getNumNonObjectParams() const
StringLiteral * getDeletedMessage() const
Get the message that indicates why this function was deleted.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isDeletedAsWritten() const
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
bool isDefaulted() const
Whether this function is defaulted.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
ArrayRef< ParmVarDecl * > parameters() const
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
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.
SourceRange getParametersSourceRange() const
Attempt to compute an informative source range covering the function parameters, including the ellips...
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
const ParmVarDecl * getParamDecl(unsigned i) const
Represents a prototype with parameter type info, e.g.
ArrayRef< QualType > param_types() const
unsigned getNumParams() const
Qualifiers getMethodQuals() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
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
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.
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, NonTypeTemplateParmDecl *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.
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
DeclClass * getAsSingle() const
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
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'.
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 ...
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member 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.
const Type * getClass() const
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.
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.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
std::string getQualifiedNameAsString(bool WithGlobalNsPrefix=false) 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.
Interfaces are the core concept in Objective-C for object oriented design.
ObjCMethodDecl - Represents an instance or class method declaration.
unsigned param_size() const
ArrayRef< ParmVarDecl * > parameters() const
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.
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.
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
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.
bool isNewCandidate(Decl *F, OverloadCandidateParamOrder PO=OverloadCandidateParamOrder::Normal)
Determine when this overload candidate will be new to the overload set.
ConversionSequenceList allocateConversionSequences(unsigned NumConversions)
Allocate storage for conversion sequences for NumConversions conversions.
OperatorRewriteInfo getRewriteInfo() const
@ 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=std::nullopt)
Add a new candidate with NumConversions conversion sequence slots to the overload set.
CandidateSetKind getKind() 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.
SourceLocation getNameLoc() const
Gets the location of the name.
decls_iterator decls_begin() const
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
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 parethesized expression, e.g.
Represents a parameter to a function.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
void EmitToString(DiagnosticsEngine &Diags, SmallVectorImpl< char > &Buf) const
unsigned getDiagID() const
StringRef getStringArg(unsigned I)
Retrieve the string argument at the given index.
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 isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
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
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)
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()
void removeAddressSpace()
void setAddressSpace(LangAS space)
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
bool hasObjCGCAttr() const
ObjCLifetime getObjCLifetime() const
std::string getAsString() const
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
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
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
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
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
@ Sycl
SYCL specific 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 ...
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...
static bool isImplicitHostDeviceFunction(const FunctionDecl *D)
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.
SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID, DeviceDiagnosticReason Reason=DeviceDiagnosticReason::Sycl|DeviceDiagnosticReason::Esimd)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
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.
ExprResult PerformImplicitObjectArgumentInitialization(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
PerformObjectArgumentInitialization - Perform initialization of the implicit object parameter for the...
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.
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr * > Args=std::nullopt, DeclContext *LookupCtx=nullptr, TypoExpr **Out=nullptr)
Diagnose an empty lookup.
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....
@ LookupOperatorName
Look up of an operator name (e.g., operator+) for use with operator overloading.
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 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)
void AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true)
AddConversionCandidate - Add a C++ conversion function as a candidate in the candidate set (C++ [over...
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.
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)
DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but will create a trap if the resul...
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
static bool TooManyArguments(size_t NumParams, size_t NumArgs, bool PartialOverloading=false)
To be used for checking whether the arguments being passed to function exceeds the number of paramete...
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.
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 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 DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
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....
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, const SourceRange &, DeclAccessPair FoundDecl)
Module * getOwningModule(const Decl *Entity)
Get the module owning an entity.
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...
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr, TemplateSpecCandidateSet *FailedTSC=nullptr)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
@ None
Allow no explicit functions to be used.
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.
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 IsBlockPointerConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
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)
Warn 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...
bool CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess)
CheckMemberPointerConversion - Check the member pointer conversion from the expression From to the ty...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
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,...
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)
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 (...
const LangOptions & LangOpts
bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType, bool InOverloadResolution, QualType &ConvertedType)
IsMemberPointerConversion - Determines whether the conversion of the expression From,...
const LangOptions & getLangOpts() const
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.
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)
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.
void popCodeSynthesisContext()
bool AreConstraintExpressionsEqual(const NamedDecl *Old, const Expr *OldConstr, const TemplateCompareNewDeclInfo &New, const Expr *NewConstr)
ReferenceConversionsScope::ReferenceConversions ReferenceConversions
FunctionTemplateDecl * getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, QualType RawObj1Ty={}, QualType RawObj2Ty={}, bool Reversed=false)
Returns the more specialized function template according to the rules of function template partial or...
Expr * BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit)
Build a CXXThisExpr and mark it referenced in the current context.
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
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.
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...
bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, ArrayRef< const Expr * > AC1, NamedDecl *D2, ArrayRef< const Expr * > AC2)
If D1 was not at least as constrained as D2, but would've been if a pair of atomic constraints involv...
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.
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)
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.
ObjCMethodDecl * SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance, SmallVectorImpl< ObjCMethodDecl * > &Methods)
AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair FoundDecl)
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ CompatiblePointerDiscardsQualifiers
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
@ IncompatiblePointer
IncompatiblePointer - The assignment is between two pointers types that are not compatible,...
@ Compatible
Compatible - the types are compatible according to the standard.
@ IncompatiblePointerSign
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
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 ?: operation.
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...
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
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=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
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,...
CCEKind
Contexts in which a converted constant expression is required.
@ CCEK_ExplicitBool
Condition in an explicit(bool) specifier.
@ CCEK_Noexcept
Condition in a noexcept(bool) specifier.
@ CCEK_ArrayBound
Array bound in array declarator or new-expression.
@ CCEK_TemplateArg
Value of a non-type template parameter.
ASTContext & getASTContext() const
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...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
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.
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
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.
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...
DiagnosticsEngine & getDiagnostics() const
bool CheckNonDependentConversions(FunctionTemplateDecl *FunctionTemplate, ArrayRef< QualType > ParamTypes, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, ConversionSequenceList &Conversions, bool SuppressUserConversions, 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...
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.
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
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...
ImplicitConversionKind Element
Element - Between the second and third conversion a vector or matrix element conversion may occur.
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).
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)
QualType getToType(unsigned Idx) const
Stmt - This represents one statement.
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...
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
StringRef getString() const
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
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.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
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() 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.
Represents a type template specialization; the template must be a class template, a type alias templa...
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
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.
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 isExtVectorType() const
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
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.
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.
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...
SourceLocation getBeginLoc() const LLVM_READONLY
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
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.
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)
Represents a GCC generic vector type.
Provides information about an attempted template argument deduction, whose success or failure was des...
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?
bool AggregateDeductionCandidateHasMismatchedArity
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.
TemplateArgumentList * takeSugared()
Take ownership of the deduced template argument lists.
unsigned CallArgIndex
The index of the function argument that caused a deduction failure.
specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are o...
Defines the clang::TargetInfo interface.
constexpr XRayInstrMask All
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
@ After
Like System, but searched after the system directories.
bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
bool This(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
@ NUM_OVERLOADED_OPERATORS
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 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...
@ 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_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_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.
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.
OverloadCandidateParamOrder
The parameter ordering that will be used for the candidate.
OverloadsShown
Specifies which overload candidates to display when overload resolution fails.
@ Ovl_Best
Show just the "best" overload candidates.
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.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
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])
ActionResult< Expr * > ExprResult
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...
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
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...
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 isBetterOverloadCandidate(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2, SourceLocation Loc, OverloadCandidateSet::CandidateSetKind Kind)
isBetterOverloadCandidate - Determines whether the first overload candidate is a better candidate tha...
const FunctionProtoType * T
bool shouldEnforceArgLimit(bool PartialOverloading, FunctionDecl *Function)
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.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
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....
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.
ConstructorInfo getConstructorInfo(NamedDecl *ND)
ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind)
GetConversionRank - Retrieve the implicit conversion rank corresponding to the given implicit convers...
@ EST_None
no exception specification
@ ForBuiltinOverloadedOp
A conversion for an operand of a builtin overloaded operator.
__DEVICE__ _Tp abs(const std::complex< _Tp > &__c)
float __ovld __cnfn distance(float, float)
Returns the distance between p0 and p1.
Represents an ambiguous user-defined conversion sequence.
ConversionSet::const_iterator const_iterator
ConversionSet & conversions()
void setFromType(QualType T)
void setToType(QualType T)
void addConversion(NamedDecl *Found, FunctionDecl *D)
void copyFrom(const AmbiguousConversionSequence &)
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.
std::optional< unsigned > getCallArgIndex()
Return the index of the call argument that this deduction failure refers to, if any.
TemplateDeductionResult getResult() const
void Destroy()
Free any memory associated with this deduction failure.
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.
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.
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.
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).
CallExpr::ADLCallKind IsADLCandidate
True if the candidate was found using ADL.
bool TryToFixBadConversion(unsigned Idx, Sema &S)
bool NotValidBecauseConstraintExprHasError() const
bool 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.
bool IgnoreObjectArgument
IgnoreObjectArgument - True to indicate that the first argument's conversion, which for this function...
DeclAccessPair FoundDecl
FoundDecl - The original declaration that was looked up / invented / otherwise found,...
FunctionDecl * Function
Function - The actual function that this candidate represents.
bool Viable
Viable - True to indicate that this overload candidate is viable.
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.
StandardConversionSequence FinalConversion
FinalConversion - For a conversion function (where Function is a CXXConversionDecl),...
unsigned getNumParams() const
unsigned ExplicitCallArguments
The number of call arguments that were explicitly provided, to be used while performing partial order...
unsigned char FailureKind
FailureKind - The reason why this candidate is not viable.
ConversionSequenceList Conversions
The conversion sequences used to convert the function arguments to the function parameters.
DeductionFailureInfo DeductionFailure
bool Best
Whether this candidate is the best viable function, or tied for being the best viable function.
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
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.
ReferenceConversions
The conversions that would be performed on an lvalue of type T2 when binding a reference of type T1 t...
Abstract class used to diagnose incomplete types.
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.
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.