39#include "llvm/ADT/DenseSet.h"
40#include "llvm/ADT/STLExtras.h"
41#include "llvm/ADT/STLForwardCompat.h"
42#include "llvm/ADT/SmallPtrSet.h"
43#include "llvm/ADT/SmallString.h"
44#include "llvm/ADT/SmallVector.h"
45#include "llvm/Support/Casting.h"
58 return P->hasAttr<PassObjectSizeAttr>();
79 if (HadMultipleCandidates)
90 CK_FunctionToPointerDecay);
94 bool InOverloadResolution,
97 bool AllowObjCWritebackConversion);
101 bool InOverloadResolution,
109 bool AllowObjCConversionOnExplicit);
169 return Rank[(
int)Kind];
175 static const char *
const Name[] = {
179 "Function-to-pointer",
180 "Function pointer conversion",
182 "Integral promotion",
183 "Floating point promotion",
185 "Integral conversion",
186 "Floating conversion",
187 "Complex conversion",
188 "Floating-integral conversion",
189 "Pointer conversion",
190 "Pointer-to-member conversion",
191 "Boolean conversion",
192 "Compatible-types conversion",
193 "Derived-to-base conversion",
195 "SVE Vector conversion",
196 "RVV Vector conversion",
198 "Complex-real conversion",
199 "Block Pointer conversion",
200 "Transparent Union Conversion",
201 "Writeback conversion",
202 "OpenCL Zero Event Conversion",
203 "OpenCL Zero Queue Conversion",
204 "C specific type conversion",
205 "Incompatible pointer conversion",
206 "Fixed point conversion",
207 "HLSL vector truncation",
208 "Non-decaying array conversion",
295 const Expr *Converted) {
298 if (
auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
305 while (
auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
306 switch (ICE->getCastKind()) {
308 case CK_IntegralCast:
309 case CK_IntegralToBoolean:
310 case CK_IntegralToFloating:
311 case CK_BooleanToSignedIntegral:
312 case CK_FloatingToIntegral:
313 case CK_FloatingToBoolean:
314 case CK_FloatingCast:
315 Converted = ICE->getSubExpr();
339 QualType &ConstantType,
bool IgnoreFloatToIntegralConversion)
const {
341 "narrowing check outside C++");
352 ToType = ET->getDecl()->getIntegerType();
358 goto FloatingIntegralConversion;
360 goto IntegralConversion;
371 FloatingIntegralConversion:
376 if (IgnoreFloatToIntegralConversion)
379 assert(
Initializer &&
"Unknown conversion expression");
385 if (std::optional<llvm::APSInt> IntConstantValue =
389 Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
390 llvm::APFloat::rmNearestTiesToEven);
392 llvm::APSInt ConvertedValue = *IntConstantValue;
394 Result.convertToInteger(ConvertedValue,
395 llvm::APFloat::rmTowardZero, &ignored);
397 if (*IntConstantValue != ConvertedValue) {
398 ConstantValue =
APValue(*IntConstantValue);
425 Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
428 ConstantValue = R.
Val;
429 assert(ConstantValue.
isFloat());
430 llvm::APFloat FloatVal = ConstantValue.
getFloat();
433 llvm::APFloat Converted = FloatVal;
434 llvm::APFloat::opStatus ConvertStatus =
436 llvm::APFloat::rmNearestTiesToEven, &ignored);
438 llvm::APFloat::rmNearestTiesToEven, &ignored);
440 if (FloatVal.isNaN() && Converted.isNaN() &&
441 !FloatVal.isSignaling() && !Converted.isSignaling()) {
447 if (!Converted.bitwiseIsEqual(FloatVal)) {
454 if (ConvertStatus & llvm::APFloat::opOverflow) {
471 IntegralConversion: {
475 const unsigned FromWidth = Ctx.
getIntWidth(FromType);
479 if (FromWidth > ToWidth ||
480 (FromWidth == ToWidth && FromSigned != ToSigned) ||
481 (FromSigned && !ToSigned)) {
489 std::optional<llvm::APSInt> OptInitializerValue;
490 if (!(OptInitializerValue =
Initializer->getIntegerConstantExpr(Ctx))) {
494 llvm::APSInt &InitializerValue = *OptInitializerValue;
495 bool Narrowing =
false;
496 if (FromWidth < ToWidth) {
499 if (InitializerValue.isSigned() && InitializerValue.isNegative())
504 InitializerValue = InitializerValue.extend(
505 InitializerValue.getBitWidth() + 1);
507 llvm::APSInt ConvertedValue = InitializerValue;
508 ConvertedValue = ConvertedValue.trunc(ToWidth);
509 ConvertedValue.setIsSigned(ToSigned);
510 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
511 ConvertedValue.setIsSigned(InitializerValue.isSigned());
513 if (ConvertedValue != InitializerValue)
518 ConstantValue =
APValue(InitializerValue);
534 ConstantValue = R.
Val;
535 assert(ConstantValue.
isFloat());
536 llvm::APFloat FloatVal = ConstantValue.
getFloat();
541 if (FloatVal.isNaN() && FloatVal.isSignaling()) {
557 raw_ostream &OS = llvm::errs();
558 bool PrintedSomething =
false;
561 PrintedSomething =
true;
565 if (PrintedSomething) {
571 OS <<
" (by copy constructor)";
573 OS <<
" (direct reference binding)";
575 OS <<
" (reference binding)";
577 PrintedSomething =
true;
581 if (PrintedSomething) {
585 PrintedSomething =
true;
588 if (!PrintedSomething) {
589 OS <<
"No conversions required";
596 raw_ostream &OS = llvm::errs();
604 OS <<
"aggregate initialization";
614 raw_ostream &OS = llvm::errs();
616 OS <<
"Worst list element conversion: ";
617 switch (ConversionKind) {
619 OS <<
"Standard conversion: ";
623 OS <<
"User-defined conversion: ";
627 OS <<
"Ellipsis conversion";
630 OS <<
"Ambiguous conversion";
633 OS <<
"Bad conversion";
658 struct DFIArguments {
664 struct DFIParamWithArguments : DFIArguments {
669 struct DFIDeducedMismatchArgs : DFIArguments {
671 unsigned CallArgIndex;
688 Result.Result =
static_cast<unsigned>(TDK);
689 Result.HasDiagnostic =
false;
708 auto *Saved =
new (Context) DFIDeducedMismatchArgs;
719 DFIArguments *Saved =
new (Context) DFIArguments;
731 DFIParamWithArguments *Saved =
new (Context) DFIParamWithArguments;
732 Saved->Param = Info.
Param;
745 Result.HasDiagnostic =
true;
750 CNSInfo *Saved =
new (Context) CNSInfo;
760 llvm_unreachable(
"not a deduction failure");
793 Diag->~PartialDiagnosticAt();
802 Diag->~PartialDiagnosticAt();
838 return TemplateParameter::getFromOpaqueValue(
Data);
843 return static_cast<DFIParamWithArguments*
>(
Data)->Param;
873 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->TemplateArgs;
879 return static_cast<CNSInfo*
>(
Data)->TemplateArgs;
911 return &
static_cast<DFIArguments*
>(
Data)->FirstArg;
943 return &
static_cast<DFIArguments*
>(
Data)->SecondArg;
958 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->CallArgIndex;
974 for (
unsigned I = 0; I <
X->getNumParams(); ++I)
978 if (
auto *FTX =
X->getDescribedFunctionTemplate()) {
983 FTY->getTemplateParameters()))
992 OverloadedOperatorKind::OO_EqualEqual);
1004 OverloadedOperatorKind::OO_ExclaimEqual);
1005 if (isa<CXXMethodDecl>(EqFD)) {
1022 auto *NotEqFD = Op->getAsFunction();
1023 if (
auto *UD = dyn_cast<UsingShadowDecl>(Op))
1024 NotEqFD = UD->getUnderlyingDecl()->getAsFunction();
1027 cast<Decl>(Op->getLexicalDeclContext())))
1037 return Op == OO_EqualEqual || Op == OO_Spaceship;
1043 if (!allowsReversed(Op))
1045 if (Op == OverloadedOperatorKind::OO_EqualEqual) {
1046 assert(OriginalArgs.size() == 2);
1048 S, OpLoc, OriginalArgs[1], FD))
1059void OverloadCandidateSet::destroyCandidates() {
1061 for (
auto &
C : i->Conversions)
1062 C.~ImplicitConversionSequence();
1064 i->DeductionFailure.Destroy();
1069 destroyCandidates();
1070 SlabAllocator.Reset();
1071 NumInlineBytesUsed = 0;
1078 class UnbridgedCastsSet {
1088 Entry entry = { &E, E };
1089 Entries.push_back(entry);
1095 i = Entries.begin(), e = Entries.end(); i != e; ++i)
1096 *i->Addr = i->Saved;
1110 UnbridgedCastsSet *unbridgedCasts =
nullptr) {
1114 if (placeholder->getKind() == BuiltinType::Overload)
return false;
1118 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
1120 unbridgedCasts->save(S, E);
1140 UnbridgedCastsSet &unbridged) {
1141 for (
unsigned i = 0, e = Args.size(); i != e; ++i)
1183 NamedDecl *&Match,
bool NewIsUsingDecl) {
1188 bool OldIsUsingDecl =
false;
1189 if (isa<UsingShadowDecl>(OldD)) {
1190 OldIsUsingDecl =
true;
1194 if (NewIsUsingDecl)
continue;
1196 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
1201 if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
1209 bool UseMemberUsingDeclRules =
1210 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
1214 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
1215 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
1216 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
1220 if (!isa<FunctionTemplateDecl>(OldD) &&
1221 !shouldLinkPossiblyHiddenDecl(*I, New))
1230 if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
1232 return Ovl_NonFunction;
1234 }
else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1238 }
else if (isa<TagDecl>(OldD)) {
1240 }
else if (
auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1247 if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1249 return Ovl_NonFunction;
1256 return Ovl_NonFunction;
1281 if (CheckFunctionTemplateSpecialization(New,
nullptr, TemplateSpecResult,
1284 return Ovl_Overload;
1291 return Ovl_Overload;
1296 bool UseMemberUsingDeclRules,
1297 bool ConsiderCudaAttrs,
1298 bool UseOverrideRules =
false) {
1315 if ((OldTemplate ==
nullptr) != (NewTemplate ==
nullptr))
1328 if (isa<FunctionNoProtoType>(OldQType.
getTypePtr()) ||
1329 isa<FunctionNoProtoType>(NewQType.
getTypePtr()))
1332 const auto *OldType = cast<FunctionProtoType>(OldQType);
1333 const auto *NewType = cast<FunctionProtoType>(NewQType);
1338 if (OldQType != NewQType && OldType->isVariadic() != NewType->isVariadic())
1353 OldDecl = OldTemplate;
1354 NewDecl = NewTemplate;
1372 bool ConstraintsInTemplateHead =
1383 if (UseMemberUsingDeclRules && ConstraintsInTemplateHead &&
1384 !SameTemplateParameterList)
1386 if (!UseMemberUsingDeclRules &&
1387 (!SameTemplateParameterList || !SameReturnType))
1391 const auto *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1392 const auto *NewMethod = dyn_cast<CXXMethodDecl>(New);
1394 int OldParamsOffset = 0;
1395 int NewParamsOffset = 0;
1413 !isa<CXXConstructorDecl>(NewMethod))
1419 auto BS =
Base.getNonReferenceType().getCanonicalType().split();
1420 BS.Quals = NormalizeQualifiers(OldMethod, BS.Quals);
1422 auto DS = D.getNonReferenceType().getCanonicalType().split();
1423 DS.Quals = NormalizeQualifiers(NewMethod, DS.Quals);
1425 if (BS.Quals != DS.Quals)
1428 if (OldMethod->isImplicitObjectMemberFunction() &&
1429 OldMethod->getParent() != NewMethod->getParent()) {
1442 if (
Base->isLValueReferenceType())
1444 return Base->isRValueReferenceType() == D->isRValueReferenceType();
1449 auto DiagnoseInconsistentRefQualifiers = [&]() {
1452 if (OldMethod->getRefQualifier() == NewMethod->getRefQualifier())
1454 if (OldMethod->isExplicitObjectMemberFunction() ||
1455 NewMethod->isExplicitObjectMemberFunction())
1457 if (!UseMemberUsingDeclRules && (OldMethod->getRefQualifier() ==
RQ_None ||
1458 NewMethod->getRefQualifier() ==
RQ_None)) {
1459 SemaRef.
Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1460 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1461 SemaRef.
Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1467 if (OldMethod && OldMethod->isExplicitObjectMemberFunction())
1469 if (NewMethod && NewMethod->isExplicitObjectMemberFunction())
1472 if (OldType->getNumParams() - OldParamsOffset !=
1473 NewType->getNumParams() - NewParamsOffset ||
1475 {OldType->param_type_begin() + OldParamsOffset,
1476 OldType->param_type_end()},
1477 {NewType->param_type_begin() + NewParamsOffset,
1478 NewType->param_type_end()},
1483 if (OldMethod && NewMethod && !OldMethod->isStatic() &&
1484 !OldMethod->isStatic()) {
1485 bool HaveCorrespondingObjectParameters = [&](
const CXXMethodDecl *Old,
1487 auto NewObjectType = New->getFunctionObjectParameterReferenceType();
1491 return F->getRefQualifier() ==
RQ_None &&
1492 !F->isExplicitObjectMemberFunction();
1495 if (IsImplicitWithNoRefQual(Old) != IsImplicitWithNoRefQual(New) &&
1496 CompareType(OldObjectType.getNonReferenceType(),
1497 NewObjectType.getNonReferenceType()))
1499 return CompareType(OldObjectType, NewObjectType);
1500 }(OldMethod, NewMethod);
1502 if (!HaveCorrespondingObjectParameters) {
1503 if (DiagnoseInconsistentRefQualifiers())
1508 if (!UseOverrideRules || (!NewMethod->isExplicitObjectMemberFunction() &&
1509 !OldMethod->isExplicitObjectMemberFunction()))
1514 if (!UseOverrideRules &&
1518 if ((NewRC !=
nullptr) != (OldRC !=
nullptr))
1525 if (NewMethod && OldMethod && OldMethod->isImplicitObjectMemberFunction() &&
1526 NewMethod->isImplicitObjectMemberFunction()) {
1527 if (DiagnoseInconsistentRefQualifiers())
1545 NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1546 if (NewI == NewE || OldI == OldE)
1548 llvm::FoldingSetNodeID NewID, OldID;
1550 OldI->getCond()->Profile(OldID, SemaRef.
Context,
true);
1555 if (SemaRef.
getLangOpts().CUDA && ConsiderCudaAttrs) {
1558 if (!isa<CXXDestructorDecl>(New)) {
1563 "Unexpected invalid target.");
1567 if (NewTarget != OldTarget)
1578 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs) {
1584 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs) {
1597 bool SuppressUserConversions,
1599 bool InOverloadResolution,
1601 bool AllowObjCWritebackConversion,
1602 bool AllowObjCConversionOnExplicit) {
1605 if (SuppressUserConversions) {
1616 Conversions, AllowExplicit,
1617 AllowObjCConversionOnExplicit)) {
1634 if (Constructor->isCopyConstructor() &&
1635 (FromCanon == ToCanon ||
1646 if (ToCanon != FromCanon)
1657 Cand != Conversions.
end(); ++Cand)
1700 bool SuppressUserConversions,
1702 bool InOverloadResolution,
1704 bool AllowObjCWritebackConversion,
1705 bool AllowObjCConversionOnExplicit) {
1708 ICS.
Standard, CStyle, AllowObjCWritebackConversion)){
1748 AllowExplicit, InOverloadResolution, CStyle,
1749 AllowObjCWritebackConversion,
1750 AllowObjCConversionOnExplicit);
1755 bool SuppressUserConversions,
1757 bool InOverloadResolution,
1759 bool AllowObjCWritebackConversion) {
1760 return ::TryImplicitConversion(*
this, From, ToType, SuppressUserConversions,
1761 AllowExplicit, InOverloadResolution, CStyle,
1762 AllowObjCWritebackConversion,
1773 bool AllowExplicit) {
1778 bool AllowObjCWritebackConversion
1779 = getLangOpts().ObjCAutoRefCount &&
1780 (Action == AA_Passing || Action == AA_Sending);
1781 if (getLangOpts().ObjC)
1785 *
this, From, ToType,
1787 AllowExplicit ? AllowedExplicit::All : AllowedExplicit::None,
1789 false, AllowObjCWritebackConversion,
1791 return PerformImplicitConversion(From, ToType, ICS, Action);
1812 if (TyClass != CanFrom->getTypeClass())
return false;
1813 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1814 if (TyClass == Type::Pointer) {
1817 }
else if (TyClass == Type::BlockPointer) {
1820 }
else if (TyClass == Type::MemberPointer) {
1824 if (ToMPT->getClass() != FromMPT->
getClass())
1826 CanTo = ToMPT->getPointeeType();
1832 TyClass = CanTo->getTypeClass();
1833 if (TyClass != CanFrom->getTypeClass())
return false;
1834 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1838 const auto *FromFn = cast<FunctionType>(CanFrom);
1841 const auto *ToFn = cast<FunctionType>(CanTo);
1844 bool Changed =
false;
1853 if (
const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1854 const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1855 if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1856 FromFn = cast<FunctionType>(
1867 bool CanUseToFPT, CanUseFromFPT;
1869 CanUseFromFPT, NewParamInfos) &&
1870 CanUseToFPT && !CanUseFromFPT) {
1873 NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1875 FromFPT->getParamTypes(), ExtInfo);
1884 assert(
QualType(FromFn, 0).isCanonical());
1885 if (
QualType(FromFn, 0) != CanTo)
return false;
1913 if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
1914 &ToSem == &llvm::APFloat::IEEEquad()) ||
1915 (&FromSem == &llvm::APFloat::IEEEquad() &&
1916 &ToSem == &llvm::APFloat::PPCDoubleDouble()))
1971 bool InOverloadResolution,
bool CStyle) {
1988 if (FromElts < ToElts)
1990 if (FromElts == ToElts)
2039 !ToType->
hasAttr(attr::ArmMveStrictPolymorphism))) {
2044 !InOverloadResolution && !CStyle) {
2046 << FromType << ToType;
2057 bool InOverloadResolution,
2070 bool InOverloadResolution,
2073 bool AllowObjCWritebackConversion) {
2120 if (Method && !Method->
isStatic() &&
2123 "Non-unary operator on non-static member address");
2124 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode()
2126 "Non-address-of operator on non-static member address");
2127 const Type *ClassType
2131 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode() ==
2133 "Non-address-of operator for overloaded function expression");
2152 FromType =
Atomic->getValueType();
2200 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
2220 bool IncompatibleObjC =
false;
2275 }
else if (AllowObjCWritebackConversion &&
2279 FromType, IncompatibleObjC)) {
2285 InOverloadResolution, FromType)) {
2289 From, InOverloadResolution, CStyle)) {
2299 S, From, ToType, InOverloadResolution, SCS, CStyle)) {
2335 bool ObjCLifetimeConversion;
2341 ObjCLifetimeConversion)) {
2360 CanonFrom = CanonTo;
2365 if (CanonFrom == CanonTo)
2370 if (S.
getLangOpts().CPlusPlus || !InOverloadResolution)
2414 bool InOverloadResolution,
2424 for (
const auto *it : UD->
fields()) {
2427 ToType = it->getType();
2457 return To->
getKind() == BuiltinType::Int;
2460 return To->
getKind() == BuiltinType::UInt;
2484 if (FromEnumType->getDecl()->isScoped())
2491 if (FromEnumType->getDecl()->isFixed()) {
2492 QualType Underlying = FromEnumType->getDecl()->getIntegerType();
2494 IsIntegralPromotion(
nullptr, Underlying, ToType);
2501 ToType, FromEnumType->getDecl()->getPromotionType());
2526 uint64_t FromSize = Context.
getTypeSize(FromType);
2535 for (
int Idx = 0; Idx < 6; ++Idx) {
2536 uint64_t ToSize = Context.
getTypeSize(PromoteTypes[Idx]);
2537 if (FromSize < ToSize ||
2538 (FromSize == ToSize &&
2539 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2564 std::optional<llvm::APSInt> BitWidth;
2567 MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
2568 llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
2572 if (*BitWidth < ToSize ||
2574 return To->
getKind() == BuiltinType::Int;
2580 return To->
getKind() == BuiltinType::UInt;
2611 if (FromBuiltin->getKind() == BuiltinType::Float &&
2612 ToBuiltin->getKind() == BuiltinType::Double)
2619 (FromBuiltin->getKind() == BuiltinType::Float ||
2620 FromBuiltin->getKind() == BuiltinType::Double) &&
2621 (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2622 ToBuiltin->getKind() == BuiltinType::Float128 ||
2623 ToBuiltin->getKind() == BuiltinType::Ibm128))
2628 if (getLangOpts().
HLSL && FromBuiltin->getKind() == BuiltinType::Half &&
2629 (ToBuiltin->getKind() == BuiltinType::Float ||
2630 ToBuiltin->getKind() == BuiltinType::Double))
2634 if (!getLangOpts().NativeHalfType &&
2635 FromBuiltin->getKind() == BuiltinType::Half &&
2636 ToBuiltin->getKind() == BuiltinType::Float)
2673 bool StripObjCLifetime =
false) {
2676 "Invalid similarly-qualified pointer type");
2687 if (StripObjCLifetime)
2698 if (isa<ObjCObjectPointerType>(ToType))
2707 if (isa<ObjCObjectPointerType>(ToType))
2713 bool InOverloadResolution,
2719 return !InOverloadResolution;
2743 bool InOverloadResolution,
2745 bool &IncompatibleObjC) {
2746 IncompatibleObjC =
false;
2747 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2754 ConvertedType = ToType;
2761 ConvertedType = ToType;
2768 ConvertedType = ToType;
2776 ConvertedType = ToType;
2786 ConvertedType = ToType;
2794 !getLangOpts().ObjCAutoRefCount) {
2824 if (getLangOpts().MSVCCompat && FromPointeeType->
isFunctionType() &&
2858 IsDerivedFrom(From->
getBeginLoc(), FromPointeeType, ToPointeeType)) {
2895 bool &IncompatibleObjC) {
2896 if (!getLangOpts().
ObjC)
2908 if (ToObjCPtr && FromObjCPtr) {
2919 if (getLangOpts().CPlusPlus && LHS && RHS &&
2921 FromObjCPtr->getPointeeType()))
2926 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2934 IncompatibleObjC =
true;
2938 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2950 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2978 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2979 IncompatibleObjC)) {
2981 IncompatibleObjC =
true;
2983 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2990 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2991 IncompatibleObjC)) {
2994 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
3006 if (FromFunctionType && ToFunctionType) {
3015 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
3016 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic() ||
3017 FromFunctionType->
getMethodQuals() != ToFunctionType->getMethodQuals())
3020 bool HasObjCConversion =
false;
3024 }
else if (isObjCPointerConversion(FromFunctionType->
getReturnType(),
3025 ToFunctionType->getReturnType(),
3026 ConvertedType, IncompatibleObjC)) {
3028 HasObjCConversion =
true;
3035 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
3036 ArgIdx != NumArgs; ++ArgIdx) {
3038 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3042 }
else if (isObjCPointerConversion(FromArgType, ToArgType,
3043 ConvertedType, IncompatibleObjC)) {
3045 HasObjCConversion =
true;
3052 if (HasObjCConversion) {
3056 IncompatibleObjC =
true;
3088 if (!FromFunctionType || !ToFunctionType)
3091 if (Context.
hasSameType(FromPointeeType, ToPointeeType))
3096 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
3097 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic())
3102 if (FromEInfo != ToEInfo)
3105 bool IncompatibleObjC =
false;
3107 ToFunctionType->getReturnType())) {
3111 QualType LHS = ToFunctionType->getReturnType();
3112 if ((!getLangOpts().CPlusPlus || !RHS->
isRecordType()) &&
3118 }
else if (isObjCPointerConversion(RHS, LHS,
3119 ConvertedType, IncompatibleObjC)) {
3120 if (IncompatibleObjC)
3129 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
3130 ArgIdx != NumArgs; ++ArgIdx) {
3131 IncompatibleObjC =
false;
3133 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3134 if (Context.
hasSameType(FromArgType, ToArgType)) {
3136 }
else if (isObjCPointerConversion(ToArgType, FromArgType,
3137 ConvertedType, IncompatibleObjC)) {
3138 if (IncompatibleObjC)
3147 bool CanUseToFPT, CanUseFromFPT;
3149 CanUseToFPT, CanUseFromFPT,
3153 ConvertedType = ToType;
3194 if (!Context.
hasSameType(FromMember->getClass(), ToMember->getClass())) {
3196 <<
QualType(FromMember->getClass(), 0);
3229 if (!FromFunction || !ToFunction) {
3234 if (FromFunction->
getNumParams() != ToFunction->getNumParams()) {
3242 if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
3244 << ToFunction->getParamType(ArgPos)
3251 ToFunction->getReturnType())) {
3257 if (FromFunction->
getMethodQuals() != ToFunction->getMethodQuals()) {
3267 cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
3287 assert(llvm::size(Old) == llvm::size(New) &&
3288 "Can't compare parameters of functions with different number of "
3291 for (
auto &&[Idx,
Type] : llvm::enumerate(Old)) {
3293 size_t J =
Reversed ? (llvm::size(New) - Idx - 1) : Idx;
3314 return FunctionParamTypesAreEqual(OldType->
param_types(),
3327 unsigned OldIgnore =
3329 unsigned NewIgnore =
3332 auto *OldPT = cast<FunctionProtoType>(OldFunction->
getFunctionType());
3333 auto *NewPT = cast<FunctionProtoType>(NewFunction->
getFunctionType());
3335 return FunctionParamTypesAreEqual(OldPT->param_types().slice(OldIgnore),
3336 NewPT->param_types().slice(NewIgnore),
3349 bool IgnoreBaseAccess,
3352 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
3356 if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->
isAnyPointerType() &&
3360 DiagRuntimeBehavior(From->
getExprLoc(), From,
3361 PDiag(diag::warn_impcast_bool_to_null_pointer)
3363 else if (!isUnevaluatedContext())
3372 if (FromPointeeType->
isRecordType() && ToPointeeType->isRecordType() &&
3376 unsigned InaccessibleID = 0;
3377 unsigned AmbiguousID = 0;
3379 InaccessibleID = diag::err_upcast_to_inaccessible_base;
3380 AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
3382 if (CheckDerivedToBaseConversion(
3383 FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
3385 &BasePath, IgnoreBaseAccess))
3389 Kind = CK_DerivedToBase;
3392 if (Diagnose && !IsCStyleOrFunctionalCast &&
3393 FromPointeeType->
isFunctionType() && ToPointeeType->isVoidType()) {
3394 assert(getLangOpts().MSVCCompat &&
3395 "this should only be possible with MSVCCompat!");
3407 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
3410 Kind = CK_BlockPointerToObjCPointerCast;
3412 Kind = CK_CPointerToObjCPointerCast;
3416 Kind = CK_AnyPointerToBlockPointerCast;
3422 Kind = CK_NullToPointer;
3434 bool InOverloadResolution,
3444 ConvertedType = ToType;
3459 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass)) {
3477 bool IgnoreBaseAccess) {
3484 "Expr must be null pointer constant!");
3485 Kind = CK_NullToMemberPointer;
3490 assert(ToPtrType &&
"No member pointer cast has a target type "
3491 "that is not a member pointer.");
3497 assert(FromClass->
isRecordType() &&
"Pointer into non-class.");
3498 assert(ToClass->
isRecordType() &&
"Pointer into non-class.");
3502 bool DerivationOkay =
3503 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass, Paths);
3504 assert(DerivationOkay &&
3505 "Should not have been called if derivation isn't OK.");
3506 (void)DerivationOkay;
3509 getUnqualifiedType())) {
3510 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3512 << 0 << FromClass << ToClass << PathDisplayStr << From->
getSourceRange();
3516 if (
const RecordType *VBase = Paths.getDetectedVirtual()) {
3518 << FromClass << ToClass <<
QualType(VBase, 0)
3523 if (!IgnoreBaseAccess)
3524 CheckBaseClassAccess(From->
getExprLoc(), FromClass, ToClass,
3526 diag::err_downcast_from_inaccessible_base);
3530 Kind = CK_BaseToDerivedMemberPointer;
3553 bool CStyle,
bool IsTopLevel,
3554 bool &PreviousToQualsIncludeConst,
3555 bool &ObjCLifetimeConversion) {
3567 ObjCLifetimeConversion =
true;
3603 !PreviousToQualsIncludeConst)
3621 PreviousToQualsIncludeConst =
3622 PreviousToQualsIncludeConst && ToQuals.
hasConst();
3635 bool CStyle,
bool &ObjCLifetimeConversion) {
3638 ObjCLifetimeConversion =
false;
3648 bool PreviousToQualsIncludeConst =
true;
3649 bool UnwrappedAnyPointer =
false;
3652 FromType, ToType, CStyle, !UnwrappedAnyPointer,
3653 PreviousToQualsIncludeConst, ObjCLifetimeConversion))
3655 UnwrappedAnyPointer =
true;
3672 bool InOverloadResolution,
3681 InOverloadResolution, InnerSCS,
3698 if (CtorType->getNumParams() > 0) {
3699 QualType FirstArg = CtorType->getParamType(0);
3711 bool AllowExplicit) {
3718 bool Usable = !Info.Constructor->isInvalidDecl() &&
3721 bool SuppressUserConversions =
false;
3722 if (Info.ConstructorTmpl)
3725 CandidateSet, SuppressUserConversions,
3730 CandidateSet, SuppressUserConversions,
3731 false, AllowExplicit);
3735 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3744 QualType ThisType = Constructor->getFunctionObjectParameterType();
3762 llvm_unreachable(
"Invalid OverloadResult!");
3784 bool AllowObjCConversionOnExplicit) {
3785 assert(AllowExplicit != AllowedExplicit::None ||
3786 !AllowObjCConversionOnExplicit);
3790 bool ConstructorsOnly =
false;
3806 ConstructorsOnly =
true;
3811 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3813 Expr **Args = &From;
3814 unsigned NumArgs = 1;
3815 bool ListInitializing =
false;
3816 if (
InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3819 S, From, ToType, ToRecordDecl, User, CandidateSet,
3820 AllowExplicit == AllowedExplicit::All);
3829 Args = InitList->getInits();
3830 NumArgs = InitList->getNumInits();
3831 ListInitializing =
true;
3839 bool Usable = !Info.Constructor->isInvalidDecl();
3840 if (!ListInitializing)
3841 Usable = Usable && Info.Constructor->isConvertingConstructor(
3844 bool SuppressUserConversions = !ConstructorsOnly;
3852 if (SuppressUserConversions && ListInitializing) {
3853 SuppressUserConversions =
3854 NumArgs == 1 && isa<InitListExpr>(Args[0]) &&
3858 if (Info.ConstructorTmpl)
3860 Info.ConstructorTmpl, Info.FoundDecl,
3862 CandidateSet, SuppressUserConversions,
3864 AllowExplicit == AllowedExplicit::All);
3870 SuppressUserConversions,
3872 AllowExplicit == AllowedExplicit::All);
3879 if (ConstructorsOnly || isa<InitListExpr>(From)) {
3882 }
else if (
const RecordType *FromRecordType =
3885 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3887 const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3888 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3892 if (isa<UsingShadowDecl>(D))
3893 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3897 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3900 Conv = cast<CXXConversionDecl>(D);
3904 ConvTemplate, FoundDecl, ActingContext, From, ToType,
3905 CandidateSet, AllowObjCConversionOnExplicit,
3906 AllowExplicit != AllowedExplicit::None);
3909 CandidateSet, AllowObjCConversionOnExplicit,
3910 AllowExplicit != AllowedExplicit::None);
3915 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3924 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3931 if (isa<InitListExpr>(From)) {
3935 if (Best->Conversions[0].isEllipsis())
3938 User.
Before = Best->Conversions[0].Standard;
3951 = dyn_cast<CXXConversionDecl>(Best->Function)) {
3958 User.
Before = Best->Conversions[0].Standard;
3973 User.
After = Best->FinalConversion;
3976 llvm_unreachable(
"Not a constructor or conversion function?");
3985 llvm_unreachable(
"Invalid OverloadResult!");
3995 CandidateSet, AllowedExplicit::None,
false);
4009 if (!RequireCompleteType(From->
getBeginLoc(), ToType,
4010 diag::err_typecheck_nonviable_condition_incomplete,
4017 *
this, From, Cands);
4043 if (!Conv1 || !Conv2)
4058 if (Block1 != Block2)
4071 if (Conv1FuncRet && Conv2FuncRet &&
4082 CallOpProto->isVariadic(),
false);
4084 CallOpProto->isVariadic(),
true);
4086 CallingConv PrefOrder[] = {DefaultFree, DefaultMember, CallOpCC};
4181 if (!ICS1.
isBad()) {
4182 bool StdInit1 =
false, StdInit2 =
false;
4189 if (StdInit1 != StdInit2)
4200 CAT2->getElementType())) {
4202 if (CAT1->getSize() != CAT2->getSize())
4204 return CAT1->getSize().ult(CAT2->getSize())
4326 return FixedEnumPromotion::None;
4330 return FixedEnumPromotion::None;
4333 if (!
Enum->isFixed())
4334 return FixedEnumPromotion::None;
4338 return FixedEnumPromotion::ToUnderlyingType;
4340 return FixedEnumPromotion::ToPromotedUnderlyingType;
4346 "Either both elements should be vectors or neither should.");
4348 LHS = VT->getElementType();
4351 RHS = VT->getElementType();
4387 else if (Rank2 < Rank1)
4410 if (FEP1 != FixedEnumPromotion::None && FEP2 != FixedEnumPromotion::None &&
4412 return FEP1 == FixedEnumPromotion::ToUnderlyingType
4422 bool SCS1ConvertsToVoid
4424 bool SCS2ConvertsToVoid
4426 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
4431 }
else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
4437 }
else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
4466 if (FromObjCPtr1 && FromObjCPtr2) {
4471 if (AssignLeft != AssignRight) {
4506 if (UnqualT1 == UnqualT2) {
4518 if (isa<ArrayType>(T1) && T1Quals)
4520 if (isa<ArrayType>(T2) && T2Quals)
4568 if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
4569 return SCS1IsCompatibleVectorConversion
4576 bool SCS1IsCompatibleSVEVectorConversion =
4578 bool SCS2IsCompatibleSVEVectorConversion =
4581 if (SCS1IsCompatibleSVEVectorConversion !=
4582 SCS2IsCompatibleSVEVectorConversion)
4583 return SCS1IsCompatibleSVEVectorConversion
4590 bool SCS1IsCompatibleRVVVectorConversion =
4592 bool SCS2IsCompatibleRVVVectorConversion =
4595 if (SCS1IsCompatibleRVVVectorConversion !=
4596 SCS2IsCompatibleRVVVectorConversion)
4597 return SCS1IsCompatibleRVVVectorConversion
4653 if (UnqualT1 == UnqualT2)
4671 bool ObjCLifetimeConversion;
4681 if (CanPick1 != CanPick2)
4735 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4743 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4760 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4767 bool FromAssignRight
4776 if (ToPtr1->isObjCIdType() &&
4777 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4779 if (ToPtr2->isObjCIdType() &&
4780 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4785 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4787 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4792 if (ToPtr1->isObjCClassType() &&
4793 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4795 if (ToPtr2->isObjCClassType() &&
4796 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4801 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4803 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4809 (ToAssignLeft != ToAssignRight)) {
4820 }
else if (IsSecondSame)
4829 (FromAssignLeft != FromAssignRight))
4843 const Type *FromPointeeType1 = FromMemPointer1->getClass();
4844 const Type *ToPointeeType1 = ToMemPointer1->
getClass();
4845 const Type *FromPointeeType2 = FromMemPointer2->
getClass();
4846 const Type *ToPointeeType2 = ToMemPointer2->
getClass();
4852 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4859 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4897 if (!
T.getQualifiers().hasUnaligned())
4917 "T1 must be the pointee type of the reference type");
4918 assert(!OrigT2->
isReferenceType() &&
"T2 cannot be a reference type");
4942 if (UnqualT1 == UnqualT2) {
4944 }
else if (isCompleteType(
Loc, OrigT2) &&
4945 IsDerivedFrom(
Loc, UnqualT2, UnqualT1))
4946 Conv |= ReferenceConversions::DerivedToBase;
4950 Conv |= ReferenceConversions::ObjC;
4952 IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2)) {
4953 Conv |= ReferenceConversions::Function;
4955 return Ref_Compatible;
4957 bool ConvertedReferent = Conv != 0;
4961 bool PreviousToQualsIncludeConst =
true;
4962 bool TopLevel =
true;
4968 Conv |= ReferenceConversions::Qualification;
4974 Conv |= ReferenceConversions::NestedQualification;
4982 bool ObjCLifetimeConversion =
false;
4984 PreviousToQualsIncludeConst,
4985 ObjCLifetimeConversion))
4991 if (ObjCLifetimeConversion)
4992 Conv |= ReferenceConversions::ObjCLifetime;
5011 bool AllowExplicit) {
5012 assert(T2->
isRecordType() &&
"Can only find conversions of record types.");
5017 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
5018 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5021 if (isa<UsingShadowDecl>(D))
5022 D = cast<UsingShadowDecl>(D)->getTargetDecl();
5025 = dyn_cast<FunctionTemplateDecl>(D);
5030 Conv = cast<CXXConversionDecl>(D);
5042 if (!ConvTemplate &&
5066 ConvTemplate, I.getPair(), ActingDC,
Init, DeclType, CandidateSet,
5067 false, AllowExplicit);
5070 Conv, I.getPair(), ActingDC,
Init, DeclType, CandidateSet,
5071 false, AllowExplicit);
5074 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5089 if (!Best->FinalConversion.DirectBinding)
5101 "Expected a direct reference binding!");
5107 Cand != CandidateSet.
end(); ++Cand)
5119 llvm_unreachable(
"Invalid OverloadResult!");
5127 bool SuppressUserConversions,
5128 bool AllowExplicit) {
5129 assert(DeclType->
isReferenceType() &&
"Reference init needs a reference");
5156 auto SetAsReferenceBinding = [&](
bool BindsDirectly) {
5161 ICS.
Standard.
Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
5163 : (RefConv & Sema::ReferenceConversions::ObjC)
5171 Sema::ReferenceConversions::NestedQualification)
5185 (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
5208 SetAsReferenceBinding(
true);
5257 SetAsReferenceBinding(S.
getLangOpts().CPlusPlus11 ||
5348 AllowedExplicit::None,
5373 if (isRValRef && LValRefType) {
5391 bool SuppressUserConversions,
5392 bool InOverloadResolution,
5393 bool AllowObjCWritebackConversion,
5394 bool AllowExplicit =
false);
5400 bool SuppressUserConversions,
5401 bool InOverloadResolution,
5402 bool AllowObjCWritebackConversion) {
5415 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
5417 InitTy = IAT->getElementType();
5443 if (From->
getNumInits() == 1 && !IsDesignatedInit) {
5449 SuppressUserConversions,
5450 InOverloadResolution,
5451 AllowObjCWritebackConversion);
5460 Result.Standard.setAsIdentityConversion();
5461 Result.Standard.setFromType(ToType);
5462 Result.Standard.setAllToTypes(ToType);
5487 bool IsUnbounded =
false;
5491 if (CT->getSize().ult(e)) {
5495 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5498 if (CT->getSize().ugt(e)) {
5504 S, &EmptyList, InitTy, SuppressUserConversions,
5505 InOverloadResolution, AllowObjCWritebackConversion);
5506 if (DfltElt.
isBad()) {
5510 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5515 assert(isa<IncompleteArrayType>(AT) &&
"Expected incomplete array");
5521 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5531 Result.Standard.setAsIdentityConversion();
5532 Result.Standard.setFromType(InitTy);
5533 Result.Standard.setAllToTypes(InitTy);
5534 for (
unsigned i = 0; i < e; ++i) {
5537 S,
Init, InitTy, SuppressUserConversions, InOverloadResolution,
5538 AllowObjCWritebackConversion);
5549 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5563 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5577 AllowedExplicit::None,
5578 InOverloadResolution,
false,
5579 AllowObjCWritebackConversion,
5598 Result.UserDefined.Before.setAsIdentityConversion();
5603 Result.UserDefined.After.setAsIdentityConversion();
5604 Result.UserDefined.After.setFromType(ToType);
5605 Result.UserDefined.After.setAllToTypes(ToType);
5606 Result.UserDefined.ConversionFunction =
nullptr;
5623 if (From->
getNumInits() == 1 && !IsDesignatedInit) {
5634 Init, ToType,
false, Found))
5644 SuppressUserConversions,
5652 InOverloadResolution,
5653 AllowObjCWritebackConversion);
5656 assert(!
Result.isEllipsis() &&
5657 "Sub-initialization cannot result in ellipsis conversion.");
5663 Result.UserDefined.After;
5684 if (NumInits == 1 && !isa<InitListExpr>(From->
getInit(0)))
5686 SuppressUserConversions,
5687 InOverloadResolution,
5688 AllowObjCWritebackConversion);
5691 else if (NumInits == 0) {
5693 Result.Standard.setAsIdentityConversion();
5694 Result.Standard.setFromType(ToType);
5695 Result.Standard.setAllToTypes(ToType);
5714 bool SuppressUserConversions,
5715 bool InOverloadResolution,
5716 bool AllowObjCWritebackConversion,
5717 bool AllowExplicit) {
5718 if (
InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
5720 InOverloadResolution,AllowObjCWritebackConversion);
5725 SuppressUserConversions, AllowExplicit);
5728 SuppressUserConversions,
5729 AllowedExplicit::None,
5730 InOverloadResolution,
5732 AllowObjCWritebackConversion,
5745 return !ICS.
isBad();
5754 const CXXRecordDecl *ActingContext,
bool InOverloadResolution =
false,
5756 bool SuppressUserConversion =
false) {
5764 assert(FromClassification.
isLValue());
5776 if (ExplicitParameterType.isNull())
5779 ValueKindFromClassification(FromClassification));
5781 S, &TmpExpr, ExplicitParameterType, SuppressUserConversion,
5799 if (isa<CXXDestructorDecl>(Method) || Method->
isStatic()) {
5836 FromType, ImplicitParamType);
5845 FromType, ImplicitParamType);
5860 FromType, ImplicitParamType);
5880 if (!FromClassification.
isRValue()) {
5920 FromRecordType = From->
getType();
5921 DestType = ImplicitParamRecordType;
5922 FromClassification = From->
Classify(Context);
5926 From = CreateMaterializeTemporaryExpr(FromRecordType, From,
5945 << Method->
getDeclName() << FromRecordType << (CVR - 1)
5956 bool IsRValueQualified =
5960 << IsRValueQualified;
5972 llvm_unreachable(
"Lists are not objects");
5975 return Diag(From->
getBeginLoc(), diag::err_member_function_call_bad_type)
5976 << ImplicitParamRecordType << FromRecordType
5982 PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
5985 From = FromRes.
get();
5994 CK = CK_AddressSpaceConversion;
5997 From = ImpCastExprToType(From, DestType, CK, From->
getValueKind()).get();
6019 AllowedExplicit::Conversions,
6034 return PerformImplicitConversion(From, Context.
BoolTy, ICS, AA_Converting);
6036 if (!DiagnoseMultipleUserDefinedConversion(From, Context.
BoolTy))
6100 llvm_unreachable(
"found a first conversion kind in Second");
6104 llvm_unreachable(
"found a third conversion kind in Second");
6110 llvm_unreachable(
"unknown conversion kind");
6122 "converted constant expression outside C++11");
6155 diag::err_typecheck_converted_constant_expression)
6161 llvm_unreachable(
"bad conversion in converted constant expression");
6167 diag::err_typecheck_converted_constant_expression_disallowed)
6173 diag::err_typecheck_converted_constant_expression_indirect)
6183 diag::err_reference_bind_to_bitfield_in_cce)
6193 "unexpected class type converted constant expr");
6196 T, cast<NonTypeTemplateParmDecl>(Dest)),
6213 bool ReturnPreNarrowingValue =
false;
6216 PreNarrowingType)) {
6229 PreNarrowingValue.
isInt()) {
6232 ReturnPreNarrowingValue =
true;
6244 << CCE << 0 << From->
getType() <<
T;
6247 if (!ReturnPreNarrowingValue)
6248 PreNarrowingValue = {};
6265 if (
Result.isInvalid() ||
Result.get()->isValueDependent()) {
6270 RequireInt, PreNarrowingValue);
6277 return ::BuildConvertedConstantExpression(*
this, From,
T, CCE, Dest,
6284 return ::CheckConvertedConstantExpression(*
this, From,
T,
Value, CCE,
false,
6289 llvm::APSInt &
Value,
6296 if (!R.isInvalid() && !R.get()->isValueDependent())
6307 const APValue &PreNarrowingValue) {
6317 Kind = ConstantExprKind::ClassTemplateArgument;
6319 Kind = ConstantExprKind::NonClassTemplateArgument;
6321 Kind = ConstantExprKind::Normal;
6324 (RequireInt && !Eval.
Val.
isInt())) {
6331 if (Notes.empty()) {
6334 if (
const auto *CE = dyn_cast<ConstantExpr>(E)) {
6338 "ConstantExpr has no value associated with it");
6344 Value = std::move(PreNarrowingValue);
6350 if (Notes.size() == 1 &&
6351 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
6352 Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
6353 }
else if (!Notes.empty() && Notes[0].second.getDiagID() ==
6354 diag::note_constexpr_invalid_template_arg) {
6355 Notes[0].second.setDiagID(diag::err_constexpr_invalid_template_arg);
6356 for (
unsigned I = 0; I < Notes.size(); ++I)
6357 Diag(Notes[I].first, Notes[I].second);
6361 for (
unsigned I = 0; I < Notes.size(); ++I)
6362 Diag(Notes[I].first, Notes[I].second);
6389 AllowedExplicit::Conversions,
6426 return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
6432 assert((isa<UnresolvedMemberExpr, MemberExpr>(MemExprE)) &&
6433 "expected a member expression");
6435 if (
const auto M = dyn_cast<UnresolvedMemberExpr>(MemExprE);
6436 M && !M->isImplicitAccess())
6437 Base = M->getBase();
6438 else if (
const auto M = dyn_cast<MemberExpr>(MemExprE);
6439 M && !M->isImplicitAccess())
6440 Base = M->getBase();
6479 "Method is not an explicit member function");
6480 assert(NewArgs.empty() &&
"NewArgs should be empty");
6481 NewArgs.reserve(Args.size() + 1);
6483 NewArgs.push_back(This);
6484 NewArgs.append(Args.begin(), Args.end());
6504 for (
unsigned I = 0, N = ViableConversions.
size(); I != N; ++I) {
6506 cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
6518 if (ExplicitConversions.
size() == 1 && !Converter.
Suppress) {
6526 std::string TypeStr;
6531 "static_cast<" + TypeStr +
">(")
6543 HadMultipleCandidates);
6550 From,
Result.get()->getType());
6576 HadMultipleCandidates);
6581 CK_UserDefinedConversion,
Result.get(),
6582 nullptr,
Result.get()->getValueKind(),
6601 for (
unsigned I = 0, N = ViableConversions.
size(); I != N; ++I) {
6605 if (isa<UsingShadowDecl>(D))
6606 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6610 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
6613 Conv = cast<CXXConversionDecl>(D);
6617 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
6621 ToType, CandidateSet,
6653 ExprResult result = CheckPlaceholderExpr(From);
6656 From = result.
get();
6660 ExprResult Converted = DefaultLvalueConversion(From);
6671 if (!RecordTy || !getLangOpts().CPlusPlus) {
6683 : Converter(Converter), From(From) {}
6688 } IncompleteDiagnoser(Converter, From);
6691 : RequireCompleteType(
Loc,
T, IncompleteDiagnoser))
6698 const auto &Conversions =
6699 cast<CXXRecordDecl>(RecordTy->
getDecl())->getVisibleConversionFunctions();
6701 bool HadMultipleCandidates =
6702 (std::distance(Conversions.begin(), Conversions.end()) > 1);
6706 bool HasUniqueTargetType =
true;
6709 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
6719 Conversion = cast<CXXConversionDecl>(D);
6721 assert((!ConvTemplate || getLangOpts().
CPlusPlus14) &&
6722 "Conversion operator templates are considered potentially "
6726 if (Converter.
match(CurToType) || ConvTemplate) {
6732 ExplicitConversions.
addDecl(I.getDecl(), I.getAccess());
6737 else if (HasUniqueTargetType &&
6739 HasUniqueTargetType =
false;
6741 ViableConversions.
addDecl(I.getDecl(), I.getAccess());
6759 HadMultipleCandidates,
6760 ExplicitConversions))
6766 if (!HasUniqueTargetType)
6785 HadMultipleCandidates, Found))
6794 HadMultipleCandidates,
6795 ExplicitConversions))
6803 switch (ViableConversions.
size()) {
6806 HadMultipleCandidates,
6807 ExplicitConversions))
6817 HadMultipleCandidates, Found))
6848 if (Proto->getNumParams() < 1)
6852 QualType ArgType = Proto->getParamType(0).getNonReferenceType();
6857 if (Proto->getNumParams() < 2)
6861 QualType ArgType = Proto->getParamType(1).getNonReferenceType();
6881 unsigned SeenAt = 0;
6883 bool HasDefault =
false;
6892 return HasDefault || SeenAt != 0;
6906 bool PartialOverloading,
bool AllowExplicit,
bool AllowExplicitConversions,
6911 assert(Proto &&
"Functions without a prototype cannot be overloaded");
6912 assert(!
Function->getDescribedFunctionTemplate() &&
6913 "Use AddTemplateOverloadCandidate for function templates");
6916 if (!isa<CXXConstructorDecl>(Method)) {
6926 CandidateSet, SuppressUserConversions,
6927 PartialOverloading, EarlyConversions, PO);
6941 if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
6942 Constructor->isMoveConstructor())
6962 CandidateSet.
addCandidate(Args.size(), EarlyConversions);
6977 Candidate.
Viable =
false;
6983 if (getLangOpts().CPlusPlusModules &&
Function->isInAnotherModuleUnit()) {
6990 if (
auto *SpecInfo =
Function->getTemplateSpecializationInfo())
6991 ND = SpecInfo->getTemplate();
6994 Candidate.
Viable =
false;
7001 Candidate.
Viable =
false;
7011 if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
7013 IsDerivedFrom(Args[0]->getBeginLoc(), Args[0]->getType(),
7015 Candidate.
Viable =
false;
7027 auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
7028 if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
7029 Constructor->getParamDecl(0)->getType()->isReferenceType()) {
7030 QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
7036 Candidate.
Viable =
false;
7045 Constructor->getMethodQualifiers().getAddressSpace(),
7047 Candidate.
Viable =
false;
7060 Candidate.
Viable =
false;
7070 unsigned MinRequiredArgs =
Function->getMinRequiredArguments();
7071 if (!AggregateCandidateDeduction && Args.size() < MinRequiredArgs &&
7072 !PartialOverloading) {
7074 Candidate.
Viable =
false;
7080 if (getLangOpts().
CUDA) {
7088 Candidate.
Viable =
false;
7094 if (
Function->getTrailingRequiresClause()) {
7096 if (CheckFunctionConstraints(
Function, Satisfaction, {},
7099 Candidate.
Viable =
false;
7107 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7110 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7113 }
else if (ArgIdx < NumParams) {
7120 *
this, Args[ArgIdx], ParamType, SuppressUserConversions,
7123 getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
7125 Candidate.
Viable =
false;
7137 if (EnableIfAttr *FailedAttr =
7139 Candidate.
Viable =
false;
7149 if (Methods.size() <= 1)
7152 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7160 if (Args.size() < NumNamedArgs)
7163 for (
unsigned i = 0; i < NumNamedArgs; i++) {
7165 if (Args[i]->isTypeDependent()) {
7171 Expr *argExpr = Args[i];
7172 assert(argExpr &&
"SelectBestMethod(): missing expression");
7177 !param->
hasAttr<CFConsumedAttr>())
7178 argExpr =
ObjC().stripARCUnbridgedCast(argExpr);
7191 getLangOpts().ObjCAutoRefCount,
7195 if (ConversionState.
isBad() ||
7205 for (
unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
7206 if (Args[i]->isTypeDependent()) {
7210 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
7219 if (Args.size() != NumNamedArgs)
7221 else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
7224 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7225 QualType ReturnT = Methods[
b]->getReturnType();
7244 assert(!isa<CXXConstructorDecl>(Method) &&
7245 "Shouldn't have `this` for ctors!");
7246 assert(!Method->
isStatic() &&
"Shouldn't have `this` for static methods!");
7248 ThisArg,
nullptr, Method, Method);
7251 ConvertedThis = R.
get();
7253 if (
auto *MD = dyn_cast<CXXMethodDecl>(
Function)) {
7255 assert((MissingImplicitThis || MD->isStatic() ||
7256 isa<CXXConstructorDecl>(MD)) &&
7257 "Expected `this` for non-ctor instance methods");
7259 ConvertedThis =
nullptr;
7264 unsigned ArgSizeNoVarargs = std::min(
Function->param_size(), Args.size());
7267 for (
unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
7276 ConvertedArgs.push_back(R.
get());
7284 for (
unsigned i = Args.size(), e =
Function->getNumParams(); i != e; ++i) {
7286 if (!
P->hasDefaultArg())
7291 ConvertedArgs.push_back(R.
get());
7303 bool MissingImplicitThis) {
7304 auto EnableIfAttrs =
Function->specific_attrs<EnableIfAttr>();
7305 if (EnableIfAttrs.begin() == EnableIfAttrs.end())
7311 Expr *DiscardedThis;
7313 *
this,
Function,
nullptr, CallLoc, Args, Trap,
7314 true, DiscardedThis, ConvertedArgs))
7315 return *EnableIfAttrs.begin();
7317 for (
auto *EIA : EnableIfAttrs) {
7321 if (EIA->getCond()->isValueDependent() ||
7322 !EIA->getCond()->EvaluateWithSubstitution(
7326 if (!
Result.isInt() || !
Result.getInt().getBoolValue())
7332template <
typename CheckFn>
7335 CheckFn &&IsSuccessful) {
7338 if (ArgDependent == DIA->getArgDependent())
7339 Attrs.push_back(DIA);
7346 auto WarningBegin = std::stable_partition(
7347 Attrs.begin(), Attrs.end(),
7348 [](
const DiagnoseIfAttr *DIA) { return DIA->isError(); });
7352 auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
7354 if (ErrAttr != WarningBegin) {
7355 const DiagnoseIfAttr *DIA = *ErrAttr;
7356 S.
Diag(
Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
7357 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7358 << DIA->getParent() << DIA->getCond()->getSourceRange();
7362 for (
const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
7363 if (IsSuccessful(DIA)) {
7364 S.
Diag(
Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
7365 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7366 << DIA->getParent() << DIA->getCond()->getSourceRange();
7373 const Expr *ThisArg,
7378 [&](
const DiagnoseIfAttr *DIA) {
7383 if (!DIA->getCond()->EvaluateWithSubstitution(
7384 Result, Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
7386 return Result.isInt() &&
Result.getInt().getBoolValue();
7393 *
this, ND,
false,
Loc,
7394 [&](
const DiagnoseIfAttr *DIA) {
7407 bool SuppressUserConversions,
7408 bool PartialOverloading,
7409 bool FirstArgumentIsBase) {
7418 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
7421 if (Args.size() > 0) {
7422 if (
Expr *E = Args[0]) {
7430 ObjectClassification = E->
Classify(Context);
7432 FunctionArgs = Args.slice(1);
7435 AddMethodTemplateCandidate(
7436 FunTmpl, F.getPair(),
7438 ExplicitTemplateArgs, ObjectType, ObjectClassification,
7439 FunctionArgs, CandidateSet, SuppressUserConversions,
7440 PartialOverloading);
7442 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
7443 cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
7444 ObjectClassification, FunctionArgs, CandidateSet,
7445 SuppressUserConversions, PartialOverloading);
7452 if (Args.size() > 0 &&
7453 (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
7454 !isa<CXXConstructorDecl>(FD)))) {
7455 assert(cast<CXXMethodDecl>(FD)->isStatic());
7456 FunctionArgs = Args.slice(1);
7459 AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
7460 ExplicitTemplateArgs, FunctionArgs,
7461 CandidateSet, SuppressUserConversions,
7462 PartialOverloading);
7464 AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet,
7465 SuppressUserConversions, PartialOverloading);
7477 bool SuppressUserConversions,
7482 if (isa<UsingShadowDecl>(
Decl))
7483 Decl = cast<UsingShadowDecl>(
Decl)->getTargetDecl();
7486 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
7487 "Expected a member function template");
7488 AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
7489 nullptr, ObjectType,
7490 ObjectClassification, Args, CandidateSet,
7491 SuppressUserConversions,
false, PO);
7493 AddMethodCandidate(cast<CXXMethodDecl>(
Decl), FoundDecl, ActingContext,
7494 ObjectType, ObjectClassification, Args, CandidateSet,
7495 SuppressUserConversions,
false, std::nullopt, PO);
7512 bool SuppressUserConversions,
7513 bool PartialOverloading,
7518 assert(Proto &&
"Methods without a prototype cannot be overloaded");
7519 assert(!isa<CXXConstructorDecl>(Method) &&
7520 "Use AddOverloadCandidate for constructors");
7538 CandidateSet.
addCandidate(Args.size() + 1, EarlyConversions);
7556 Candidate.
Viable =
false;
7567 if (Args.size() < MinRequiredArgs && !PartialOverloading) {
7569 Candidate.
Viable =
false;
7589 Candidate.
Conversions[FirstConvIdx].setStaticObjectArgument();
7594 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7595 Method, ActingContext,
true);
7596 if (Candidate.
Conversions[FirstConvIdx].isBad()) {
7597 Candidate.
Viable =
false;
7604 if (getLangOpts().
CUDA)
7605 if (!
CUDA().IsAllowedCall(getCurFunctionDecl(
true),
7607 Candidate.
Viable =
false;
7614 if (CheckFunctionConstraints(Method, Satisfaction, {},
7617 Candidate.
Viable =
false;
7625 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7628 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7631 }
else if (ArgIdx < NumParams) {
7639 SuppressUserConversions,
7642 getLangOpts().ObjCAutoRefCount);
7644 Candidate.
Viable =
false;
7656 if (EnableIfAttr *FailedAttr =
7657 CheckEnableIf(Method, CandidateSet.
getLocation(), Args,
true)) {
7658 Candidate.
Viable =
false;
7665 Candidate.
Viable =
false;
7697 PartialOverloading,
false, ObjectType,
7698 ObjectClassification,
7700 return CheckNonDependentConversions(
7701 MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
7702 SuppressUserConversions, ActingContext, ObjectType,
7703 ObjectClassification, PO);
7707 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7710 Candidate.
Viable =
false;
7715 cast<CXXMethodDecl>(Candidate.
Function)->isStatic() ||
7730 assert(
Specialization &&
"Missing member function template specialization?");
7732 "Specialization is not a member function?");
7733 AddMethodCandidate(cast<CXXMethodDecl>(
Specialization), FoundDecl,
7734 ActingContext, ObjectType, ObjectClassification, Args,
7735 CandidateSet, SuppressUserConversions, PartialOverloading,
7752 bool PartialOverloading,
bool AllowExplicit,
ADLCallKind IsADLCandidate,
7764 Candidate.
Viable =
false;
7783 FunctionTemplate, ExplicitTemplateArgs, Args,
Specialization, Info,
7784 PartialOverloading, AggregateCandidateDeduction,
7788 return CheckNonDependentConversions(
7789 FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions,
7790 SuppressUserConversions,
nullptr,
QualType(), {}, PO);
7794 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7797 Candidate.
Viable =
false;
7805 isa<CXXMethodDecl>(Candidate.
Function) &&
7806 !isa<CXXConstructorDecl>(Candidate.
Function);
7820 assert(
Specialization &&
"Missing function template specialization?");
7821 AddOverloadCandidate(
7822 Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
7823 PartialOverloading, AllowExplicit,
7824 false, IsADLCandidate, Conversions, PO,
7840 const bool AllowExplicit =
false;
7843 auto *Method = dyn_cast<CXXMethodDecl>(FD);
7844 bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
7845 unsigned ThisConversions = HasThisConversion ? 1 : 0;
7857 if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
7860 if (!FD->hasCXXExplicitFunctionObjectParameter() ||
7861 !ParamTypes[0]->isDependentType()) {
7863 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7864 Method, ActingContext,
true,
7865 FD->hasCXXExplicitFunctionObjectParameter() ? ParamTypes[0]
7867 if (Conversions[ConvIdx].isBad())
7875 for (
unsigned I = 0, N = std::min(ParamTypes.size() - Offset, Args.size());
7877 QualType ParamType = ParamTypes[I + Offset];
7881 ConvIdx = Args.size() - 1 - I;
7882 assert(Args.size() + ThisConversions == 2 &&
7883 "number of args (including 'this') must be exactly 2 for "
7887 assert(!HasThisConversion || (ConvIdx == 0 && I == 0));
7890 ConvIdx = ThisConversions + I;
7892 Conversions[ConvIdx]
7894 SuppressUserConversions,
7897 getLangOpts().ObjCAutoRefCount,
7899 if (Conversions[ConvIdx].isBad())
7921 bool AllowObjCPointerConversion) {
7929 bool ObjCLifetimeConversion;
7931 ObjCLifetimeConversion))
7936 if (!AllowObjCPointerConversion)
7940 bool IncompatibleObjC =
false;
7956 bool AllowExplicit,
bool AllowResultConversion) {
7958 "Conversion function templates use AddTemplateConversionCandidate");
7966 if (DeduceReturnType(Conversion, From->
getExprLoc()))
7973 if (!AllowResultConversion &&
7985 AllowObjCConversionOnExplicit))
8007 if (!AllowExplicit && Conversion->
isExplicit()) {
8008 Candidate.
Viable =
false;
8023 const auto *ConversionContext =
8032 From->
Classify(Context), Conversion, ConversionContext,
8037 Candidate.
Viable =
false;
8044 if (CheckFunctionConstraints(Conversion, Satisfaction) ||
8046 Candidate.
Viable =
false;
8058 if (FromCanon == ToCanon ||
8059 IsDerivedFrom(CandidateSet.
getLocation(), FromCanon, ToCanon)) {
8060 Candidate.
Viable =
false;
8077 CK_FunctionToPointerDecay, &ConversionRef,
8081 if (!isCompleteType(From->
getBeginLoc(), ConversionType)) {
8082 Candidate.
Viable =
false;
8096 Buffer, &ConversionFn, CallResultType, VK, From->
getBeginLoc());
8114 Candidate.
Viable =
false;
8126 Candidate.
Viable =
false;
8133 Candidate.
Viable =
false;
8139 "Can only end up with a standard conversion sequence or failure");
8142 if (EnableIfAttr *FailedAttr =
8143 CheckEnableIf(Conversion, CandidateSet.
getLocation(), std::nullopt)) {
8144 Candidate.
Viable =
false;
8151 Candidate.
Viable =
false;
8165 bool AllowExplicit,
bool AllowResultConversion) {
8167 "Only conversion function templates permitted here");
8179 Candidate.
Viable =
false;
8190 FunctionTemplate, ObjectType, ObjectClassification, ToType,
8196 Candidate.
Viable =
false;
8208 assert(
Specialization &&
"Missing function template specialization?");
8209 AddConversionCandidate(
Specialization, FoundDecl, ActingDC, From, ToType,
8210 CandidateSet, AllowObjCConversionOnExplicit,
8211 AllowExplicit, AllowResultConversion);
8252 *
this, CandidateSet.
getLocation(), Object->getType(),
8253 Object->Classify(Context), Conversion, ActingContext);
8256 if (ObjectInit.
isBad()) {
8257 Candidate.
Viable =
false;
8268 Candidate.
Conversions[0].UserDefined.EllipsisConversion =
false;
8269 Candidate.
Conversions[0].UserDefined.HadMultipleCandidates =
false;
8270 Candidate.
Conversions[0].UserDefined.ConversionFunction = Conversion;
8271 Candidate.
Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
8274 Candidate.
Conversions[0].UserDefined.After.setAsIdentityConversion();
8282 if (Args.size() > NumParams && !Proto->
isVariadic()) {
8283 Candidate.
Viable =
false;
8290 if (Args.size() < NumParams) {
8292 Candidate.
Viable =
false;
8299 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8300 if (ArgIdx < NumParams) {
8311 getLangOpts().ObjCAutoRefCount);
8313 Candidate.
Viable =
false;
8327 if (CheckFunctionConstraints(Conversion, Satisfaction, {},
8330 Candidate.
Viable =
false;
8336 if (EnableIfAttr *FailedAttr =
8337 CheckEnableIf(Conversion, CandidateSet.
getLocation(), std::nullopt)) {
8338 Candidate.
Viable =
false;
8363 assert(!isa<CXXMethodDecl>(FD) &&
8364 "unqualified operator lookup found a member function");
8367 AddTemplateOverloadCandidate(FunTmpl, F.getPair(), ExplicitTemplateArgs,
8368 FunctionArgs, CandidateSet);
8370 AddTemplateOverloadCandidate(
8371 FunTmpl, F.getPair(), ExplicitTemplateArgs,
8372 {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
false,
false,
8375 if (ExplicitTemplateArgs)
8377 AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet);
8379 AddOverloadCandidate(
8380 FD, F.getPair(), {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
8381 false,
false,
true,
false, ADLCallKind::NotADL, std::nullopt,
8418 if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
8421 if (!T1Rec->getDecl()->getDefinition())
8424 LookupResult Operators(*
this, OpName, OpLoc, LookupOrdinaryName);
8425 LookupQualifiedName(Operators, T1Rec->getDecl());
8429 OperEnd = Operators.
end();
8430 Oper != OperEnd; ++Oper) {
8431 if (Oper->getAsFunction() &&
8434 *
this, {Args[1], Args[0]}, Oper->getAsFunction()))
8436 AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
8437 Args[0]->Classify(Context), Args.slice(1),
8438 CandidateSet,
false, PO);
8453 bool IsAssignmentOperator,
8454 unsigned NumContextualBoolArguments) {
8471 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8484 if (ArgIdx < NumContextualBoolArguments) {
8485 assert(ParamTys[ArgIdx] == Context.
BoolTy &&
8486 "Contextual conversion to bool requires bool type");
8492 ArgIdx == 0 && IsAssignmentOperator,
8495 getLangOpts().ObjCAutoRefCount);
8498 Candidate.
Viable =
false;
8511class BuiltinCandidateTypeSet {
8517 TypeSet PointerTypes;
8521 TypeSet MemberPointerTypes;
8525 TypeSet EnumerationTypes;
8529 TypeSet VectorTypes;
8533 TypeSet MatrixTypes;
8536 TypeSet BitIntTypes;
8539 bool HasNonRecordTypes;
8543 bool HasArithmeticOrEnumeralTypes;
8547 bool HasNullPtrType;
8556 bool AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8558 bool AddMemberPointerWithMoreQualifiedTypeVariants(
QualType Ty);
8562 typedef TypeSet::iterator iterator;
8564 BuiltinCandidateTypeSet(
Sema &SemaRef)
8565 : HasNonRecordTypes(
false),
8566 HasArithmeticOrEnumeralTypes(
false),
8567 HasNullPtrType(
false),
8569 Context(SemaRef.Context) { }
8571 void AddTypesConvertedFrom(
QualType Ty,
8573 bool AllowUserConversions,
8574 bool AllowExplicitConversions,
8575 const Qualifiers &VisibleTypeConversionsQuals);
8577 llvm::iterator_range<iterator> pointer_types() {
return PointerTypes; }
8578 llvm::iterator_range<iterator> member_pointer_types() {
8579 return MemberPointerTypes;
8581 llvm::iterator_range<iterator> enumeration_types() {
8582 return EnumerationTypes;
8584 llvm::iterator_range<iterator> vector_types() {
return VectorTypes; }
8585 llvm::iterator_range<iterator> matrix_types() {
return MatrixTypes; }
8586 llvm::iterator_range<iterator> bitint_types() {
return BitIntTypes; }
8588 bool containsMatrixType(
QualType Ty)
const {
return MatrixTypes.count(Ty); }
8589 bool hasNonRecordTypes() {
return HasNonRecordTypes; }
8590 bool hasArithmeticOrEnumeralTypes() {
return HasArithmeticOrEnumeralTypes; }
8591 bool hasNullPtrType()
const {
return HasNullPtrType; }
8606BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8610 if (!PointerTypes.insert(Ty))
8615 bool buildObjCPtr =
false;
8619 buildObjCPtr =
true;
8631 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
8637 if ((CVR | BaseCVR) != CVR)
continue;
8659 PointerTypes.insert(QPointerTy);
8675BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
8678 if (!MemberPointerTypes.insert(Ty))
8682 assert(PointerTy &&
"type was not a member pointer type!");
8697 if ((CVR | BaseCVR) != CVR)
continue;
8700 MemberPointerTypes.insert(
8716BuiltinCandidateTypeSet::AddTypesConvertedFrom(
QualType Ty,
8718 bool AllowUserConversions,
8719 bool AllowExplicitConversions,
8731 Ty = SemaRef.Context.getArrayDecayedType(Ty);
8738 HasNonRecordTypes = HasNonRecordTypes || !TyRec;
8741 HasArithmeticOrEnumeralTypes =
8745 PointerTypes.insert(Ty);
8749 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
8753 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
8756 HasArithmeticOrEnumeralTypes =
true;
8757 EnumerationTypes.insert(Ty);
8759 HasArithmeticOrEnumeralTypes =
true;
8760 BitIntTypes.insert(Ty);
8764 HasArithmeticOrEnumeralTypes =
true;
8765 VectorTypes.insert(Ty);
8769 HasArithmeticOrEnumeralTypes =
true;
8770 MatrixTypes.insert(Ty);
8772 HasNullPtrType =
true;
8773 }
else if (AllowUserConversions && TyRec) {
8775 if (!SemaRef.isCompleteType(Loc, Ty))
8780 if (isa<UsingShadowDecl>(D))
8781 D = cast<UsingShadowDecl>(D)->getTargetDecl();
8785 if (isa<FunctionTemplateDecl>(D))
8789 if (AllowExplicitConversions || !Conv->
isExplicit()) {
8852 if (isa<UsingShadowDecl>(D))
8853 D = cast<UsingShadowDecl>(D)->getTargetDecl();
8887 if (Available.hasAtomic()) {
8888 Available.removeAtomic();
8895 if (Available.hasVolatile()) {
8896 Available.removeVolatile();
8930class BuiltinOperatorOverloadBuilder {
8935 bool HasArithmeticOrEnumeralCandidateType;
8939 static constexpr int ArithmeticTypesCap = 26;
8945 unsigned FirstIntegralType,
8947 unsigned FirstPromotedIntegralType,
8948 LastPromotedIntegralType;
8949 unsigned FirstPromotedArithmeticType,
8950 LastPromotedArithmeticType;
8951 unsigned NumArithmeticTypes;
8953 void InitArithmeticTypes() {
8955 FirstPromotedArithmeticType = 0;
8965 FirstIntegralType = ArithmeticTypes.size();
8966 FirstPromotedIntegralType = ArithmeticTypes.size();
8989 llvm::for_each(CandidateTypes, [&BitIntCandidates](
8990 BuiltinCandidateTypeSet &Candidate) {
8991 for (
QualType BitTy : Candidate.bitint_types())
8994 llvm::move(BitIntCandidates, std::back_inserter(ArithmeticTypes));
8995 LastPromotedIntegralType = ArithmeticTypes.size();
8996 LastPromotedArithmeticType = ArithmeticTypes.size();
9010 LastIntegralType = ArithmeticTypes.size();
9011 NumArithmeticTypes = ArithmeticTypes.size();
9018 assert(ArithmeticTypes.size() - BitIntCandidates.size() <=
9019 ArithmeticTypesCap &&
9020 "Enough inline storage for all arithmetic types.");
9025 void addPlusPlusMinusMinusStyleOverloads(
QualType CandidateTy,
9074 BuiltinOperatorOverloadBuilder(
9077 bool HasArithmeticOrEnumeralCandidateType,
9081 VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
9082 HasArithmeticOrEnumeralCandidateType(
9083 HasArithmeticOrEnumeralCandidateType),
9084 CandidateTypes(CandidateTypes),
9085 CandidateSet(CandidateSet) {
9087 InitArithmeticTypes();
9110 if (!HasArithmeticOrEnumeralCandidateType)
9113 for (
unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
9114 const auto TypeOfT = ArithmeticTypes[Arith];
9116 if (Op == OO_MinusMinus)
9118 if (Op == OO_PlusPlus && S.
getLangOpts().CPlusPlus17)
9121 addPlusPlusMinusMinusStyleOverloads(
9138 void addPlusPlusMinusMinusPointerOverloads() {
9139 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9141 if (!PtrTy->getPointeeType()->isObjectType())
9144 addPlusPlusMinusMinusStyleOverloads(
9146 (!PtrTy.isVolatileQualified() &&
9148 (!PtrTy.isRestrictQualified() &&
9163 void addUnaryStarPointerOverloads() {
9164 for (
QualType ParamTy : CandidateTypes[0].pointer_types()) {
9170 if (Proto->getMethodQuals() || Proto->getRefQualifier())
9183 void addUnaryPlusOrMinusArithmeticOverloads() {
9184 if (!HasArithmeticOrEnumeralCandidateType)
9187 for (
unsigned Arith = FirstPromotedArithmeticType;
9188 Arith < LastPromotedArithmeticType; ++Arith) {
9189 QualType ArithTy = ArithmeticTypes[Arith];
9194 for (
QualType VecTy : CandidateTypes[0].vector_types())
9203 void addUnaryPlusPointerOverloads() {
9204 for (
QualType ParamTy : CandidateTypes[0].pointer_types())
9213 void addUnaryTildePromotedIntegralOverloads() {
9214 if (!HasArithmeticOrEnumeralCandidateType)
9217 for (
unsigned Int = FirstPromotedIntegralType;
9218 Int < LastPromotedIntegralType; ++
Int) {
9224 for (
QualType VecTy : CandidateTypes[0].vector_types())
9234 void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
9238 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9239 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9244 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9248 if (CandidateTypes[ArgIdx].hasNullPtrType()) {
9250 if (AddedTypes.insert(NullPtrTy).second) {
9251 QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
9270 void addGenericBinaryPointerOrEnumeralOverloads(
bool IsSpaceship) {
9284 UserDefinedBinaryOperators;
9286 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9287 if (!CandidateTypes[ArgIdx].enumeration_types().empty()) {
9289 CEnd = CandidateSet.
end();
9291 if (!
C->Viable || !
C->Function ||
C->Function->getNumParams() != 2)
9294 if (
C->Function->isFunctionTemplateSpecialization())
9303 .getUnqualifiedType();
9306 .getUnqualifiedType();
9314 UserDefinedBinaryOperators.insert(
9324 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9325 for (
QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9329 if (IsSpaceship && PtrTy->isFunctionPointerType())
9332 QualType ParamTypes[2] = {PtrTy, PtrTy};
9335 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9340 if (!AddedTypes.insert(CanonType).second ||
9341 UserDefinedBinaryOperators.count(std::make_pair(CanonType,
9344 QualType ParamTypes[2] = {EnumTy, EnumTy};
9371 for (
int Arg = 0; Arg < 2; ++Arg) {
9372 QualType AsymmetricParamTypes[2] = {
9376 for (
QualType PtrTy : CandidateTypes[Arg].pointer_types()) {
9381 AsymmetricParamTypes[Arg] = PtrTy;
9382 if (Arg == 0 || Op == OO_Plus) {
9387 if (Op == OO_Minus) {
9392 QualType ParamTypes[2] = {PtrTy, PtrTy};
9428 void addGenericBinaryArithmeticOverloads() {
9429 if (!HasArithmeticOrEnumeralCandidateType)
9432 for (
unsigned Left = FirstPromotedArithmeticType;
9433 Left < LastPromotedArithmeticType; ++Left) {
9434 for (
unsigned Right = FirstPromotedArithmeticType;
9435 Right < LastPromotedArithmeticType; ++Right) {
9436 QualType LandR[2] = { ArithmeticTypes[Left],
9437 ArithmeticTypes[Right] };
9444 for (
QualType Vec1Ty : CandidateTypes[0].vector_types())
9445 for (
QualType Vec2Ty : CandidateTypes[1].vector_types()) {
9446 QualType LandR[2] = {Vec1Ty, Vec2Ty};
9456 void addMatrixBinaryArithmeticOverloads() {
9457 if (!HasArithmeticOrEnumeralCandidateType)
9460 for (
QualType M1 : CandidateTypes[0].matrix_types()) {
9461 AddCandidate(M1, cast<MatrixType>(M1)->getElementType());
9462 AddCandidate(M1, M1);
9465 for (
QualType M2 : CandidateTypes[1].matrix_types()) {
9466 AddCandidate(cast<MatrixType>(M2)->getElementType(), M2);
9467 if (!CandidateTypes[0].containsMatrixType(M2))
9468 AddCandidate(M2, M2);
9503 void addThreeWayArithmeticOverloads() {
9504 addGenericBinaryArithmeticOverloads();
9521 void addBinaryBitwiseArithmeticOverloads() {
9522 if (!HasArithmeticOrEnumeralCandidateType)
9525 for (
unsigned Left = FirstPromotedIntegralType;
9526 Left < LastPromotedIntegralType; ++Left) {
9527 for (
unsigned Right = FirstPromotedIntegralType;
9528 Right < LastPromotedIntegralType; ++Right) {
9529 QualType LandR[2] = { ArithmeticTypes[Left],
9530 ArithmeticTypes[Right] };
9543 void addAssignmentMemberPointerOrEnumeralOverloads() {
9547 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9548 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9555 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9580 void addAssignmentPointerOverloads(
bool isEqualOp) {
9584 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9588 else if (!PtrTy->getPointeeType()->isObjectType())
9599 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9609 if (!PtrTy.isRestrictQualified() &&
9629 for (
QualType PtrTy : CandidateTypes[1].pointer_types()) {
9643 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9653 if (!PtrTy.isRestrictQualified() &&
9686 void addAssignmentArithmeticOverloads(
bool isEqualOp) {
9687 if (!HasArithmeticOrEnumeralCandidateType)
9690 for (
unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
9691 for (
unsigned Right = FirstPromotedArithmeticType;
9692 Right < LastPromotedArithmeticType; ++Right) {
9694 ParamTypes[1] = ArithmeticTypes[Right];
9696 S, ArithmeticTypes[Left], Args[0]);
9709 for (
QualType Vec1Ty : CandidateTypes[0].vector_types())
9710 for (
QualType Vec2Ty : CandidateTypes[0].vector_types()) {
9712 ParamTypes[1] = Vec2Ty;
9740 void addAssignmentIntegralOverloads() {
9741 if (!HasArithmeticOrEnumeralCandidateType)
9744 for (
unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
9745 for (
unsigned Right = FirstPromotedIntegralType;
9746 Right < LastPromotedIntegralType; ++Right) {
9748 ParamTypes[1] = ArithmeticTypes[Right];
9750 S, ArithmeticTypes[Left], Args[0]);
9769 void addExclaimOverload() {
9775 void addAmpAmpOrPipePipeOverload() {
9792 void addSubscriptOverloads() {
9793 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9803 for (
QualType PtrTy : CandidateTypes[1].pointer_types()) {
9823 void addArrowStarOverloads() {
9824 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9829 if (!isa<RecordType>(C1))
9838 for (
QualType MemPtrTy : CandidateTypes[1].member_pointer_types()) {
9844 QualType ParamTypes[2] = {PtrTy, MemPtrTy};
9848 T.isVolatileQualified())
9851 T.isRestrictQualified())
9869 void addConditionalOperatorOverloads() {
9873 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9874 for (
QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9878 QualType ParamTypes[2] = {PtrTy, PtrTy};
9882 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9886 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9891 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9898 QualType ParamTypes[2] = {EnumTy, EnumTy};
9922 VisibleTypeConversionsQuals.
addConst();
9923 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9925 if (Args[ArgIdx]->getType()->isAtomicType())
9926 VisibleTypeConversionsQuals.
addAtomic();
9929 bool HasNonRecordCandidateType =
false;
9930 bool HasArithmeticOrEnumeralCandidateType =
false;
9932 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9933 CandidateTypes.emplace_back(*
this);
9934 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
9937 (Op == OO_Exclaim ||
9940 VisibleTypeConversionsQuals);
9941 HasNonRecordCandidateType = HasNonRecordCandidateType ||
9942 CandidateTypes[ArgIdx].hasNonRecordTypes();
9943 HasArithmeticOrEnumeralCandidateType =
9944 HasArithmeticOrEnumeralCandidateType ||
9945 CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
9953 if (!HasNonRecordCandidateType &&
9954 !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
9958 BuiltinOperatorOverloadBuilder OpBuilder(*
this, Args,
9959 VisibleTypeConversionsQuals,
9960 HasArithmeticOrEnumeralCandidateType,
9961 CandidateTypes, CandidateSet);
9967 llvm_unreachable(
"Expected an overloaded operator");
9972 case OO_Array_Delete:
9975 "Special operators don't use AddBuiltinOperatorCandidates");
9987 if (Args.size() == 1)
9988 OpBuilder.addUnaryPlusPointerOverloads();
9992 if (Args.size() == 1) {
9993 OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
9995 OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
9996 OpBuilder.addGenericBinaryArithmeticOverloads();
9997 OpBuilder.addMatrixBinaryArithmeticOverloads();
10002 if (Args.size() == 1)
10003 OpBuilder.addUnaryStarPointerOverloads();
10005 OpBuilder.addGenericBinaryArithmeticOverloads();
10006 OpBuilder.addMatrixBinaryArithmeticOverloads();
10011 OpBuilder.addGenericBinaryArithmeticOverloads();
10015 case OO_MinusMinus:
10016 OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
10017 OpBuilder.addPlusPlusMinusMinusPointerOverloads();
10020 case OO_EqualEqual:
10021 case OO_ExclaimEqual:
10022 OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
10023 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10024 OpBuilder.addGenericBinaryArithmeticOverloads();
10030 case OO_GreaterEqual:
10031 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10032 OpBuilder.addGenericBinaryArithmeticOverloads();
10036 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
true);
10037 OpBuilder.addThreeWayArithmeticOverloads();
10044 case OO_GreaterGreater:
10045 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10049 if (Args.size() == 1)
10055 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10059 OpBuilder.addUnaryTildePromotedIntegralOverloads();
10063 OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
10067 case OO_MinusEqual:
10068 OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
10072 case OO_SlashEqual:
10073 OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
10076 case OO_PercentEqual:
10077 case OO_LessLessEqual:
10078 case OO_GreaterGreaterEqual:
10080 case OO_CaretEqual:
10082 OpBuilder.addAssignmentIntegralOverloads();
10086 OpBuilder.addExclaimOverload();
10091 OpBuilder.addAmpAmpOrPipePipeOverload();
10095 if (Args.size() == 2)
10096 OpBuilder.addSubscriptOverloads();
10100 OpBuilder.addArrowStarOverloads();
10103 case OO_Conditional:
10104 OpBuilder.addConditionalOperatorOverloads();
10105 OpBuilder.addGenericBinaryArithmeticOverloads();
10123 bool PartialOverloading) {
10134 ArgumentDependentLookup(Name,
Loc, Args, Fns);
10138 CandEnd = CandidateSet.
end();
10139 Cand != CandEnd; ++Cand)
10140 if (Cand->Function) {
10141 Fns.
erase(Cand->Function);
10143 Fns.
erase(FunTmpl);
10152 if (ExplicitTemplateArgs)
10155 AddOverloadCandidate(
10156 FD, FoundDecl, Args, CandidateSet,
false,
10157 PartialOverloading,
true,
10158 false, ADLCallKind::UsesADL);
10160 AddOverloadCandidate(
10161 FD, FoundDecl, {Args[1], Args[0]}, CandidateSet,
10162 false, PartialOverloading,
10164 ADLCallKind::UsesADL, std::nullopt,
10168 auto *FTD = cast<FunctionTemplateDecl>(*I);
10169 AddTemplateOverloadCandidate(
10170 FTD, FoundDecl, ExplicitTemplateArgs, Args, CandidateSet,
10171 false, PartialOverloading,
10172 true, ADLCallKind::UsesADL);
10174 *
this, Args, FTD->getTemplatedDecl())) {
10175 AddTemplateOverloadCandidate(
10176 FTD, FoundDecl, ExplicitTemplateArgs, {Args[1], Args[0]},
10177 CandidateSet,
false, PartialOverloading,
10178 true, ADLCallKind::UsesADL,
10186enum class Comparison {
Equal, Better, Worse };
10203 bool Cand1Attr = Cand1->
hasAttr<EnableIfAttr>();
10204 bool Cand2Attr = Cand2->
hasAttr<EnableIfAttr>();
10205 if (!Cand1Attr || !Cand2Attr) {
10206 if (Cand1Attr == Cand2Attr)
10207 return Comparison::Equal;
10208 return Cand1Attr ? Comparison::Better : Comparison::Worse;
10214 llvm::FoldingSetNodeID Cand1ID, Cand2ID;
10215 for (
auto Pair : zip_longest(Cand1Attrs, Cand2Attrs)) {
10216 std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
10217 std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
10222 return Comparison::Worse;
10224 return Comparison::Better;
10229 (*Cand1A)->getCond()->Profile(Cand1ID, S.
getASTContext(),
true);
10230 (*Cand2A)->getCond()->Profile(Cand2ID, S.
getASTContext(),
true);
10231 if (Cand1ID != Cand2ID)
10232 return Comparison::Worse;
10235 return Comparison::Equal;
10243 return Comparison::Equal;
10249 return Comparison::Equal;
10250 return Comparison::Worse;
10253 return Comparison::Better;
10259 const auto *Cand1CPUSpec = Cand1.
Function->
getAttr<CPUSpecificAttr>();
10260 const auto *Cand2CPUSpec = Cand2.
Function->
getAttr<CPUSpecificAttr>();
10262 if (!Cand1CPUDisp && !Cand2CPUDisp && !Cand1CPUSpec && !Cand2CPUSpec)
10263 return Comparison::Equal;
10265 if (Cand1CPUDisp && !Cand2CPUDisp)
10266 return Comparison::Better;
10267 if (Cand2CPUDisp && !Cand1CPUDisp)
10268 return Comparison::Worse;
10270 if (Cand1CPUSpec && Cand2CPUSpec) {
10271 if (Cand1CPUSpec->cpus_size() != Cand2CPUSpec->cpus_size())
10272 return Cand1CPUSpec->cpus_size() < Cand2CPUSpec->cpus_size()
10273 ? Comparison::Better
10274 : Comparison::Worse;
10276 std::pair<CPUSpecificAttr::cpus_iterator, CPUSpecificAttr::cpus_iterator>
10277 FirstDiff = std::mismatch(
10278 Cand1CPUSpec->cpus_begin(), Cand1CPUSpec->cpus_end(),
10279 Cand2CPUSpec->cpus_begin(),
10281 return LHS->getName() == RHS->getName();
10284 assert(FirstDiff.first != Cand1CPUSpec->cpus_end() &&
10285 "Two different cpu-specific versions should not have the same "
10286 "identifier list, otherwise they'd be the same decl!");
10287 return (*FirstDiff.first)->getName() < (*FirstDiff.second)->
getName()
10288 ? Comparison::Better
10289 : Comparison::Worse;
10291 llvm_unreachable(
"No way to get here unless both had cpu_dispatch");
10297static std::optional<QualType>
10299 if (!isa<CXXMethodDecl>(F) || isa<CXXConstructorDecl>(F))
10300 return std::nullopt;
10302 auto *M = cast<CXXMethodDecl>(F);
10306 return M->getFunctionObjectParameterReferenceType();
10320 PT2->getInstantiatedFromMemberTemplate()))
10331 assert(I < F->getNumParams());
10335 unsigned F1NumParams = F1->
getNumParams() + isa<CXXMethodDecl>(F1);
10336 unsigned F2NumParams = F2->
getNumParams() + isa<CXXMethodDecl>(F2);
10338 if (F1NumParams != F2NumParams)
10341 unsigned I1 = 0, I2 = 0;
10342 for (
unsigned I = 0; I != F1NumParams; ++I) {
10343 QualType T1 = NextParam(F1, I1, I == 0);
10344 QualType T2 = NextParam(F2, I2, I == 0);
10345 assert(!T1.
isNull() && !T2.
isNull() &&
"Unexpected null param types");
10373 auto *Mem1 = dyn_cast<CXXMethodDecl>(Fn1);
10374 auto *Mem2 = dyn_cast<CXXMethodDecl>(Fn2);
10375 if (Mem1 && Mem2) {
10378 if (Mem1->getParent() != Mem2->getParent())
10382 if (Mem1->isInstance() && Mem2->isInstance() &&
10384 Mem1->getFunctionObjectParameterReferenceType(),
10385 Mem1->getFunctionObjectParameterReferenceType()))
10441 bool IsCand1ImplicitHD =
10443 bool IsCand2ImplicitHD =
10458 auto EmitThreshold =
10459 (S.
getLangOpts().CUDAIsDevice && IsCallerImplicitHD &&
10460 (IsCand1ImplicitHD || IsCand2ImplicitHD))
10463 auto Cand1Emittable = P1 > EmitThreshold;
10464 auto Cand2Emittable = P2 > EmitThreshold;
10465 if (Cand1Emittable && !Cand2Emittable)
10467 if (!Cand1Emittable && Cand2Emittable)
10478 unsigned StartArg = 0;
10485 return ICS.isStandard() &&
10497 assert(Cand2.
Conversions.size() == NumArgs &&
"Overload candidate mismatch");
10498 bool HasBetterConversion =
false;
10499 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10500 bool Cand1Bad = IsIllFormedConversion(Cand1.
Conversions[ArgIdx]);
10501 bool Cand2Bad = IsIllFormedConversion(Cand2.
Conversions[ArgIdx]);
10502 if (Cand1Bad != Cand2Bad) {
10505 HasBetterConversion =
true;
10509 if (HasBetterConversion)
10516 bool HasWorseConversion =
false;
10517 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10523 HasBetterConversion =
true;
10542 HasWorseConversion =
true;
10557 if (HasBetterConversion && !HasWorseConversion)
10568 isa<CXXConversionDecl>(Cand1.
Function) &&
10569 isa<CXXConversionDecl>(Cand2.
Function)) {
10597 isa<CXXConstructorDecl>(Cand1.
Function) !=
10598 isa<CXXConstructorDecl>(Cand2.
Function))
10599 return isa<CXXConstructorDecl>(Cand1.
Function);
10603 bool Cand1IsSpecialization = Cand1.
Function &&
10605 bool Cand2IsSpecialization = Cand2.
Function &&
10607 if (Cand1IsSpecialization != Cand2IsSpecialization)
10608 return Cand2IsSpecialization;
10614 if (Cand1IsSpecialization && Cand2IsSpecialization) {
10615 const auto *Obj1Context =
10617 const auto *Obj2Context =
10625 Obj1Context ?
QualType(Obj1Context->getTypeForDecl(), 0)
10627 Obj2Context ?
QualType(Obj2Context->getTypeForDecl(), 0)
10636 if (!Cand1IsSpecialization && !Cand2IsSpecialization &&
10646 bool Cand1IsInherited =
10648 bool Cand2IsInherited =
10650 if (Cand1IsInherited != Cand2IsInherited)
10651 return Cand2IsInherited;
10652 else if (Cand1IsInherited) {
10653 assert(Cand2IsInherited);
10656 if (Cand1Class->isDerivedFrom(Cand2Class))
10658 if (Cand2Class->isDerivedFrom(Cand1Class))
10675 auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.
Function);
10676 auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.
Function);
10677 if (Guide1 && Guide2) {
10679 if (Guide1->isImplicit() != Guide2->isImplicit())
10680 return Guide2->isImplicit();
10690 const auto *Constructor1 = Guide1->getCorrespondingConstructor();
10691 const auto *Constructor2 = Guide2->getCorrespondingConstructor();
10692 if (Constructor1 && Constructor2) {
10693 bool isC1Templated = Constructor1->getTemplatedKind() !=
10695 bool isC2Templated = Constructor2->getTemplatedKind() !=
10697 if (isC1Templated != isC2Templated)
10698 return isC2Templated;
10706 if (Cmp != Comparison::Equal)
10707 return Cmp == Comparison::Better;
10710 bool HasPS1 = Cand1.
Function !=
nullptr &&
10712 bool HasPS2 = Cand2.
Function !=
nullptr &&
10714 if (HasPS1 != HasPS2 && HasPS1)
10718 if (MV == Comparison::Better)
10720 if (MV == Comparison::Worse)
10735 const auto *CD1 = dyn_cast_or_null<CXXConstructorDecl>(Cand1.
Function);
10736 const auto *CD2 = dyn_cast_or_null<CXXConstructorDecl>(Cand2.
Function);
10738 LangAS AS1 = CD1->getMethodQualifiers().getAddressSpace();
10739 LangAS AS2 = CD2->getMethodQualifiers().getAddressSpace();
10760 auto *VA = dyn_cast_or_null<ValueDecl>(A);
10761 auto *VB = dyn_cast_or_null<ValueDecl>(B);
10767 if (!VA->getDeclContext()->getRedeclContext()->Equals(
10768 VB->getDeclContext()->getRedeclContext()) ||
10769 getOwningModule(VA) == getOwningModule(VB) ||
10770 VA->isExternallyVisible() || VB->isExternallyVisible())
10778 if (Context.
hasSameType(VA->getType(), VB->getType()))
10783 if (
auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
10784 if (
auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
10787 auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
10788 auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
10789 if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
10791 EnumB->getIntegerType()))
10794 return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
10804 assert(D &&
"Unknown declaration");
10805 Diag(
Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
10807 Module *M = getOwningModule(D);
10811 for (
auto *E : Equiv) {
10812 Module *M = getOwningModule(E);
10813 Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
10822 static_cast<CNSInfo *
>(DeductionFailure.Data)
10823 ->Satisfaction.ContainsErrors;
10840 std::transform(
begin(),
end(), std::back_inserter(Candidates),
10856 bool ContainsSameSideCandidate =
10860 S.
CUDA().IdentifyPreference(Caller, Cand->
Function) ==
10863 if (ContainsSameSideCandidate) {
10870 llvm::erase_if(Candidates, IsWrongSideCandidate);
10876 for (
auto *Cand : Candidates) {
10877 Cand->
Best =
false;
10879 if (Best ==
end() ||
10899 PendingBest.push_back(&*Best);
10904 while (!PendingBest.empty()) {
10905 auto *Curr = PendingBest.pop_back_val();
10906 for (
auto *Cand : Candidates) {
10909 PendingBest.push_back(Cand);
10914 EquivalentCands.push_back(Cand->
Function);
10926 if (Best->Function && Best->Function->isDeleted())
10929 if (!EquivalentCands.empty())
10938enum OverloadCandidateKind {
10941 oc_reversed_binary_operator,
10943 oc_implicit_default_constructor,
10944 oc_implicit_copy_constructor,
10945 oc_implicit_move_constructor,
10946 oc_implicit_copy_assignment,
10947 oc_implicit_move_assignment,
10948 oc_implicit_equality_comparison,
10949 oc_inherited_constructor
10952enum OverloadCandidateSelect {
10955 ocs_described_template,
10958static std::pair<OverloadCandidateKind, OverloadCandidateSelect>
10962 std::string &Description) {
10971 OverloadCandidateSelect Select = [&]() {
10972 if (!Description.empty())
10973 return ocs_described_template;
10974 return isTemplate ? ocs_template : ocs_non_template;
10977 OverloadCandidateKind Kind = [&]() {
10979 return oc_implicit_equality_comparison;
10982 return oc_reversed_binary_operator;
10984 if (
const auto *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
10985 if (!Ctor->isImplicit()) {
10986 if (isa<ConstructorUsingShadowDecl>(Found))
10987 return oc_inherited_constructor;
10989 return oc_constructor;
10992 if (Ctor->isDefaultConstructor())
10993 return oc_implicit_default_constructor;
10995 if (Ctor->isMoveConstructor())
10996 return oc_implicit_move_constructor;
10998 assert(Ctor->isCopyConstructor() &&
10999 "unexpected sort of implicit constructor");
11000 return oc_implicit_copy_constructor;
11003 if (
const auto *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
11006 if (!Meth->isImplicit())
11009 if (Meth->isMoveAssignmentOperator())
11010 return oc_implicit_move_assignment;
11012 if (Meth->isCopyAssignmentOperator())
11013 return oc_implicit_copy_assignment;
11015 assert(isa<CXXConversionDecl>(Meth) &&
"expected conversion");
11019 return oc_function;
11022 return std::make_pair(Kind, Select);
11025void MaybeEmitInheritedConstructorNote(
Sema &S,
const Decl *FoundDecl) {
11028 if (
const auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
11030 diag::note_ovl_candidate_inherited_constructor)
11031 << Shadow->getNominatedBaseClass();
11040 if (EnableIf->getCond()->isValueDependent() ||
11041 !EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
11058 bool InOverloadResolution,
11062 if (InOverloadResolution)
11064 diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
11066 S.
Diag(
Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
11077 if (InOverloadResolution) {
11080 TemplateArgString +=
" ";
11082 FunTmpl->getTemplateParameters(),
11087 diag::note_ovl_candidate_unsatisfied_constraints)
11088 << TemplateArgString;
11090 S.
Diag(
Loc, diag::err_addrof_function_constraints_not_satisfied)
11099 return P->hasAttr<PassObjectSizeAttr>();
11106 unsigned ParamNo = std::distance(FD->
param_begin(), I) + 1;
11107 if (InOverloadResolution)
11109 diag::note_ovl_candidate_has_pass_object_size_params)
11112 S.
Diag(
Loc, diag::err_address_of_function_with_pass_object_size_params)
11128 return ::checkAddressOfFunctionIsAvailable(*
this,
Function, Complain,
11136 const auto *ConvD = dyn_cast<CXXConversionDecl>(Fn);
11140 const auto *RD = cast<CXXRecordDecl>(Fn->
getParent());
11141 if (!RD->isLambda())
11151 return ConvToCC != CallOpCC;
11157 QualType DestType,
bool TakingAddress) {
11161 !Fn->
getAttr<TargetAttr>()->isDefaultVersion())
11164 !Fn->
getAttr<TargetVersionAttr>()->isDefaultVersion())
11169 std::string FnDesc;
11170 std::pair<OverloadCandidateKind, OverloadCandidateSelect> KSPair =
11171 ClassifyOverloadCandidate(*
this, Found, Fn, RewriteKind, FnDesc);
11173 << (
unsigned)KSPair.first << (
unsigned)KSPair.second
11176 HandleFunctionTypeMismatch(PD, Fn->
getType(), DestType);
11178 MaybeEmitInheritedConstructorNote(*
this, Found);
11196 FunctionDecl *FirstCand =
nullptr, *SecondCand =
nullptr;
11197 for (
auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
11201 if (
auto *Template = I->Function->getPrimaryTemplate())
11202 Template->getAssociatedConstraints(AC);
11204 I->Function->getAssociatedConstraints(AC);
11207 if (FirstCand ==
nullptr) {
11208 FirstCand = I->Function;
11210 }
else if (SecondCand ==
nullptr) {
11211 SecondCand = I->Function;
11224 SecondCand, SecondAC))
11233 bool TakingAddress) {
11243 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
11244 NoteOverloadCandidate(*I, FunTmpl->getTemplatedDecl(),
CRK_None, DestType,
11247 = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
11248 NoteOverloadCandidate(*I, Fun,
CRK_None, DestType, TakingAddress);
11260 S.
Diag(CaretLoc, PDiag)
11261 << Ambiguous.getFromType() << Ambiguous.getToType();
11262 unsigned CandsShown = 0;
11264 for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
11276 unsigned I,
bool TakingCandidateAddress) {
11278 assert(Conv.
isBad());
11279 assert(Cand->
Function &&
"for now, candidate must be a function");
11285 bool isObjectArgument =
false;
11286 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
11288 isObjectArgument =
true;
11293 std::string FnDesc;
11294 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11305 assert(FromExpr &&
"overload set argument came from implicit argument?");
11307 if (isa<UnaryOperator>(E))
11308 E = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
11312 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11313 << ToParamRange << ToTy << Name << I + 1;
11314 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11323 CToTy = RT->getPointeeType();
11328 CFromTy = FromPT->getPointeeType();
11329 CToTy = ToPT->getPointeeType();
11339 if (isObjectArgument)
11340 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_addrspace_this)
11341 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11345 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11348 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11354 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11357 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11363 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11366 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11371 assert(CVR &&
"expected qualifiers mismatch");
11373 if (isObjectArgument) {
11375 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11376 << FromTy << (CVR - 1);
11379 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11380 << ToParamRange << FromTy << (CVR - 1) << I + 1;
11382 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11388 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_value_category)
11389 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11390 << (
unsigned)isObjectArgument << I + 1
11393 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11399 if (FromExpr && isa<InitListExpr>(FromExpr)) {
11400 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_list_argument)
11401 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11402 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11407 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11419 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
11420 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11421 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11422 << (
unsigned)(Cand->
Fix.
Kind);
11424 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11429 unsigned BaseToDerivedConversion = 0;
11432 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11433 FromPtrTy->getPointeeType()) &&
11434 !FromPtrTy->getPointeeType()->isIncompleteType() &&
11435 !ToPtrTy->getPointeeType()->isIncompleteType() &&
11437 FromPtrTy->getPointeeType()))
11438 BaseToDerivedConversion = 1;
11446 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11447 FromPtrTy->getPointeeType()) &&
11448 FromIface->isSuperClassOf(ToIface))
11449 BaseToDerivedConversion = 2;
11451 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
11453 !ToRefTy->getPointeeType()->isIncompleteType() &&
11455 BaseToDerivedConversion = 3;
11459 if (BaseToDerivedConversion) {
11460 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv)
11461 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11462 << ToParamRange << (BaseToDerivedConversion - 1) << FromTy << ToTy
11464 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11468 if (isa<ObjCObjectPointerType>(CFromTy) &&
11469 isa<PointerType>(CToTy)) {
11474 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11475 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument
11477 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11482 if (TakingCandidateAddress &&
11488 FDiag << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11489 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11490 << (
unsigned)(Cand->
Fix.
Kind);
11501 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11508 unsigned NumArgs) {
11521 if (NumArgs < MinParams) {
11538 unsigned NumFormalArgs) {
11539 assert(isa<FunctionDecl>(D) &&
11540 "The templated declaration should at least be a function"
11541 " when diagnosing bad template argument deduction due to too many"
11542 " or too few arguments");
11552 unsigned ParamCount = FnTy->getNumParams() - (HasExplicitObjectParam ? 1 : 0);
11553 unsigned mode, modeCount;
11554 if (NumFormalArgs < MinParams) {
11555 if (MinParams != ParamCount || FnTy->isVariadic() ||
11556 FnTy->isTemplateVariadic())
11560 modeCount = MinParams;
11562 if (MinParams != ParamCount)
11566 modeCount = ParamCount;
11569 std::string Description;
11570 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11571 ClassifyOverloadCandidate(S, Found, Fn,
CRK_None, Description);
11573 if (modeCount == 1 &&
11576 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11577 << Description << mode
11578 << Fn->
getParamDecl(HasExplicitObjectParam ? 1 : 0) << NumFormalArgs
11582 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11583 << Description << mode << modeCount << NumFormalArgs
11586 MaybeEmitInheritedConstructorNote(S, Found);
11591 unsigned NumFormalArgs) {
11599 llvm_unreachable(
"Unsupported: Getting the described template declaration"
11600 " for bad deduction diagnosis");
11607 bool TakingCandidateAddress) {
11613 switch (DeductionFailure.
getResult()) {
11616 "TemplateDeductionResult::Success while diagnosing bad deduction");
11618 llvm_unreachable(
"TemplateDeductionResult::NonDependentConversionFailure "
11619 "while diagnosing bad deduction");
11625 assert(ParamD &&
"no parameter found for incomplete deduction result");
11627 diag::note_ovl_candidate_incomplete_deduction)
11629 MaybeEmitInheritedConstructorNote(S, Found);
11634 assert(ParamD &&
"no parameter found for incomplete deduction result");
11636 diag::note_ovl_candidate_incomplete_deduction_pack)
11640 MaybeEmitInheritedConstructorNote(S, Found);
11645 assert(ParamD &&
"no parameter found for bad qualifiers deduction result");
11663 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_underqualified)
11664 << ParamD->
getDeclName() << Arg << NonCanonParam;
11665 MaybeEmitInheritedConstructorNote(S, Found);
11670 assert(ParamD &&
"no parameter found for inconsistent deduction result");
11672 if (isa<TemplateTypeParmDecl>(ParamD))
11674 else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
11684 diag::note_ovl_candidate_inconsistent_deduction_types)
11687 MaybeEmitInheritedConstructorNote(S, Found);
11707 diag::note_ovl_candidate_inconsistent_deduction)
11710 MaybeEmitInheritedConstructorNote(S, Found);
11715 assert(ParamD &&
"no parameter found for invalid explicit arguments");
11718 diag::note_ovl_candidate_explicit_arg_mismatch_named)
11723 index = TTP->getIndex();
11725 = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
11726 index = NTTP->getIndex();
11728 index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
11730 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
11733 MaybeEmitInheritedConstructorNote(S, Found);
11740 TemplateArgString =
" ";
11743 if (TemplateArgString.size() == 1)
11744 TemplateArgString.clear();
11746 diag::note_ovl_candidate_unsatisfied_constraints)
11747 << TemplateArgString;
11750 static_cast<CNSInfo*
>(DeductionFailure.
Data)->Satisfaction);
11760 diag::note_ovl_candidate_instantiation_depth);
11761 MaybeEmitInheritedConstructorNote(S, Found);
11769 TemplateArgString =
" ";
11772 if (TemplateArgString.size() == 1)
11773 TemplateArgString.clear();
11778 if (PDiag && PDiag->second.getDiagID() ==
11779 diag::err_typename_nested_not_found_enable_if) {
11782 S.
Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
11783 <<
"'enable_if'" << TemplateArgString;
11788 if (PDiag && PDiag->second.getDiagID() ==
11789 diag::err_typename_nested_not_found_requirement) {
11791 diag::note_ovl_candidate_disabled_by_requirement)
11792 << PDiag->second.getStringArg(0) << TemplateArgString;
11802 SFINAEArgString =
": ";
11804 PDiag->second.EmitToString(S.
getDiagnostics(), SFINAEArgString);
11808 diag::note_ovl_candidate_substitution_failure)
11809 << TemplateArgString << SFINAEArgString << R;
11810 MaybeEmitInheritedConstructorNote(S, Found);
11820 TemplateArgString =
" ";
11823 if (TemplateArgString.size() == 1)
11824 TemplateArgString.clear();
11827 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_deduced_mismatch)
11830 << TemplateArgString
11855 diag::note_ovl_candidate_non_deduced_mismatch_qualified)
11862 if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
11871 diag::note_ovl_candidate_non_deduced_mismatch)
11872 << FirstTA << SecondTA;
11878 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_bad_deduction);
11879 MaybeEmitInheritedConstructorNote(S, Found);
11883 diag::note_cuda_ovl_candidate_target_mismatch);
11891 bool TakingCandidateAddress) {
11910 std::string FnDesc;
11911 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11912 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Callee,
11915 S.
Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
11916 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
11918 << llvm::to_underlying(CalleeTarget) << llvm::to_underlying(CallerTarget);
11923 if (Meth !=
nullptr && Meth->
isImplicit()) {
11927 switch (FnKindPair.first) {
11930 case oc_implicit_default_constructor:
11933 case oc_implicit_copy_constructor:
11936 case oc_implicit_move_constructor:
11939 case oc_implicit_copy_assignment:
11942 case oc_implicit_move_assignment:
11947 bool ConstRHS =
false;
11951 ConstRHS = RT->getPointeeType().isConstQualified();
11965 S.
Diag(Callee->getLocation(),
11966 diag::note_ovl_candidate_disabled_by_function_cond_attr)
11967 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
11972 assert(ES.
isExplicit() &&
"not an explicit candidate");
11976 case Decl::Kind::CXXConstructor:
11979 case Decl::Kind::CXXConversion:
11982 case Decl::Kind::CXXDeductionGuide:
11986 llvm_unreachable(
"invalid Decl");
11995 First = Pattern->getFirstDecl();
11998 diag::note_ovl_candidate_explicit)
11999 << Kind << (ES.
getExpr() ? 1 : 0)
12020 bool TakingCandidateAddress,
12036 std::string FnDesc;
12037 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12038 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12042 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
12044 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12060 TakingCandidateAddress);
12063 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_illegal_constructor)
12065 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12073 diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch)
12074 << QualsForPrinting;
12075 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12086 for (
unsigned N = Cand->
Conversions.size(); I != N; ++I)
12107 if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
12110 diag::note_ovl_candidate_inherited_constructor_slice)
12113 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12119 assert(!Available);
12127 std::string FnDesc;
12128 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12129 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12133 diag::note_ovl_candidate_constraints_not_satisfied)
12134 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
12152 bool isLValueReference =
false;
12153 bool isRValueReference =
false;
12154 bool isPointer =
false;
12158 isLValueReference =
true;
12162 isRValueReference =
true;
12178 diag::note_ovl_surrogate_constraints_not_satisfied)
12192 assert(Cand->
Conversions.size() <= 2 &&
"builtin operator is not binary");
12193 std::string TypeStr(
"operator");
12199 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12204 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12211 if (ICS.
isBad())
break;
12215 S, OpLoc, S.
PDiag(diag::note_ambiguous_type_conversion));
12232 llvm_unreachable(
"non-deduction failure while diagnosing bad deduction");
12262 llvm_unreachable(
"Unhandled deduction result");
12267struct CompareOverloadCandidatesForDisplay {
12273 CompareOverloadCandidatesForDisplay(
12276 : S(S), NumArgs(NArgs), CSK(CSK) {}
12286 if (NumArgs >
C->Function->getNumParams() && !
C->Function->isVariadic())
12288 if (NumArgs < C->
Function->getMinRequiredArguments())
12298 if (L == R)
return false;
12302 if (!R->
Viable)
return true;
12304 if (
int Ord = CompareConversions(*L, *R))
12324 if (LDist == RDist) {
12325 if (LFailureKind == RFailureKind)
12333 return LDist < RDist;
12351 numLFixes = (numLFixes == 0) ?
UINT_MAX : numLFixes;
12352 numRFixes = (numRFixes == 0) ?
UINT_MAX : numRFixes;
12353 if (numLFixes != numRFixes) {
12354 return numLFixes < numRFixes;
12358 if (
int Ord = CompareConversions(*L, *R))
12370 if (LRank != RRank)
12371 return LRank < RRank;
12397 struct ConversionSignals {
12398 unsigned KindRank = 0;
12402 ConversionSignals Sig;
12403 Sig.KindRank =
Seq.getKindRank();
12404 if (
Seq.isStandard())
12405 Sig.Rank =
Seq.Standard.getRank();
12406 else if (
Seq.isUserDefined())
12407 Sig.Rank =
Seq.UserDefined.After.getRank();
12413 static ConversionSignals ForObjectArgument() {
12429 for (
unsigned I = 0, N = L.
Conversions.size(); I != N; ++I) {
12431 ? ConversionSignals::ForObjectArgument()
12432 : ConversionSignals::ForSequence(L.Conversions[I]);
12434 ? ConversionSignals::ForObjectArgument()
12435 : ConversionSignals::ForSequence(R.Conversions[I]);
12436 if (std::tie(LS.KindRank, LS.Rank) != std::tie(RS.KindRank, RS.Rank))
12437 return std::tie(LS.KindRank, LS.Rank) < std::tie(RS.KindRank, RS.Rank)
12462 bool Unfixable =
false;
12470 assert(ConvIdx != ConvCount &&
"no bad conversion in candidate");
12471 if (Cand->
Conversions[ConvIdx].isInitialized() &&
12480 bool SuppressUserConversions =
false;
12482 unsigned ConvIdx = 0;
12483 unsigned ArgIdx = 0;
12498 if (isa<CXXMethodDecl>(Cand->
Function) &&
12511 assert(ConvCount <= 3);
12517 ConvIdx != ConvCount;
12519 assert(ArgIdx < Args.size() &&
"no argument for this arg conversion");
12520 if (Cand->
Conversions[ConvIdx].isInitialized()) {
12522 }
else if (
ParamIdx < ParamTypes.size()) {
12523 if (ParamTypes[
ParamIdx]->isDependentType())
12524 Cand->
Conversions[ConvIdx].setAsIdentityConversion(
12525 Args[ArgIdx]->getType());
12529 SuppressUserConversions,
12534 if (!Unfixable && Cand->
Conversions[ConvIdx].isBad())
12550 for (
iterator Cand =
begin(), LastCand =
end(); Cand != LastCand; ++Cand) {
12551 if (!Filter(*Cand))
12555 if (!Cand->Viable) {
12556 if (!Cand->Function && !Cand->IsSurrogate) {
12576 Cands.push_back(Cand);
12580 Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
12587 bool DeferHint =
false;
12591 auto WrongSidedCands =
12593 return (Cand.Viable ==
false &&
12596 Cand.Function->template hasAttr<CUDAHostAttr>() &&
12597 Cand.Function->template hasAttr<CUDADeviceAttr>());
12599 DeferHint = !WrongSidedCands.empty();
12617 bool NoteCands =
true;
12618 for (
const Expr *Arg : Args) {
12619 if (Arg->getType()->isWebAssemblyTableType())
12633 bool ReportedAmbiguousConversions =
false;
12636 unsigned CandsShown = 0;
12637 auto I = Cands.begin(), E = Cands.end();
12638 for (; I != E; ++I) {
12654 "Non-viable built-in candidates are not added to Cands.");
12661 if (!ReportedAmbiguousConversions) {
12663 ReportedAmbiguousConversions =
true;
12676 S.
Diag(OpLoc, diag::note_ovl_too_many_candidates,
12688struct CompareTemplateSpecCandidatesForDisplay {
12690 CompareTemplateSpecCandidatesForDisplay(
Sema &S) : S(S) {}
12724 bool ForTakingAddress) {
12726 DeductionFailure, 0, ForTakingAddress);
12729void TemplateSpecCandidateSet::destroyCandidates() {
12731 i->DeductionFailure.Destroy();
12736 destroyCandidates();
12737 Candidates.clear();
12750 Cands.reserve(
size());
12751 for (
iterator Cand =
begin(), LastCand =
end(); Cand != LastCand; ++Cand) {
12752 if (Cand->Specialization)
12753 Cands.push_back(Cand);
12758 llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S));
12765 unsigned CandsShown = 0;
12766 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
12772 if (CandsShown >= 4 && ShowOverloads ==
Ovl_Best)
12777 "Non-matching built-in candidates are not added to Cands.");
12782 S.
Diag(
Loc, diag::note_ovl_too_many_candidates) <<
int(E - I);
12792 QualType Ret = PossiblyAFunctionType;
12795 Ret = ToTypePtr->getPointeeType();
12798 Ret = ToTypeRef->getPointeeType();
12801 Ret = MemTypePtr->getPointeeType();
12808 bool Complain =
true) {
12825class AddressOfFunctionResolver {
12835 bool TargetTypeIsNonStaticMemberFunction;
12836 bool FoundNonTemplateFunction;
12837 bool StaticMemberFunctionFromBoundPointer;
12838 bool HasComplained;
12847 AddressOfFunctionResolver(
Sema &S,
Expr *SourceExpr,
12848 const QualType &TargetType,
bool Complain)
12849 : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
12850 Complain(Complain), Context(S.getASTContext()),
12851 TargetTypeIsNonStaticMemberFunction(
12853 FoundNonTemplateFunction(
false),
12854 StaticMemberFunctionFromBoundPointer(
false),
12855 HasComplained(
false),
12858 FailedCandidates(OvlExpr->getNameLoc(),
true) {
12859 ExtractUnqualifiedFunctionTypeFromTargetType();
12863 if (!UME->isImplicitAccess() &&
12865 StaticMemberFunctionFromBoundPointer =
true;
12869 OvlExpr,
false, &dap)) {
12875 TargetTypeIsNonStaticMemberFunction =
true;
12883 Matches.push_back(std::make_pair(dap, Fn));
12891 if (FindAllFunctionsThatMatchTargetTypeExactly()) {
12894 if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
12895 if (FoundNonTemplateFunction)
12896 EliminateAllTemplateMatches();
12898 EliminateAllExceptMostSpecializedTemplate();
12903 EliminateSuboptimalCudaMatches();
12906 bool hasComplained()
const {
return HasComplained; }
12909 bool candidateHasExactlyCorrectType(
const FunctionDecl *FD) {
12921 return candidateHasExactlyCorrectType(A) &&
12922 (!candidateHasExactlyCorrectType(B) ||
12928 bool eliminiateSuboptimalOverloadCandidates() {
12931 auto Best = Matches.begin();
12932 for (
auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
12933 if (isBetterCandidate(I->second, Best->second))
12937 auto IsBestOrInferiorToBest = [
this, BestFn](
12938 const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
12939 return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
12944 if (!llvm::all_of(Matches, IsBestOrInferiorToBest))
12946 Matches[0] = *Best;
12951 bool isTargetTypeAFunction()
const {
12960 void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
12971 bool CanConvertToFunctionPointer =
12973 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
12976 else if (TargetTypeIsNonStaticMemberFunction)
12988 FunctionTemplate, &OvlExplicitTemplateArgs, TargetFunctionType,
12990 Result != TemplateDeductionResult::Success) {
13008 Matches.push_back(std::make_pair(CurAccessFunPair,
Specialization));
13012 bool AddMatchingNonTemplateFunction(
NamedDecl* Fn,
13017 bool CanConvertToFunctionPointer =
13019 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13022 else if (TargetTypeIsNonStaticMemberFunction)
13025 if (
FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
13032 if (FunDecl->isMultiVersion()) {
13033 const auto *TA = FunDecl->
getAttr<TargetAttr>();
13034 if (TA && !TA->isDefaultVersion())
13036 const auto *TVA = FunDecl->getAttr<TargetVersionAttr>();
13037 if (TVA && !TVA->isDefaultVersion())
13045 HasComplained |= Complain;
13054 candidateHasExactlyCorrectType(FunDecl)) {
13055 Matches.push_back(std::make_pair(
13056 CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
13057 FoundNonTemplateFunction =
true;
13065 bool FindAllFunctionsThatMatchTargetTypeExactly() {
13070 if (IsInvalidFormOfPointerToMemberFunction())
13086 = dyn_cast<FunctionTemplateDecl>(Fn)) {
13087 if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
13092 AddMatchingNonTemplateFunction(Fn, I.getPair()))
13095 assert(Ret || Matches.empty());
13099 void EliminateAllExceptMostSpecializedTemplate() {
13112 for (
unsigned I = 0, E = Matches.size(); I != E; ++I)
13113 MatchesCopy.
addDecl(Matches[I].second, Matches[I].first.getAccess());
13118 MatchesCopy.
begin(), MatchesCopy.
end(), FailedCandidates,
13120 S.
PDiag(diag::err_addr_ovl_ambiguous)
13121 << Matches[0].second->getDeclName(),
13122 S.
PDiag(diag::note_ovl_candidate)
13123 << (
unsigned)oc_function << (
unsigned)ocs_described_template,
13124 Complain, TargetFunctionType);
13126 if (Result != MatchesCopy.
end()) {
13128 Matches[0].first = Matches[Result - MatchesCopy.
begin()].first;
13129 Matches[0].second = cast<FunctionDecl>(*Result);
13132 HasComplained |= Complain;
13135 void EliminateAllTemplateMatches() {
13138 for (
unsigned I = 0, N = Matches.size(); I != N; ) {
13139 if (Matches[I].second->getPrimaryTemplate() ==
nullptr)
13142 Matches[I] = Matches[--N];
13148 void EliminateSuboptimalCudaMatches() {
13154 void ComplainNoMatchesFound()
const {
13155 assert(Matches.empty());
13157 << OvlExpr->
getName() << TargetFunctionType
13159 if (FailedCandidates.
empty())
13170 dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
13178 bool IsInvalidFormOfPointerToMemberFunction()
const {
13179 return TargetTypeIsNonStaticMemberFunction &&
13183 void ComplainIsInvalidFormOfPointerToMemberFunction()
const {
13191 bool IsStaticMemberFunctionFromBoundPointer()
const {
13192 return StaticMemberFunctionFromBoundPointer;
13195 void ComplainIsStaticMemberFunctionFromBoundPointer()
const {
13197 diag::err_invalid_form_pointer_member_function)
13201 void ComplainOfInvalidConversion()
const {
13203 << OvlExpr->
getName() << TargetType;
13206 void ComplainMultipleMatchesFound()
const {
13207 assert(Matches.size() > 1);
13214 bool hadMultipleCandidates()
const {
return (OvlExpr->
getNumDecls() > 1); }
13216 int getNumMatches()
const {
return Matches.size(); }
13219 if (Matches.size() != 1)
return nullptr;
13220 return Matches[0].second;
13224 if (Matches.size() != 1)
return nullptr;
13225 return &Matches[0].first;
13250 bool *pHadMultipleCandidates) {
13253 AddressOfFunctionResolver Resolver(*
this, AddressOfExpr, TargetType,
13255 int NumMatches = Resolver.getNumMatches();
13257 bool ShouldComplain = Complain && !Resolver.hasComplained();
13258 if (NumMatches == 0 && ShouldComplain) {
13259 if (Resolver.IsInvalidFormOfPointerToMemberFunction())
13260 Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
13262 Resolver.ComplainNoMatchesFound();
13264 else if (NumMatches > 1 && ShouldComplain)
13265 Resolver.ComplainMultipleMatchesFound();
13266 else if (NumMatches == 1) {
13267 Fn = Resolver.getMatchingFunctionDecl();
13270 ResolveExceptionSpec(AddressOfExpr->
getExprLoc(), FPT);
13271 FoundResult = *Resolver.getMatchingFunctionAccessPair();
13273 if (Resolver.IsStaticMemberFunctionFromBoundPointer())
13274 Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
13276 CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
13280 if (pHadMultipleCandidates)
13281 *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
13296 bool IsResultAmbiguous =
false;
13304 return static_cast<int>(
CUDA().IdentifyPreference(Caller, FD1)) -
13305 static_cast<int>(
CUDA().IdentifyPreference(Caller, FD2));
13312 auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
13320 auto FoundBetter = [&]() {
13321 IsResultAmbiguous =
false;
13332 if (getLangOpts().CUDA) {
13333 int PreferenceByCUDA = CheckCUDAPreference(FD,
Result);
13335 if (PreferenceByCUDA != 0) {
13337 if (PreferenceByCUDA > 0)
13345 if (MoreConstrained != FD) {
13346 if (!MoreConstrained) {
13347 IsResultAmbiguous =
true;
13348 AmbiguousDecls.push_back(FD);
13357 if (IsResultAmbiguous)
13368 if (getLangOpts().
CUDA && CheckCUDAPreference(Skipped,
Result) != 0)
13370 if (!getMoreConstrainedFunction(Skipped,
Result))
13386 ExprResult &SrcExpr,
bool DoFunctionPointerConversion) {
13391 FunctionDecl *Found = resolveAddressOfSingleOverloadCandidate(E, DAP);
13400 CheckAddressOfMemberAccess(E, DAP);
13401 ExprResult Res = FixOverloadedFunctionReference(E, DAP, Found);
13406 SrcExpr = DefaultFunctionArrayConversion(Fixed,
false);
13451 = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
13480 NoteAllOverloadCandidates(ovl);
13486 if (FoundResult) *FoundResult = I.getPair();
13505 ExprResult &SrcExpr,
bool doFunctionPointerConversion,
bool complain,
13507 unsigned DiagIDForComplaining) {
13514 if (
FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
13526 isa<CXXMethodDecl>(fn) &&
13527 cast<CXXMethodDecl>(fn)->isInstance()) {
13528 if (!complain)
return false;
13531 diag::err_bound_member_function)
13544 SingleFunctionExpression =
13545 FixOverloadedFunctionReference(SrcExpr.
get(), found, fn);
13548 if (doFunctionPointerConversion) {
13549 SingleFunctionExpression =
13550 DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.
get());
13551 if (SingleFunctionExpression.
isInvalid()) {
13558 if (!SingleFunctionExpression.
isUsable()) {
13560 Diag(OpRangeForComplaining.
getBegin(), DiagIDForComplaining)
13562 << DestTypeForComplaining
13563 << OpRangeForComplaining
13565 NoteAllOverloadCandidates(SrcExpr.
get());
13574 SrcExpr = SingleFunctionExpression;
13584 bool PartialOverloading,
13586 NamedDecl *Callee = FoundDecl.getDecl();
13587 if (isa<UsingShadowDecl>(Callee))
13588 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
13591 if (ExplicitTemplateArgs) {
13592 assert(!KnownValid &&
"Explicit template arguments?");
13601 PartialOverloading);
13606 = dyn_cast<FunctionTemplateDecl>(Callee)) {
13608 ExplicitTemplateArgs, Args, CandidateSet,
13610 PartialOverloading);
13614 assert(!KnownValid &&
"unhandled case in overloaded call candidate");
13622 bool PartialOverloading) {
13645 assert(!(*I)->getDeclContext()->isRecord());
13646 assert(isa<UsingShadowDecl>(*I) ||
13647 !(*I)->getDeclContext()->isFunctionOrMethod());
13648 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
13658 ExplicitTemplateArgs = &TABuffer;
13664 CandidateSet, PartialOverloading,
13669 Args, ExplicitTemplateArgs,
13670 CandidateSet, PartialOverloading);
13680 CandidateSet,
false,
false);
13686 switch (Name.getCXXOverloadedOperator()) {
13687 case OO_New:
case OO_Array_New:
13688 case OO_Delete:
case OO_Array_Delete:
13711 if (DC->isTransparentContext())
13727 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC)) {
13732 if (FoundInClass) {
13733 *FoundInClass = RD;
13736 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
13753 AssociatedNamespaces,
13754 AssociatedClasses);
13758 for (Sema::AssociatedNamespaceSet::iterator
13759 it = AssociatedNamespaces.begin(),
13760 end = AssociatedNamespaces.end(); it !=
end; ++it) {
13762 if (
Std &&
Std->Encloses(*it))
13772 SuggestedNamespaces.insert(*it);
13776 SemaRef.
Diag(R.
getNameLoc(), diag::err_not_found_by_two_phase_lookup)
13778 if (SuggestedNamespaces.empty()) {
13779 SemaRef.
Diag(Best->Function->getLocation(),
13780 diag::note_not_found_by_two_phase_lookup)
13782 }
else if (SuggestedNamespaces.size() == 1) {
13783 SemaRef.
Diag(Best->Function->getLocation(),
13784 diag::note_not_found_by_two_phase_lookup)
13790 SemaRef.
Diag(Best->Function->getLocation(),
13791 diag::note_not_found_by_two_phase_lookup)
13823class BuildRecoveryCallExprRAII {
13828 BuildRecoveryCallExprRAII(
Sema &S) : SemaRef(S), SatStack(S) {
13850 bool EmptyLookup,
bool AllowTypoCorrection) {
13858 BuildRecoveryCallExprRAII RCE(SemaRef);
13868 ExplicitTemplateArgs = &TABuffer;
13876 ExplicitTemplateArgs, Args, &FoundInClass)) {
13878 }
else if (EmptyLookup) {
13883 ExplicitTemplateArgs !=
nullptr,
13884 dyn_cast<MemberExpr>(Fn));
13886 AllowTypoCorrection
13892 }
else if (FoundInClass && SemaRef.
getLangOpts().MSVCCompat) {
13907 assert(!R.
empty() &&
"lookup results empty despite recovery");
13918 if ((*R.
begin())->isCXXClassMember())
13920 ExplicitTemplateArgs, S);
13921 else if (ExplicitTemplateArgs || TemplateKWLoc.
isValid())
13923 ExplicitTemplateArgs);
13950 assert(!ULE->
getQualifier() &&
"qualified name with ADL");
13957 (F = dyn_cast<FunctionDecl>(*ULE->
decls_begin())) &&
13959 llvm_unreachable(
"performing ADL for builtin");
13962 assert(getLangOpts().
CPlusPlus &&
"ADL enabled in C");
13966 UnbridgedCastsSet UnbridgedCasts;
13974 AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
13976 if (getLangOpts().MSVCCompat &&
13977 CurContext->isDependentContext() && !isSFINAEContext() &&
13978 (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
13981 if (CandidateSet->
empty() ||
13990 RParenLoc, CurFPFeatureOverrides());
13997 if (CandidateSet->
empty())
14000 UnbridgedCasts.restore();
14007 std::optional<QualType>
Result;
14010 if (!Candidate.Function)
14012 if (Candidate.Function->isInvalidDecl())
14014 QualType T = Candidate.Function->getReturnType();
14027 if (Best && *Best != CS.
end())
14028 ConsiderCandidate(**Best);
14031 for (
const auto &
C : CS)
14033 ConsiderCandidate(
C);
14036 for (
const auto &
C : CS)
14037 ConsiderCandidate(
C);
14042 if (
Value.isNull() ||
Value->isUndeducedType())
14059 bool AllowTypoCorrection) {
14060 switch (OverloadResult) {
14071 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14072 false, (*Best)->IsADLCandidate);
14080 CandidateSet->
empty(),
14081 AllowTypoCorrection);
14088 for (
const Expr *Arg : Args) {
14089 if (!Arg->getType()->isFunctionType())
14091 if (
auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
14092 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
14095 Arg->getExprLoc()))
14103 SemaRef.
PDiag(diag::err_ovl_no_viable_function_in_call)
14112 SemaRef.
PDiag(diag::err_ovl_ambiguous_call)
14121 *CandidateSet, FDecl, Args);
14130 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14131 false, (*Best)->IsADLCandidate);
14137 SubExprs.append(Args.begin(), Args.end());
14144 for (
auto I = CS.
begin(), E = CS.
end(); I != E; ++I) {
14165 bool AllowTypoCorrection,
14166 bool CalleesAddressIsTaken) {
14171 if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
14177 if (CalleesAddressIsTaken)
14191 if (
const auto *TP =
14195 VK_PRValue, RParenLoc, CurFPFeatureOverrides());
14201 ExecConfig, &CandidateSet, &Best,
14202 OverloadResult, AllowTypoCorrection);
14211 PerformADL, Fns.
begin(), Fns.
end(),
14217 bool HadMultipleCandidates) {
14222 Exp = InitializeExplicitObjectArgument(*
this, E, Method);
14224 Exp = PerformImplicitObjectArgumentInitialization(E,
nullptr,
14225 FoundDecl, Method);
14234 auto *CE = dyn_cast<CastExpr>(SubE);
14235 if (CE && CE->getCastKind() == CK_NoOp)
14236 SubE = CE->getSubExpr();
14238 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
14239 SubE = BE->getSubExpr();
14240 if (isa<LambdaExpr>(SubE)) {
14246 PushExpressionEvaluationContext(
14247 ExpressionEvaluationContext::PotentiallyEvaluated);
14248 ExprResult BlockExp = BuildBlockForLambdaConversion(
14250 PopExpressionEvaluationContext();
14268 Expr *ObjectParam = Exp.
get();
14271 CurFPFeatureOverrides());
14281 Exp.
get()->getEndLoc(),
14282 CurFPFeatureOverrides());
14285 if (CheckFunctionCall(Method, CE,
14310 Expr *Input,
bool PerformADL) {
14312 assert(Op !=
OO_None &&
"Invalid opcode for overloaded unary operator");
14320 Expr *Args[2] = { Input,
nullptr };
14321 unsigned NumArgs = 1;
14326 if (Opc == UO_PostInc || Opc == UO_PostDec) {
14340 if (Opc == UO_PreDec || Opc == UO_PreInc || Opc == UO_Deref)
14346 CurFPFeatureOverrides());
14355 CurFPFeatureOverrides());
14362 AddNonMemberOperatorCandidates(Fns, ArgsArray, CandidateSet);
14365 AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
14369 AddArgumentDependentLookupCandidates(OpName, OpLoc, ArgsArray,
14375 AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
14377 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
14392 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14393 CheckMemberOperatorAccess(OpLoc, Input,
nullptr, Best->FoundDecl);
14397 InputInit = InitializeExplicitObjectArgument(*
this, Input, Method);
14399 InputInit = PerformImplicitObjectArgumentInitialization(
14400 Input,
nullptr, Best->FoundDecl, Method);
14403 Base = Input = InputInit.
get();
14414 Input = InputInit.
get();
14419 Base, HadMultipleCandidates,
14431 Context, Op, FnExpr.
get(), ArgsArray, ResultTy, VK, OpLoc,
14432 CurFPFeatureOverrides(), Best->IsADLCandidate);
14434 if (CheckCallReturnType(FnDecl->
getReturnType(), OpLoc, TheCall, FnDecl))
14437 if (CheckFunctionCall(FnDecl, TheCall,
14440 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FnDecl);
14445 ExprResult InputRes = PerformImplicitConversion(
14446 Input, Best->BuiltinParamTypes[0], Best->Conversions[0], AA_Passing,
14450 Input = InputRes.
get();
14470 PDiag(diag::err_ovl_ambiguous_oper_unary)
14487 << (Msg !=
nullptr)
14488 << (Msg ? Msg->
getString() : StringRef())
14499 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
14516 AddNonMemberOperatorCandidates(Fns, Args, CandidateSet);
14519 AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
14521 AddMemberOperatorCandidates(Op, OpLoc, {Args[1], Args[0]}, CandidateSet,
14526 AddMemberOperatorCandidates(ExtraOp, OpLoc, Args, CandidateSet);
14528 AddMemberOperatorCandidates(ExtraOp, OpLoc, {Args[1], Args[0]},
14536 if (Op != OO_Equal && PerformADL) {
14538 AddArgumentDependentLookupCandidates(OpName, OpLoc, Args,
14544 AddArgumentDependentLookupCandidates(ExtraOpName, OpLoc, Args,
14563 AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
14592 Expr *RHS,
bool PerformADL,
14593 bool AllowRewrittenCandidates,
14595 Expr *Args[2] = { LHS, RHS };
14599 AllowRewrittenCandidates =
false;
14605 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
14630 CurFPFeatureOverrides());
14635 if (Opc == BO_PtrMemD) {
14636 auto CheckPlaceholder = [&](
Expr *&Arg) {
14645 if (CheckPlaceholder(Args[0]) || CheckPlaceholder(Args[1]))
14647 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14666 if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
14667 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14672 Op, OpLoc, AllowRewrittenCandidates));
14674 CandidateSet.
exclude(DefaultedFn);
14675 LookupOverloadedBinOp(CandidateSet, Op, Fns, Args, PerformADL);
14677 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
14686 bool IsReversed = Best->isReversed();
14688 std::swap(Args[0], Args[1]);
14705 if (Best->RewriteKind && ChosenOp == OO_EqualEqual &&
14709 Diag(OpLoc, IsExtension ? diag::ext_ovl_rewrite_equalequal_not_bool
14710 : diag::err_ovl_rewrite_equalequal_not_bool)
14718 if (AllowRewrittenCandidates && !IsReversed &&
14726 if (Cand.Viable && Cand.Function && Cand.isReversed() &&
14728 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
14730 *
this, OpLoc, Cand.Conversions[ArgIdx],
14731 Best->Conversions[ArgIdx]) ==
14733 AmbiguousWith.push_back(Cand.Function);
14740 if (!AmbiguousWith.empty()) {
14741 bool AmbiguousWithSelf =
14742 AmbiguousWith.size() == 1 &&
14744 Diag(OpLoc, diag::ext_ovl_ambiguous_oper_binary_reversed)
14746 << Args[0]->
getType() << Args[1]->
getType() << AmbiguousWithSelf
14748 if (AmbiguousWithSelf) {
14750 diag::note_ovl_ambiguous_oper_binary_reversed_self);
14755 if (
auto *MD = dyn_cast<CXXMethodDecl>(FnDecl))
14756 if (Op == OverloadedOperatorKind::OO_EqualEqual &&
14758 !MD->hasCXXExplicitFunctionObjectParameter() &&
14760 MD->getFunctionObjectParameterType(),
14761 MD->getParamDecl(0)->getType().getNonReferenceType()) &&
14763 MD->getFunctionObjectParameterType(),
14766 MD->getFunctionObjectParameterType(),
14769 diag::note_ovl_ambiguous_eqeq_reversed_self_non_const);
14772 diag::note_ovl_ambiguous_oper_binary_selected_candidate);
14773 for (
auto *F : AmbiguousWith)
14774 Diag(F->getLocation(),
14775 diag::note_ovl_ambiguous_oper_binary_reversed_candidate);
14783 if (Op == OO_Equal)
14784 diagnoseNullableToNonnullConversion(Args[0]->getType(),
14785 Args[1]->getType(), OpLoc);
14788 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14790 CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
14795 Arg0 = InitializeExplicitObjectArgument(*
this, Args[0], FnDecl);
14798 Arg0 = PerformImplicitObjectArgumentInitialization(
14799 Args[0],
nullptr, Best->FoundDecl, Method);
14801 Arg1 = PerformCopyInitialization(
14812 ExprResult Arg0 = PerformCopyInitialization(
14820 PerformCopyInitialization(
14832 Best->FoundDecl,
Base,
14833 HadMultipleCandidates, OpLoc);
14844 const Expr *ImplicitThis =
nullptr;
14849 Context, ChosenOp, FnExpr.
get(), Args, ResultTy, VK, OpLoc,
14850 CurFPFeatureOverrides(), Best->IsADLCandidate);
14852 if (
const auto *Method = dyn_cast<CXXMethodDecl>(FnDecl);
14855 ImplicitThis = ArgsArray[0];
14856 ArgsArray = ArgsArray.slice(1);
14859 if (CheckCallReturnType(FnDecl->
getReturnType(), OpLoc, TheCall,
14864 if (Op == OO_Equal)
14865 DiagnoseSelfMove(Args[0], Args[1], OpLoc);
14867 if (ImplicitThis) {
14870 cast<CXXMethodDecl>(FnDecl)->getFunctionObjectParameterType());
14872 CheckArgAlignment(OpLoc, FnDecl,
"'this'", ThisType,
14876 checkCall(FnDecl,
nullptr, ImplicitThis, ArgsArray,
14878 VariadicDoesNotApply);
14880 ExprResult R = MaybeBindToTemporary(TheCall);
14884 R = CheckForImmediateInvocation(R, FnDecl);
14891 (Op == OO_Spaceship && IsReversed)) {
14892 if (Op == OO_ExclaimEqual) {
14893 assert(ChosenOp == OO_EqualEqual &&
"unexpected operator name");
14894 R = CreateBuiltinUnaryOp(OpLoc, UO_LNot, R.
get());
14896 assert(ChosenOp == OO_Spaceship &&
"unexpected operator name");
14898 Expr *ZeroLiteral =
14904 pushCodeSynthesisContext(Ctx);
14906 R = CreateOverloadedBinOp(
14907 OpLoc, Opc, Fns, IsReversed ? ZeroLiteral : R.
get(),
14908 IsReversed ? R.
get() : ZeroLiteral,
true,
14911 popCodeSynthesisContext();
14916 assert(ChosenOp == Op &&
"unexpected operator name");
14920 if (Best->RewriteKind !=
CRK_None)
14928 ExprResult ArgsRes0 = PerformImplicitConversion(
14929 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
14933 Args[0] = ArgsRes0.
get();
14935 ExprResult ArgsRes1 = PerformImplicitConversion(
14936 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
14940 Args[1] = ArgsRes1.
get();
14950 if (Opc == BO_Comma)
14955 if (DefaultedFn && Opc == BO_Cmp) {
14956 ExprResult E = BuildSynthesizedThreeWayComparison(OpLoc, Fns, Args[0],
14957 Args[1], DefaultedFn);
14972 Opc >= BO_Assign && Opc <= BO_OrAssign) {
14973 Diag(OpLoc, diag::err_ovl_no_viable_oper)
14976 if (Args[0]->getType()->isIncompleteType()) {
14977 Diag(OpLoc, diag::note_assign_lhs_incomplete)
14991 Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14993 assert(
Result.isInvalid() &&
14994 "C++ binary operator overloading is missing candidates!");
15003 << Args[0]->getType()
15004 << Args[1]->getType()
15005 << Args[0]->getSourceRange()
15006 << Args[1]->getSourceRange()),
15012 if (isImplicitlyDeleted(Best->Function)) {
15016 Diag(OpLoc, diag::err_ovl_deleted_special_oper)
15021 Diag(OpLoc, diag::err_ovl_deleted_comparison)
15022 << Args[0]->
getType() << DeletedFD;
15027 NoteDeletedFunction(DeletedFD);
15035 PDiag(diag::err_ovl_deleted_oper)
15037 .getCXXOverloadedOperator())
15038 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef())
15039 << Args[0]->getSourceRange() << Args[1]->getSourceRange()),
15047 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
15063 "cannot use prvalue expressions more than once");
15064 Expr *OrigLHS = LHS;
15065 Expr *OrigRHS = RHS;
15069 LHS =
new (Context)
15072 RHS =
new (Context)
15076 ExprResult Eq = CreateOverloadedBinOp(OpLoc, BO_EQ, Fns, LHS, RHS,
true,
true,
15078 if (
Eq.isInvalid())
15081 ExprResult Less = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, LHS, RHS,
true,
15082 true, DefaultedFn);
15083 if (
Less.isInvalid())
15088 Greater = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, RHS, LHS,
true,
true,
15095 struct Comparison {
15110 for (; I >= 0; --I) {
15112 auto *VI = Info->lookupValueInfo(Comparisons[I].
Result);
15123 Result = ActOnConditionalOp(OpLoc, OpLoc, Comparisons[I].Cmp.get(),
15135 Context, OrigLHS, OrigRHS, BO_Cmp,
Result.get()->getType(),
15136 Result.get()->getValueKind(),
Result.get()->getObjectKind(), OpLoc,
15137 CurFPFeatureOverrides());
15138 Expr *SemanticForm[] = {LHS, RHS,
Result.get()};
15148 unsigned NumArgsSlots =
15149 MethodArgs.size() + std::max<unsigned>(Args.size(), NumParams);
15152 MethodArgs.reserve(MethodArgs.size() + NumArgsSlots);
15153 bool IsError =
false;
15156 for (
unsigned i = 0; i != NumParams; i++) {
15158 if (i < Args.size()) {
15176 MethodArgs.push_back(Arg);
15186 Args.push_back(
Base);
15187 for (
auto *e : ArgExpr) {
15196 ArgExpr.back()->getEndLoc());
15214 CurFPFeatureOverrides());
15218 UnbridgedCastsSet UnbridgedCasts;
15228 AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
15231 if (Args.size() == 2)
15232 AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
15234 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15247 CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, Best->FoundDecl);
15256 InitializeExplicitObjectArgument(*
this, Args[0], Method);
15259 Args[0] = Res.
get();
15262 ExprResult Arg0 = PerformImplicitObjectArgumentInitialization(
15263 Args[0],
nullptr, Best->FoundDecl, Method);
15267 MethodArgs.push_back(Arg0.
get());
15271 *
this, MethodArgs, Method, ArgExpr, LLoc);
15279 *
this, FnDecl, Best->FoundDecl,
Base, HadMultipleCandidates,
15290 Context, OO_Subscript, FnExpr.
get(), MethodArgs, ResultTy, VK, RLoc,
15291 CurFPFeatureOverrides());
15293 if (CheckCallReturnType(FnDecl->
getReturnType(), LLoc, TheCall, FnDecl))
15296 if (CheckFunctionCall(Method, TheCall,
15300 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
15306 ExprResult ArgsRes0 = PerformImplicitConversion(
15307 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
15311 Args[0] = ArgsRes0.
get();
15313 ExprResult ArgsRes1 = PerformImplicitConversion(
15314 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
15318 Args[1] = ArgsRes1.
get();
15326 CandidateSet.
empty()
15327 ? (PDiag(diag::err_ovl_no_oper)
15328 << Args[0]->getType() << 0
15329 << Args[0]->getSourceRange() <<
Range)
15330 : (PDiag(diag::err_ovl_no_viable_subscript)
15331 << Args[0]->getType() << Args[0]->getSourceRange() <<
Range);
15338 if (Args.size() == 2) {
15341 LLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
15342 <<
"[]" << Args[0]->getType() << Args[1]->getType()
15343 << Args[0]->getSourceRange() <<
Range),
15348 PDiag(diag::err_ovl_ambiguous_subscript_call)
15349 << Args[0]->getType()
15350 << Args[0]->getSourceRange() <<
Range),
15359 PDiag(diag::err_ovl_deleted_oper)
15360 <<
"[]" << (Msg !=
nullptr)
15361 << (Msg ? Msg->
getString() : StringRef())
15362 << Args[0]->getSourceRange() <<
Range),
15369 return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
15383 Expr *ExecConfig,
bool IsExecConfig,
15384 bool AllowRecovery) {
15393 if (
BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
15395 assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
15408 QualType objectType = op->getLHS()->getType();
15409 if (op->getOpcode() == BO_PtrMemI)
15413 Qualifiers difference = objectQuals - funcQuals;
15417 std::string qualsString = difference.
getAsString();
15418 Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
15421 << (qualsString.find(
' ') == std::string::npos ? 1 : 2);
15425 Context, MemExprE, Args, resultType, valueKind, RParenLoc,
15428 if (CheckCallReturnType(proto->
getReturnType(), op->getRHS()->getBeginLoc(),
15432 if (ConvertArgumentsForCall(call, op,
nullptr, proto, Args, RParenLoc))
15435 if (CheckOtherCall(call, proto))
15438 return MaybeBindToTemporary(call);
15445 if (!AllowRecovery)
15447 std::vector<Expr *> SubExprs = {MemExprE};
15448 llvm::append_range(SubExprs, Args);
15449 return CreateRecoveryExpr(MemExprE->
getBeginLoc(), RParenLoc, SubExprs,
15452 if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
15454 RParenLoc, CurFPFeatureOverrides());
15456 UnbridgedCastsSet UnbridgedCasts;
15462 bool HadMultipleCandidates =
false;
15465 if (isa<MemberExpr>(NakedMemExpr)) {
15466 MemExpr = cast<MemberExpr>(NakedMemExpr);
15470 UnbridgedCasts.restore();
15488 TemplateArgs = &TemplateArgsBuffer;
15492 E = UnresExpr->
decls_end(); I != E; ++I) {
15494 QualType ExplicitObjectType = ObjectType;
15498 if (isa<UsingShadowDecl>(
Func))
15499 Func = cast<UsingShadowDecl>(
Func)->getTargetDecl();
15501 bool HasExplicitParameter =
false;
15502 if (
const auto *M = dyn_cast<FunctionDecl>(
Func);
15503 M && M->hasCXXExplicitFunctionObjectParameter())
15504 HasExplicitParameter =
true;
15505 else if (
const auto *M = dyn_cast<FunctionTemplateDecl>(
Func);
15507 M->getTemplatedDecl()->hasCXXExplicitFunctionObjectParameter())
15508 HasExplicitParameter =
true;
15510 if (HasExplicitParameter)
15514 if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(
Func)) {
15515 AddOverloadCandidate(cast<CXXConstructorDecl>(
Func), I.getPair(), Args,
15518 }
else if ((Method = dyn_cast<CXXMethodDecl>(
Func))) {
15524 AddMethodCandidate(Method, I.getPair(), ActingDC, ExplicitObjectType,
15525 ObjectClassification, Args, CandidateSet,
15528 AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(
Func),
15529 I.getPair(), ActingDC, TemplateArgs,
15530 ExplicitObjectType, ObjectClassification,
15531 Args, CandidateSet,
15536 HadMultipleCandidates = (CandidateSet.
size() > 1);
15540 UnbridgedCasts.restore();
15543 bool Succeeded =
false;
15547 Method = cast<CXXMethodDecl>(Best->Function);
15548 FoundDecl = Best->FoundDecl;
15549 CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
15550 if (DiagnoseUseOfOverloadedDecl(Best->FoundDecl, UnresExpr->
getNameLoc()))
15558 if (Method != FoundDecl.getDecl() &&
15559 DiagnoseUseOfOverloadedDecl(Method, UnresExpr->
getNameLoc()))
15568 PDiag(diag::err_ovl_no_viable_member_function_in_call)
15575 PDiag(diag::err_ovl_ambiguous_member_call)
15580 DiagnoseUseOfDeletedFunction(
15582 CandidateSet, Best->Function, Args,
true);
15590 FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
15593 MemExprE = Res.
get();
15598 return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args, RParenLoc,
15599 ExecConfig, IsExecConfig);
15609 assert(Method &&
"Member call to something that isn't a method?");
15620 HadMultipleCandidates, MemExpr->
getExprLoc());
15626 CurFPFeatureOverrides(), Proto->getNumParams());
15631 ExprResult ObjectArg = PerformImplicitObjectArgumentInitialization(
15632 MemExpr->
getBase(), Qualifier, FoundDecl, Method);
15637 RParenLoc, CurFPFeatureOverrides(),
15638 Proto->getNumParams());
15644 return BuildRecoveryExpr(ResultType);
15647 if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
15649 return BuildRecoveryExpr(ResultType);
15651 DiagnoseSentinelCalls(Method, LParenLoc, Args);
15653 if (CheckFunctionCall(Method, TheCall, Proto))
15659 if (
auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
15660 if (
const EnableIfAttr *
Attr =
15661 CheckEnableIf(Method, LParenLoc, Args,
true)) {
15662 Diag(MemE->getMemberLoc(),
15663 diag::err_ovl_no_viable_member_function_in_call)
15666 diag::note_ovl_candidate_disabled_by_function_cond_attr)
15667 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
15672 if (isa<CXXConstructorDecl, CXXDestructorDecl>(CurContext) &&
15673 TheCall->getDirectCallee()->isPureVirtual()) {
15679 diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
15680 << MD->
getDeclName() << isa<CXXDestructorDecl>(CurContext)
15684 if (getLangOpts().AppleKext)
15690 if (
auto *DD = dyn_cast<CXXDestructorDecl>(TheCall->getDirectCallee())) {
15692 bool CallCanBeVirtual = !MemExpr->
hasQualifier() || getLangOpts().AppleKext;
15693 CheckVirtualDtorCall(DD, MemExpr->
getBeginLoc(),
false,
15694 CallCanBeVirtual,
true,
15698 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
15699 TheCall->getDirectCallee());
15715 UnbridgedCastsSet UnbridgedCasts;
15719 assert(Object.get()->getType()->isRecordType() &&
15720 "Requires object type argument");
15733 if (RequireCompleteType(LParenLoc, Object.get()->getType(),
15734 diag::err_incomplete_object_call, Object.get()))
15738 LookupResult R(*
this, OpName, LParenLoc, LookupOrdinaryName);
15739 LookupQualifiedName(R,
Record->getDecl());
15740 R.suppressAccessDiagnostics();
15743 Oper != OperEnd; ++Oper) {
15744 AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
15745 Object.get()->Classify(Context), Args, CandidateSet,
15757 bool IgnoreSurrogateFunctions =
false;
15758 if (CandidateSet.
size() == 1 &&
Record->getAsCXXRecordDecl()->isLambda()) {
15760 if (!Candidate.
Viable &&
15762 IgnoreSurrogateFunctions =
true;
15782 const auto &Conversions =
15783 cast<CXXRecordDecl>(
Record->getDecl())->getVisibleConversionFunctions();
15784 for (
auto I = Conversions.begin(), E = Conversions.end();
15785 !IgnoreSurrogateFunctions && I != E; ++I) {
15788 if (isa<UsingShadowDecl>(D))
15789 D = cast<UsingShadowDecl>(D)->getTargetDecl();
15793 if (isa<FunctionTemplateDecl>(D))
15806 AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
15807 Object.get(), Args, CandidateSet);
15812 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15825 CandidateSet.
empty()
15826 ? (PDiag(diag::err_ovl_no_oper)
15827 << Object.get()->getType() << 1
15828 << Object.get()->getSourceRange())
15829 : (PDiag(diag::err_ovl_no_viable_object_call)
15830 << Object.get()->getType() << Object.get()->getSourceRange());
15837 if (!R.isAmbiguous())
15840 PDiag(diag::err_ovl_ambiguous_object_call)
15841 << Object.get()->getType()
15842 << Object.get()->getSourceRange()),
15853 PDiag(diag::err_ovl_deleted_object_call)
15854 << Object.get()->getType() << (Msg !=
nullptr)
15855 << (Msg ? Msg->
getString() : StringRef())
15856 << Object.get()->getSourceRange()),
15862 if (Best == CandidateSet.
end())
15865 UnbridgedCasts.restore();
15867 if (Best->Function ==
nullptr) {
15871 = cast<CXXConversionDecl>(
15872 Best->Conversions[0].UserDefined.ConversionFunction);
15874 CheckMemberOperatorAccess(LParenLoc, Object.get(),
nullptr,
15876 if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
15878 assert(Conv == Best->FoundDecl.getDecl() &&
15879 "Found Decl & conversion-to-functionptr should be same, right?!");
15886 ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
15887 Conv, HadMultipleCandidates);
15888 if (
Call.isInvalid())
15892 Context,
Call.get()->getType(), CK_UserDefinedConversion,
Call.get(),
15893 nullptr,
VK_PRValue, CurFPFeatureOverrides());
15895 return BuildCallExpr(S,
Call.get(), LParenLoc, Args, RParenLoc);
15898 CheckMemberOperatorAccess(LParenLoc, Object.get(),
nullptr, Best->FoundDecl);
15903 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
15916 Obj, HadMultipleCandidates,
15923 MethodArgs.reserve(NumParams + 1);
15925 bool IsError =
false;
15931 DiagnoseInvalidExplicitObjectParameterInLambda(Method);
15934 ExprResult ObjRes = PerformImplicitObjectArgumentInitialization(
15935 Object.get(),
nullptr, Best->FoundDecl, Method);
15940 MethodArgs.push_back(Object.get());
15944 *
this, MethodArgs, Method, Args, LParenLoc);
15947 if (Proto->isVariadic()) {
15949 for (
unsigned i = NumParams, e = Args.size(); i < e; i++) {
15950 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
15953 MethodArgs.push_back(Arg.
get());
15960 DiagnoseSentinelCalls(Method, LParenLoc, Args);
15968 Context, OO_Call, NewFn.
get(), MethodArgs, ResultTy, VK, RParenLoc,
15969 CurFPFeatureOverrides());
15971 if (CheckCallReturnType(Method->
getReturnType(), LParenLoc, TheCall, Method))
15974 if (CheckFunctionCall(Method, TheCall, Proto))
15977 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
15985 bool *NoArrowOperatorFound) {
15986 assert(
Base->getType()->isRecordType() &&
15987 "left-hand side must have class type");
16004 if (RequireCompleteType(
Loc,
Base->getType(),
16005 diag::err_typecheck_incomplete_tag,
Base))
16008 LookupResult R(*
this, OpName, OpLoc, LookupOrdinaryName);
16013 Oper != OperEnd; ++Oper) {
16014 AddMethodCandidate(Oper.getPair(),
Base->getType(),
Base->Classify(Context),
16015 std::nullopt, CandidateSet,
16019 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16030 if (CandidateSet.
empty()) {
16032 if (NoArrowOperatorFound) {
16035 *NoArrowOperatorFound =
true;
16038 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
16039 << BaseType <<
Base->getSourceRange();
16041 Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
16045 Diag(OpLoc, diag::err_ovl_no_viable_oper)
16046 <<
"operator->" <<
Base->getSourceRange();
16054 <<
"->" <<
Base->getType()
16055 <<
Base->getSourceRange()),
16063 <<
"->" << (Msg !=
nullptr)
16064 << (Msg ? Msg->
getString() : StringRef())
16065 <<
Base->getSourceRange()),
16071 CheckMemberOperatorAccess(OpLoc,
Base,
nullptr, Best->FoundDecl);
16074 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
16077 ExprResult R = InitializeExplicitObjectArgument(*
this,
Base, Method);
16083 Base,
nullptr, Best->FoundDecl, Method);
16091 Base, HadMultipleCandidates, OpLoc);
16101 ResultTy, VK, OpLoc, CurFPFeatureOverrides());
16103 if (CheckCallReturnType(Method->
getReturnType(), OpLoc, TheCall, Method))
16106 if (CheckFunctionCall(Method, TheCall,
16110 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
16124 AddNonMemberOperatorCandidates(R.
asUnresolvedSet(), Args, CandidateSet,
16127 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16140 PDiag(diag::err_ovl_no_viable_function_in_call)
16155 nullptr, HadMultipleCandidates,
16164 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
16165 ExprResult InputInit = PerformCopyInitialization(
16170 ConvArgs[ArgIdx] = InputInit.
get();
16179 LitEndLoc, UDSuffixLoc, CurFPFeatureOverrides());
16181 if (CheckCallReturnType(FD->
getReturnType(), UDSuffixLoc, UDL, FD))
16184 if (CheckFunctionCall(FD, UDL,
nullptr))
16187 return CheckForImmediateInvocation(MaybeBindToTemporary(UDL), FD);
16204 Scope *S =
nullptr;
16207 if (!MemberLookup.
empty()) {
16217 return FRS_DiagnosticIssued;
16220 BuildCallExpr(S, MemberRef.
get(),
Loc, std::nullopt,
Loc,
nullptr);
16223 return FRS_DiagnosticIssued;
16226 ExprResult FnR = CreateUnresolvedLookupExpr(
nullptr,
16230 return FRS_DiagnosticIssued;
16233 bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn,
Range,
Loc,
16235 if (CandidateSet->
empty() || CandidateSetError) {
16237 return FRS_NoViableFunction;
16245 return FRS_NoViableFunction;
16248 Loc,
nullptr, CandidateSet, &Best,
16253 return FRS_DiagnosticIssued;
16256 return FRS_Success;
16267 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
16269 FixOverloadedFunctionReference(PE->getSubExpr(), Found, Fn);
16272 if (SubExpr.
get() == PE->getSubExpr())
16275 return new (Context)
16276 ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.
get());
16281 FixOverloadedFunctionReference(ICE->getSubExpr(), Found, Fn);
16284 assert(Context.
hasSameType(ICE->getSubExpr()->getType(),
16286 "Implicit cast type cannot be determined from overload");
16287 assert(ICE->path_empty() &&
"fixing up hierarchy conversion?");
16288 if (SubExpr.
get() == ICE->getSubExpr())
16293 CurFPFeatureOverrides());
16296 if (
auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
16297 if (!GSE->isResultDependent()) {
16299 FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
16302 if (SubExpr.
get() == GSE->getResultExpr())
16309 unsigned ResultIdx = GSE->getResultIndex();
16310 AssocExprs[ResultIdx] = SubExpr.
get();
16312 if (GSE->isExprPredicate())
16314 Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
16315 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16316 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16319 Context, GSE->getGenericLoc(), GSE->getControllingType(),
16320 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16321 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16330 assert(UnOp->getOpcode() == UO_AddrOf &&
16331 "Can only take the address of an overloaded function");
16341 FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
16344 if (SubExpr.
get() == UnOp->getSubExpr())
16347 if (CheckUseOfCXXMethodAsAddressOfOperand(UnOp->getBeginLoc(),
16348 SubExpr.
get(), Method))
16351 assert(isa<DeclRefExpr>(SubExpr.
get()) &&
16352 "fixed to something other than a decl ref");
16353 assert(cast<DeclRefExpr>(SubExpr.
get())->getQualifier() &&
16354 "fixed to a member ref with no nested name qualifier");
16365 (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
16369 UnOp->getOperatorLoc(),
false,
16370 CurFPFeatureOverrides());
16374 FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
16377 if (SubExpr.
get() == UnOp->getSubExpr())
16380 return CreateBuiltinUnaryOp(UnOp->getOperatorLoc(), UO_AddrOf,
16387 if (ULE->hasExplicitTemplateArgs()) {
16388 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
16389 TemplateArgs = &TemplateArgsBuffer;
16404 Fn,
Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
16405 Found.
getDecl(), ULE->getTemplateKeywordLoc(), TemplateArgs);
16413 if (MemExpr->hasExplicitTemplateArgs()) {
16414 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
16415 TemplateArgs = &TemplateArgsBuffer;
16422 if (MemExpr->isImplicitAccess()) {
16423 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16426 MemExpr->getQualifierLoc(), Found.
getDecl(),
16427 MemExpr->getTemplateKeywordLoc(), TemplateArgs);
16432 if (MemExpr->getQualifier())
16433 Loc = MemExpr->getQualifierLoc().getBeginLoc();
16435 BuildCXXThisExpr(
Loc, MemExpr->getBaseType(),
true);
16438 Base = MemExpr->getBase();
16442 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16450 return BuildMemberExpr(
16451 Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
16452 MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
16453 true, MemExpr->getMemberNameInfo(),
16457 llvm_unreachable(
"Invalid reference to overloaded function");
16463 return FixOverloadedFunctionReference(E.
get(), Found, Fn);
16468 if (!PartialOverloading || !
Function)
16472 if (
const auto *Proto =
16473 dyn_cast<FunctionProtoType>(
Function->getFunctionType()))
16474 if (Proto->isTemplateVariadic())
16476 if (
auto *Pattern =
Function->getTemplateInstantiationPattern())
16477 if (
const auto *Proto =
16478 dyn_cast<FunctionProtoType>(Pattern->getFunctionType()))
16479 if (Proto->isTemplateVariadic())
16492 << IsMember << Name << (Msg !=
nullptr)
16493 << (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)
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)
static void TryUserDefinedConversion(Sema &S, QualType DestType, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence, bool TopLevelOfInitList)
Attempt a user-defined conversion between two types (C++ [dcl.init]), which enumerates all conversion...
This file declares semantic analysis for Objective-C.
static ImplicitConversionSequence::CompareKind CompareStandardConversionSequences(Sema &S, SourceLocation Loc, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareStandardConversionSequences - Compare two standard conversion sequences to determine whether o...
static bool isNullPointerConstantForConversion(Expr *Expr, bool InOverloadResolution, ASTContext &Context)
static bool shouldSkipNotingLambdaConversionDecl(const FunctionDecl *Fn)
static const FunctionType * getConversionOpReturnTyAsFunction(CXXConversionDecl *Conv)
static bool functionHasPassObjectSizeParams(const FunctionDecl *FD)
static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1, const FunctionDecl *Cand2)
Compares the enable_if attributes of two FunctionDecls, for the purposes of overload resolution.
static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr *ArgExpr)
CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers, if any, found in visible typ...
@ ToPromotedUnderlyingType
static void AddOverloadedCallCandidate(Sema &S, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading, bool KnownValid)
Add a single candidate to the overload set.
static 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 const Expr * IgnoreNarrowingConversion(ASTContext &Ctx, const Expr *Converted)
Skip any implicit casts which could be either part of a narrowing conversion or after one in an impli...
static bool 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 Expr * GetExplicitObjectExpr(Sema &S, Expr *Obj, const FunctionDecl *Fun)
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 const char * GetImplicitConversionName(ImplicitConversionKind Kind)
GetImplicitConversionName - Return the name of this kind of implicit conversion.
static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc)
Returns true if we can take the address of the function.
static ImplicitConversionSequence::CompareKind CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareDerivedToBaseConversions - Compares two standard conversion sequences to determine whether the...
static bool convertArgsForAvailabilityChecks(Sema &S, FunctionDecl *Function, Expr *ThisArg, SourceLocation CallLoc, ArrayRef< Expr * > Args, Sema::SFINAETrap &Trap, bool MissingImplicitThis, Expr *&ConvertedThis, SmallVectorImpl< Expr * > &ConvertedArgs)
static TemplateDecl * getDescribedTemplate(Decl *Templated)
static void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand, ArrayRef< Expr * > Args, OverloadCandidateSet::CandidateSetKind CSK)
CompleteNonViableCandidate - Normally, overload resolution only computes up to the first bad conversi...
static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs)
Adopt the given qualifiers for the given type.
static void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc, OverloadCandidate *Cand)
static 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 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 std::optional< QualType > getImplicitObjectParamType(ASTContext &Context, const FunctionDecl *F)
Compute the type of the implicit object parameter for the given function, if any.
static bool checkPlaceholderForOverload(Sema &S, Expr *&E, UnbridgedCastsSet *unbridgedCasts=nullptr)
checkPlaceholderForOverload - Do any interesting placeholder-like preprocessing on the given expressi...
static FixedEnumPromotion getFixedEnumPromtion(Sema &S, const StandardConversionSequence &SCS)
Returns kind of fixed enum promotion the SCS uses.
static bool isAllowableExplicitConversion(Sema &S, QualType ConvType, QualType ToType, bool AllowObjCPointerConversion)
Determine whether this is an allowable conversion from the result of an explicit conversion operator ...
static bool isNonViableMultiVersionOverload(FunctionDecl *FD)
static 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 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 ImplicitConversionSequence TryContextuallyConvertToBool(Sema &S, Expr *From)
TryContextuallyConvertToBool - Attempt to contextually convert the expression From to bool (C++0x [co...
static ImplicitConversionSequence TryObjectArgumentInitialization(Sema &S, SourceLocation Loc, QualType FromType, Expr::Classification FromClassification, CXXMethodDecl *Method, const CXXRecordDecl *ActingContext, bool InOverloadResolution=false, QualType ExplicitParameterType=QualType(), bool SuppressUserConversion=false)
TryObjectArgumentInitialization - Try to initialize the object parameter of the given member function...
static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, DeclAccessPair &Found)
static ImplicitConversionSequence::CompareKind CompareImplicitConversionSequences(Sema &S, SourceLocation Loc, const ImplicitConversionSequence &ICS1, const ImplicitConversionSequence &ICS2)
CompareImplicitConversionSequences - Compare two implicit conversion sequences to determine whether o...
static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS=LangAS::Default)
Generates a 'note' diagnostic for an overload candidate.
static ImplicitConversionSequence TryCopyInitialization(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool InOverloadResolution, bool AllowObjCWritebackConversion, bool AllowExplicit=false)
TryCopyInitialization - Try to copy-initialize a value of type ToType from the expression From.
static ExprResult diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From, Sema::ContextualImplicitConverter &Converter, QualType T, UnresolvedSetImpl &ViableConversions)
static void markUnaddressableCandidatesUnviable(Sema &S, OverloadCandidateSet &CS)
static QualType GetExplicitObjectType(Sema &S, const Expr *MemExprE)
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 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 void PrepareExplicitObjectArgument(Sema &S, CXXMethodDecl *Method, Expr *Object, MultiExprArg &Args, SmallVectorImpl< Expr * > &NewArgs)
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 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 const FunctionProtoType * tryGetFunctionProtoType(QualType FromType)
Attempts to get the FunctionProtoType from a Type.
static bool PrepareArgumentsForCallToObjectOfClassType(Sema &S, SmallVectorImpl< Expr * > &MethodArgs, CXXMethodDecl *Method, MultiExprArg Args, SourceLocation LParenLoc)
static TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, ArrayRef< TemplateArgument > Ps, ArrayRef< TemplateArgument > As, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, bool NumberOfArgumentsMustMatch, PackFold PackFold=PackFold::ParameterToArgument)
Defines the SourceManager interface.
Allows QualTypes to be sorted and hence used in maps and sets.
C Language Family Type Representation.
A class for storing results from argument-dependent lookup.
void erase(NamedDecl *D)
Removes any data associated with a given decl.
llvm::mapped_iterator< decltype(Decls)::iterator, select_second > iterator
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
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 LangOptions & getLangOpts() 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...
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....
const TargetInfo * getAuxTargetInfo() const
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.
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...
const TargetInfo & getTargetInfo() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
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...
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.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
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.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
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.
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...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
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
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
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
specific_attr_iterator< T > specific_attr_end() const
specific_attr_iterator< T > specific_attr_begin() const
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
DeclarationNameLoc - Additional source/type location info for a declaration name.
The name of a declaration.
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.
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
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
void overloadCandidatesShown(unsigned N)
Call this after showing N overload candidates.
unsigned getNumOverloadCandidatesToShow() const
When a call or operator fails, print out up to this many candidate overloads as suggestions.
OverloadsShown getShowOverloads() const
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.
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.
const ParmVarDecl * getParamDecl(unsigned i) const
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()
StringLiteral * getDeletedMessage() const
Get the message that indicates why this function was deleted.
bool isMemberLikeConstrainedFriend() const
Determine whether a function is a friend function that cannot be redeclared outside of its class,...
bool hasCXXExplicitFunctionObjectParameter() const
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
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
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.
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.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
Qualifiers getMethodQuals() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
A class which abstracts out some details necessary for making a call.
ExtInfo withNoReturn(bool noReturn) const
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.
DeclClass * getAsSingle() const
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
bool empty() const
Return true if no decls were found.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
void suppressAccessDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup due to access control violat...
const UnresolvedSetImpl & asUnresolvedSet() const
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 ...
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.
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.
QualType getPointeeType() const
const Type * getClass() const
Describes a module or submodule.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getQualifiedNameAsString() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents an ObjC class declaration.
Interfaces are the core concept in Objective-C for object oriented design.
ObjCMethodDecl - Represents an instance or class method declaration.
ArrayRef< ParmVarDecl * > parameters() const
unsigned param_size() 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.
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
void clear(CandidateSetKind CSK)
Clear out all of the candidates.
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.
OverloadCandidate & addCandidate(unsigned NumConversions=0, ConversionSequenceList Conversions=std::nullopt)
Add a new candidate with NumConversions conversion sequence slots to the overload set.
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
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.
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
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.
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.
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.
bool IsAllowedCall(const FunctionDecl *Caller, const FunctionDecl *Callee)
Determines whether Caller may invoke Callee, based on their CUDA host/device attributes.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
bool inferTargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, CXXMethodDecl *MemberDecl, bool ConstRHS, bool Diagnose)
Given a implicit special member, infer its CUDA target from the calls it needs to make to underlying ...
static bool isImplicitHostDeviceFunction(const FunctionDecl *D)
void EraseUnwantedMatches(const FunctionDecl *Caller, llvm::SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl * > > &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
CUDAFunctionPreference IdentifyPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)
Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...
bool isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast.
Abstract base class used to perform a contextual implicit conversion from an expression to any type p...
virtual SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for one of the candidate conversions.
virtual SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic complaining that the expression does not have integral or enumeration type.
virtual SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for the explicit conversion function.
virtual SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy)=0
Emits a diagnostic when the only matching conversion function is explicit.
virtual SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy)=0
Emits a diagnostic when we picked a conversion function (for cases when we are not allowed to pick a ...
virtual SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when there are multiple possible conversion functions.
virtual bool match(QualType T)=0
Determine whether the specified type is a valid destination type for this conversion.
virtual SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when the expression has incomplete class type.
For a defaulted function, the kind of defaulted function that it is.
bool isSpecialMember() const
bool isComparison() const
CXXSpecialMemberKind asSpecialMember() const
RAII class to control scope of DeferDiags.
bool match(QualType T) override
Match an integral or (possibly scoped) enumeration type.
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Sema - This implements semantic analysis and AST building for C.
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.
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.
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
@ 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.
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
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.
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.
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.
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
DiagnosticsEngine & getDiagnostics() const
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
bool 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...
ASTContext & getASTContext() const
UnresolvedSetIterator getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain=true, QualType TargetType=QualType())
Retrieve the most specialized of the given function template specializations.
bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
IsIntegralPromotion - Determines whether the conversion from the expression From (whose potentially-a...
bool IsFloatingPointPromotion(QualType FromType, QualType ToType)
IsFloatingPointPromotion - Determines whether the conversion from FromType to ToType is a floating po...
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
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)
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...
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.
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...
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 LangOptions & getLangOpts() const
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, const NamedDecl *B)
Determine if A and B are equivalent internal linkage declarations from different modules,...
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)
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,...
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)
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.
bool AreConstraintExpressionsEqual(const NamedDecl *Old, const Expr *OldConstr, const TemplateCompareNewDeclInfo &New, const Expr *NewConstr)
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...
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)
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)
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 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.
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 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...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
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 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...
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
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 IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
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.
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"...
void AddMemberOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, OverloadCandidateParamOrder PO={})
Add overload candidates for overloaded operators that are member functions.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
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?
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
virtual bool hasIbm128Type() const
Determine whether the __ibm128 type is supported on this target.
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
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...
TemplateArgumentList * takeSugared()
Take ownership of the deduced template argument lists.
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
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.
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.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
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...
@ Result
The result type of a method or function.
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)
@ None
The alignment was not explicit in code.
ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind)
GetConversionRank - Retrieve the implicit conversion rank corresponding to the given implicit convers...
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ EST_None
no exception specification
@ ForBuiltinOverloadedOp
A conversion for an operand of a builtin overloaded operator.
__DEVICE__ _Tp abs(const std::complex< _Tp > &__c)
Represents an ambiguous user-defined conversion sequence.
ConversionSet::const_iterator const_iterator
ConversionSet & conversions()
void setFromType(QualType T)
void setToType(QualType T)
void addConversion(NamedDecl *Found, FunctionDecl *D)
SmallVector< std::pair< NamedDecl *, FunctionDecl * >, 4 > ConversionSet
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.
unsigned HasDiagnostic
Indicates whether a diagnostic is stored in Diagnostic.
TemplateDeductionResult getResult() const
void Destroy()
Free any memory associated with this deduction failure.
char Diagnostic[sizeof(PartialDiagnosticAt)]
A diagnostic indicating why deduction failed.
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.