38#include "llvm/ADT/DenseSet.h"
39#include "llvm/ADT/STLExtras.h"
40#include "llvm/ADT/STLForwardCompat.h"
41#include "llvm/ADT/SmallPtrSet.h"
42#include "llvm/ADT/SmallString.h"
43#include "llvm/ADT/SmallVector.h"
44#include "llvm/Support/Casting.h"
57 return P->hasAttr<PassObjectSizeAttr>();
78 if (HadMultipleCandidates)
89 CK_FunctionToPointerDecay);
93 bool InOverloadResolution,
96 bool AllowObjCWritebackConversion);
100 bool InOverloadResolution,
108 bool AllowObjCConversionOnExplicit);
168 return Rank[(
int)Kind];
174 static const char *
const Name[] = {
178 "Function-to-pointer",
179 "Function pointer conversion",
181 "Integral promotion",
182 "Floating point promotion",
184 "Integral conversion",
185 "Floating conversion",
186 "Complex conversion",
187 "Floating-integral conversion",
188 "Pointer conversion",
189 "Pointer-to-member conversion",
190 "Boolean conversion",
191 "Compatible-types conversion",
192 "Derived-to-base conversion",
194 "SVE Vector conversion",
195 "RVV Vector conversion",
197 "Complex-real conversion",
198 "Block Pointer conversion",
199 "Transparent Union Conversion",
200 "Writeback conversion",
201 "OpenCL Zero Event Conversion",
202 "OpenCL Zero Queue Conversion",
203 "C specific type conversion",
204 "Incompatible pointer conversion",
205 "Fixed point conversion",
206 "HLSL vector truncation",
207 "Non-decaying array conversion",
294 const Expr *Converted) {
297 if (
auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
304 while (
auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
305 switch (ICE->getCastKind()) {
307 case CK_IntegralCast:
308 case CK_IntegralToBoolean:
309 case CK_IntegralToFloating:
310 case CK_BooleanToSignedIntegral:
311 case CK_FloatingToIntegral:
312 case CK_FloatingToBoolean:
313 case CK_FloatingCast:
314 Converted = ICE->getSubExpr();
338 QualType &ConstantType,
bool IgnoreFloatToIntegralConversion)
const {
340 "narrowing check outside C++");
351 ToType = ET->getDecl()->getIntegerType();
357 goto FloatingIntegralConversion;
359 goto IntegralConversion;
370 FloatingIntegralConversion:
375 if (IgnoreFloatToIntegralConversion)
378 assert(
Initializer &&
"Unknown conversion expression");
384 if (std::optional<llvm::APSInt> IntConstantValue =
388 Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
389 llvm::APFloat::rmNearestTiesToEven);
391 llvm::APSInt ConvertedValue = *IntConstantValue;
393 Result.convertToInteger(ConvertedValue,
394 llvm::APFloat::rmTowardZero, &ignored);
396 if (*IntConstantValue != ConvertedValue) {
397 ConstantValue =
APValue(*IntConstantValue);
424 Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
427 ConstantValue = R.
Val;
428 assert(ConstantValue.
isFloat());
429 llvm::APFloat FloatVal = ConstantValue.
getFloat();
432 llvm::APFloat Converted = FloatVal;
433 llvm::APFloat::opStatus ConvertStatus =
435 llvm::APFloat::rmNearestTiesToEven, &ignored);
437 llvm::APFloat::rmNearestTiesToEven, &ignored);
439 if (FloatVal.isNaN() && Converted.isNaN() &&
440 !FloatVal.isSignaling() && !Converted.isSignaling()) {
446 if (!Converted.bitwiseIsEqual(FloatVal)) {
453 if (ConvertStatus & llvm::APFloat::opOverflow) {
470 IntegralConversion: {
474 const unsigned FromWidth = Ctx.
getIntWidth(FromType);
478 if (FromWidth > ToWidth ||
479 (FromWidth == ToWidth && FromSigned != ToSigned) ||
480 (FromSigned && !ToSigned)) {
488 std::optional<llvm::APSInt> OptInitializerValue;
489 if (!(OptInitializerValue =
Initializer->getIntegerConstantExpr(Ctx))) {
493 llvm::APSInt &InitializerValue = *OptInitializerValue;
494 bool Narrowing =
false;
495 if (FromWidth < ToWidth) {
498 if (InitializerValue.isSigned() && InitializerValue.isNegative())
503 InitializerValue = InitializerValue.extend(
504 InitializerValue.getBitWidth() + 1);
506 llvm::APSInt ConvertedValue = InitializerValue;
507 ConvertedValue = ConvertedValue.trunc(ToWidth);
508 ConvertedValue.setIsSigned(ToSigned);
509 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
510 ConvertedValue.setIsSigned(InitializerValue.isSigned());
512 if (ConvertedValue != InitializerValue)
517 ConstantValue =
APValue(InitializerValue);
533 ConstantValue = R.
Val;
534 assert(ConstantValue.
isFloat());
535 llvm::APFloat FloatVal = ConstantValue.
getFloat();
540 if (FloatVal.isNaN() && FloatVal.isSignaling()) {
556 raw_ostream &OS = llvm::errs();
557 bool PrintedSomething =
false;
560 PrintedSomething =
true;
564 if (PrintedSomething) {
570 OS <<
" (by copy constructor)";
572 OS <<
" (direct reference binding)";
574 OS <<
" (reference binding)";
576 PrintedSomething =
true;
580 if (PrintedSomething) {
584 PrintedSomething =
true;
587 if (!PrintedSomething) {
588 OS <<
"No conversions required";
595 raw_ostream &OS = llvm::errs();
603 OS <<
"aggregate initialization";
613 raw_ostream &OS = llvm::errs();
615 OS <<
"Worst list element conversion: ";
616 switch (ConversionKind) {
618 OS <<
"Standard conversion: ";
622 OS <<
"User-defined conversion: ";
626 OS <<
"Ellipsis conversion";
629 OS <<
"Ambiguous conversion";
632 OS <<
"Bad conversion";
657 struct DFIArguments {
663 struct DFIParamWithArguments : DFIArguments {
668 struct DFIDeducedMismatchArgs : DFIArguments {
670 unsigned CallArgIndex;
687 Result.Result =
static_cast<unsigned>(TDK);
688 Result.HasDiagnostic =
false;
707 auto *Saved =
new (Context) DFIDeducedMismatchArgs;
718 DFIArguments *Saved =
new (Context) DFIArguments;
730 DFIParamWithArguments *Saved =
new (Context) DFIParamWithArguments;
731 Saved->Param = Info.
Param;
744 Result.HasDiagnostic =
true;
749 CNSInfo *Saved =
new (Context) CNSInfo;
759 llvm_unreachable(
"not a deduction failure");
792 Diag->~PartialDiagnosticAt();
801 Diag->~PartialDiagnosticAt();
837 return TemplateParameter::getFromOpaqueValue(
Data);
842 return static_cast<DFIParamWithArguments*
>(
Data)->Param;
872 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->TemplateArgs;
878 return static_cast<CNSInfo*
>(
Data)->TemplateArgs;
910 return &
static_cast<DFIArguments*
>(
Data)->FirstArg;
942 return &
static_cast<DFIArguments*
>(
Data)->SecondArg;
957 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->CallArgIndex;
973 for (
unsigned I = 0; I <
X->getNumParams(); ++I)
977 if (
auto *FTX =
X->getDescribedFunctionTemplate()) {
982 FTY->getTemplateParameters()))
991 OverloadedOperatorKind::OO_EqualEqual);
1003 OverloadedOperatorKind::OO_ExclaimEqual);
1004 if (isa<CXXMethodDecl>(EqFD)) {
1021 auto *NotEqFD = Op->getAsFunction();
1022 if (
auto *UD = dyn_cast<UsingShadowDecl>(Op))
1023 NotEqFD = UD->getUnderlyingDecl()->getAsFunction();
1026 cast<Decl>(Op->getLexicalDeclContext())))
1036 return Op == OO_EqualEqual || Op == OO_Spaceship;
1042 if (!allowsReversed(Op))
1044 if (Op == OverloadedOperatorKind::OO_EqualEqual) {
1045 assert(OriginalArgs.size() == 2);
1047 S, OpLoc, OriginalArgs[1], FD))
1058void OverloadCandidateSet::destroyCandidates() {
1060 for (
auto &
C : i->Conversions)
1061 C.~ImplicitConversionSequence();
1063 i->DeductionFailure.Destroy();
1068 destroyCandidates();
1069 SlabAllocator.Reset();
1070 NumInlineBytesUsed = 0;
1077 class UnbridgedCastsSet {
1087 Entry entry = { &E, E };
1088 Entries.push_back(entry);
1094 i = Entries.begin(), e = Entries.end(); i != e; ++i)
1095 *i->Addr = i->Saved;
1109 UnbridgedCastsSet *unbridgedCasts =
nullptr) {
1113 if (placeholder->getKind() == BuiltinType::Overload)
return false;
1117 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
1119 unbridgedCasts->save(S, E);
1139 UnbridgedCastsSet &unbridged) {
1140 for (
unsigned i = 0, e = Args.size(); i != e; ++i)
1182 NamedDecl *&Match,
bool NewIsUsingDecl) {
1187 bool OldIsUsingDecl =
false;
1188 if (isa<UsingShadowDecl>(OldD)) {
1189 OldIsUsingDecl =
true;
1193 if (NewIsUsingDecl)
continue;
1195 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
1200 if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
1208 bool UseMemberUsingDeclRules =
1209 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
1213 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
1214 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
1215 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
1219 if (!isa<FunctionTemplateDecl>(OldD) &&
1220 !shouldLinkPossiblyHiddenDecl(*I, New))
1229 if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
1231 return Ovl_NonFunction;
1233 }
else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1237 }
else if (isa<TagDecl>(OldD)) {
1239 }
else if (
auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1246 if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1248 return Ovl_NonFunction;
1255 return Ovl_NonFunction;
1280 if (CheckFunctionTemplateSpecialization(New,
nullptr, TemplateSpecResult,
1283 return Ovl_Overload;
1290 return Ovl_Overload;
1295 bool UseMemberUsingDeclRules,
1296 bool ConsiderCudaAttrs,
1297 bool UseOverrideRules =
false) {
1312 if ((OldTemplate ==
nullptr) != (NewTemplate ==
nullptr))
1325 if (isa<FunctionNoProtoType>(OldQType.
getTypePtr()) ||
1326 isa<FunctionNoProtoType>(NewQType.
getTypePtr()))
1329 const auto *OldType = cast<FunctionProtoType>(OldQType);
1330 const auto *NewType = cast<FunctionProtoType>(NewQType);
1335 if (OldQType != NewQType && OldType->isVariadic() != NewType->isVariadic())
1367 bool ConstraintsInTemplateHead =
1378 if (UseMemberUsingDeclRules && ConstraintsInTemplateHead &&
1379 !SameTemplateParameterList)
1381 if (!UseMemberUsingDeclRules &&
1382 (!SameTemplateParameterList || !SameReturnType))
1386 const auto *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1387 const auto *NewMethod = dyn_cast<CXXMethodDecl>(New);
1389 int OldParamsOffset = 0;
1390 int NewParamsOffset = 0;
1408 !isa<CXXConstructorDecl>(NewMethod))
1414 auto BS =
Base.getNonReferenceType().getCanonicalType().split();
1415 BS.Quals = NormalizeQualifiers(OldMethod, BS.Quals);
1417 auto DS = D.getNonReferenceType().getCanonicalType().split();
1418 DS.Quals = NormalizeQualifiers(NewMethod, DS.Quals);
1420 if (BS.Quals != DS.Quals)
1423 if (OldMethod->isImplicitObjectMemberFunction() &&
1424 OldMethod->getParent() != NewMethod->getParent()) {
1437 if (
Base->isLValueReferenceType())
1439 return Base->isRValueReferenceType() == D->isRValueReferenceType();
1444 auto DiagnoseInconsistentRefQualifiers = [&]() {
1447 if (OldMethod->getRefQualifier() == NewMethod->getRefQualifier())
1449 if (OldMethod->isExplicitObjectMemberFunction() ||
1450 NewMethod->isExplicitObjectMemberFunction())
1452 if (!UseMemberUsingDeclRules && (OldMethod->getRefQualifier() ==
RQ_None ||
1453 NewMethod->getRefQualifier() ==
RQ_None)) {
1454 SemaRef.
Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1455 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1456 SemaRef.
Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1462 if (OldMethod && OldMethod->isExplicitObjectMemberFunction())
1464 if (NewMethod && NewMethod->isExplicitObjectMemberFunction())
1467 if (OldType->getNumParams() - OldParamsOffset !=
1468 NewType->getNumParams() - NewParamsOffset ||
1470 {OldType->param_type_begin() + OldParamsOffset,
1471 OldType->param_type_end()},
1472 {NewType->param_type_begin() + NewParamsOffset,
1473 NewType->param_type_end()},
1478 if (OldMethod && NewMethod && !OldMethod->isStatic() &&
1479 !OldMethod->isStatic()) {
1480 bool HaveCorrespondingObjectParameters = [&](
const CXXMethodDecl *Old,
1482 auto NewObjectType = New->getFunctionObjectParameterReferenceType();
1486 return F->getRefQualifier() ==
RQ_None &&
1487 !F->isExplicitObjectMemberFunction();
1490 if (IsImplicitWithNoRefQual(Old) != IsImplicitWithNoRefQual(New) &&
1491 CompareType(OldObjectType.getNonReferenceType(),
1492 NewObjectType.getNonReferenceType()))
1494 return CompareType(OldObjectType, NewObjectType);
1495 }(OldMethod, NewMethod);
1497 if (!HaveCorrespondingObjectParameters) {
1498 if (DiagnoseInconsistentRefQualifiers())
1503 if (!UseOverrideRules || (!NewMethod->isExplicitObjectMemberFunction() &&
1504 !OldMethod->isExplicitObjectMemberFunction()))
1509 if (!UseOverrideRules) {
1512 if ((NewRC !=
nullptr) != (OldRC !=
nullptr))
1519 if (NewMethod && OldMethod && OldMethod->isImplicitObjectMemberFunction() &&
1520 NewMethod->isImplicitObjectMemberFunction()) {
1521 if (DiagnoseInconsistentRefQualifiers())
1539 NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1540 if (NewI == NewE || OldI == OldE)
1542 llvm::FoldingSetNodeID NewID, OldID;
1544 OldI->getCond()->Profile(OldID, SemaRef.
Context,
true);
1549 if (SemaRef.
getLangOpts().CUDA && ConsiderCudaAttrs) {
1552 if (!isa<CXXDestructorDecl>(New)) {
1557 "Unexpected invalid target.");
1561 if (NewTarget != OldTarget)
1572 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs) {
1578 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs) {
1591 bool SuppressUserConversions,
1593 bool InOverloadResolution,
1595 bool AllowObjCWritebackConversion,
1596 bool AllowObjCConversionOnExplicit) {
1599 if (SuppressUserConversions) {
1610 Conversions, AllowExplicit,
1611 AllowObjCConversionOnExplicit)) {
1628 if (Constructor->isCopyConstructor() &&
1629 (FromCanon == ToCanon ||
1640 if (ToCanon != FromCanon)
1651 Cand != Conversions.
end(); ++Cand)
1694 bool SuppressUserConversions,
1696 bool InOverloadResolution,
1698 bool AllowObjCWritebackConversion,
1699 bool AllowObjCConversionOnExplicit) {
1702 ICS.
Standard, CStyle, AllowObjCWritebackConversion)){
1742 AllowExplicit, InOverloadResolution, CStyle,
1743 AllowObjCWritebackConversion,
1744 AllowObjCConversionOnExplicit);
1749 bool SuppressUserConversions,
1751 bool InOverloadResolution,
1753 bool AllowObjCWritebackConversion) {
1754 return ::TryImplicitConversion(*
this, From, ToType, SuppressUserConversions,
1755 AllowExplicit, InOverloadResolution, CStyle,
1756 AllowObjCWritebackConversion,
1767 bool AllowExplicit) {
1772 bool AllowObjCWritebackConversion
1773 = getLangOpts().ObjCAutoRefCount &&
1774 (Action == AA_Passing || Action == AA_Sending);
1775 if (getLangOpts().ObjC)
1776 CheckObjCBridgeRelatedConversions(From->
getBeginLoc(), ToType,
1779 *
this, From, ToType,
1781 AllowExplicit ? AllowedExplicit::All : AllowedExplicit::None,
1783 false, AllowObjCWritebackConversion,
1785 return PerformImplicitConversion(From, ToType, ICS, Action);
1806 if (TyClass != CanFrom->getTypeClass())
return false;
1807 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1808 if (TyClass == Type::Pointer) {
1811 }
else if (TyClass == Type::BlockPointer) {
1814 }
else if (TyClass == Type::MemberPointer) {
1818 if (ToMPT->getClass() != FromMPT->
getClass())
1820 CanTo = ToMPT->getPointeeType();
1826 TyClass = CanTo->getTypeClass();
1827 if (TyClass != CanFrom->getTypeClass())
return false;
1828 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1832 const auto *FromFn = cast<FunctionType>(CanFrom);
1835 const auto *ToFn = cast<FunctionType>(CanTo);
1838 bool Changed =
false;
1847 if (
const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1848 const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1849 if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1850 FromFn = cast<FunctionType>(
1861 bool CanUseToFPT, CanUseFromFPT;
1863 CanUseFromFPT, NewParamInfos) &&
1864 CanUseToFPT && !CanUseFromFPT) {
1867 NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1869 FromFPT->getParamTypes(), ExtInfo);
1878 assert(
QualType(FromFn, 0).isCanonical());
1879 if (
QualType(FromFn, 0) != CanTo)
return false;
1907 if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
1908 &ToSem == &llvm::APFloat::IEEEquad()) ||
1909 (&FromSem == &llvm::APFloat::IEEEquad() &&
1910 &ToSem == &llvm::APFloat::PPCDoubleDouble()))
1965 bool InOverloadResolution,
bool CStyle) {
1982 if (FromElts < ToElts)
1984 if (FromElts == ToElts)
2033 !ToType->
hasAttr(attr::ArmMveStrictPolymorphism))) {
2038 !InOverloadResolution && !CStyle) {
2040 << FromType << ToType;
2051 bool InOverloadResolution,
2064 bool InOverloadResolution,
2067 bool AllowObjCWritebackConversion) {
2114 if (Method && !Method->
isStatic() &&
2117 "Non-unary operator on non-static member address");
2118 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode()
2120 "Non-address-of operator on non-static member address");
2121 const Type *ClassType
2125 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode() ==
2127 "Non-address-of operator for overloaded function expression");
2146 FromType =
Atomic->getValueType();
2194 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
2214 bool IncompatibleObjC =
false;
2269 }
else if (AllowObjCWritebackConversion &&
2273 FromType, IncompatibleObjC)) {
2279 InOverloadResolution, FromType)) {
2283 From, InOverloadResolution, CStyle)) {
2293 S, From, ToType, InOverloadResolution, SCS, CStyle)) {
2329 bool ObjCLifetimeConversion;
2335 ObjCLifetimeConversion)) {
2354 CanonFrom = CanonTo;
2359 if (CanonFrom == CanonTo)
2364 if (S.
getLangOpts().CPlusPlus || !InOverloadResolution)
2408 bool InOverloadResolution,
2418 for (
const auto *it : UD->
fields()) {
2421 ToType = it->getType();
2451 return To->
getKind() == BuiltinType::Int;
2454 return To->
getKind() == BuiltinType::UInt;
2478 if (FromEnumType->getDecl()->isScoped())
2485 if (FromEnumType->getDecl()->isFixed()) {
2486 QualType Underlying = FromEnumType->getDecl()->getIntegerType();
2488 IsIntegralPromotion(
nullptr, Underlying, ToType);
2495 ToType, FromEnumType->getDecl()->getPromotionType());
2520 uint64_t FromSize = Context.
getTypeSize(FromType);
2529 for (
int Idx = 0; Idx < 6; ++Idx) {
2530 uint64_t ToSize = Context.
getTypeSize(PromoteTypes[Idx]);
2531 if (FromSize < ToSize ||
2532 (FromSize == ToSize &&
2533 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2558 std::optional<llvm::APSInt> BitWidth;
2561 MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
2562 llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
2566 if (*BitWidth < ToSize ||
2568 return To->
getKind() == BuiltinType::Int;
2574 return To->
getKind() == BuiltinType::UInt;
2604 if (FromBuiltin->getKind() == BuiltinType::Float &&
2605 ToBuiltin->getKind() == BuiltinType::Double)
2612 (FromBuiltin->getKind() == BuiltinType::Float ||
2613 FromBuiltin->getKind() == BuiltinType::Double) &&
2614 (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2615 ToBuiltin->getKind() == BuiltinType::Float128 ||
2616 ToBuiltin->getKind() == BuiltinType::Ibm128))
2620 if (!getLangOpts().NativeHalfType &&
2621 FromBuiltin->getKind() == BuiltinType::Half &&
2622 ToBuiltin->getKind() == BuiltinType::Float)
2659 bool StripObjCLifetime =
false) {
2662 "Invalid similarly-qualified pointer type");
2673 if (StripObjCLifetime)
2684 if (isa<ObjCObjectPointerType>(ToType))
2693 if (isa<ObjCObjectPointerType>(ToType))
2699 bool InOverloadResolution,
2705 return !InOverloadResolution;
2729 bool InOverloadResolution,
2731 bool &IncompatibleObjC) {
2732 IncompatibleObjC =
false;
2733 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2740 ConvertedType = ToType;
2747 ConvertedType = ToType;
2754 ConvertedType = ToType;
2762 ConvertedType = ToType;
2772 ConvertedType = ToType;
2780 !getLangOpts().ObjCAutoRefCount) {
2810 if (getLangOpts().MSVCCompat && FromPointeeType->
isFunctionType() &&
2844 IsDerivedFrom(From->
getBeginLoc(), FromPointeeType, ToPointeeType)) {
2881 bool &IncompatibleObjC) {
2882 if (!getLangOpts().
ObjC)
2894 if (ToObjCPtr && FromObjCPtr) {
2905 if (getLangOpts().CPlusPlus && LHS && RHS &&
2907 FromObjCPtr->getPointeeType()))
2912 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2920 IncompatibleObjC =
true;
2924 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2936 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2964 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2965 IncompatibleObjC)) {
2967 IncompatibleObjC =
true;
2969 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2976 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2977 IncompatibleObjC)) {
2980 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2992 if (FromFunctionType && ToFunctionType) {
3001 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
3002 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic() ||
3003 FromFunctionType->
getMethodQuals() != ToFunctionType->getMethodQuals())
3006 bool HasObjCConversion =
false;
3010 }
else if (isObjCPointerConversion(FromFunctionType->
getReturnType(),
3011 ToFunctionType->getReturnType(),
3012 ConvertedType, IncompatibleObjC)) {
3014 HasObjCConversion =
true;
3021 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
3022 ArgIdx != NumArgs; ++ArgIdx) {
3024 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3028 }
else if (isObjCPointerConversion(FromArgType, ToArgType,
3029 ConvertedType, IncompatibleObjC)) {
3031 HasObjCConversion =
true;
3038 if (HasObjCConversion) {
3042 IncompatibleObjC =
true;
3061 if (!getLangOpts().ObjCAutoRefCount ||
3103 bool IncompatibleObjC;
3105 FromPointee = ToPointee;
3106 else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
3141 if (!FromFunctionType || !ToFunctionType)
3144 if (Context.
hasSameType(FromPointeeType, ToPointeeType))
3149 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
3150 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic())
3155 if (FromEInfo != ToEInfo)
3158 bool IncompatibleObjC =
false;
3160 ToFunctionType->getReturnType())) {
3164 QualType LHS = ToFunctionType->getReturnType();
3165 if ((!getLangOpts().CPlusPlus || !RHS->
isRecordType()) &&
3171 }
else if (isObjCPointerConversion(RHS, LHS,
3172 ConvertedType, IncompatibleObjC)) {
3173 if (IncompatibleObjC)
3182 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
3183 ArgIdx != NumArgs; ++ArgIdx) {
3184 IncompatibleObjC =
false;
3186 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3187 if (Context.
hasSameType(FromArgType, ToArgType)) {
3189 }
else if (isObjCPointerConversion(ToArgType, FromArgType,
3190 ConvertedType, IncompatibleObjC)) {
3191 if (IncompatibleObjC)
3200 bool CanUseToFPT, CanUseFromFPT;
3202 CanUseToFPT, CanUseFromFPT,
3206 ConvertedType = ToType;
3247 if (!Context.
hasSameType(FromMember->getClass(), ToMember->getClass())) {
3249 <<
QualType(FromMember->getClass(), 0);
3282 if (!FromFunction || !ToFunction) {
3287 if (FromFunction->
getNumParams() != ToFunction->getNumParams()) {
3295 if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
3297 << ToFunction->getParamType(ArgPos)
3304 ToFunction->getReturnType())) {
3310 if (FromFunction->
getMethodQuals() != ToFunction->getMethodQuals()) {
3320 cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
3340 assert(llvm::size(Old) == llvm::size(New) &&
3341 "Can't compare parameters of functions with different number of "
3344 for (
auto &&[Idx,
Type] : llvm::enumerate(Old)) {
3346 size_t J =
Reversed ? (llvm::size(New) - Idx - 1) : Idx;
3367 return FunctionParamTypesAreEqual(OldType->
param_types(),
3380 unsigned OldIgnore =
3382 unsigned NewIgnore =
3385 auto *OldPT = cast<FunctionProtoType>(OldFunction->
getFunctionType());
3386 auto *NewPT = cast<FunctionProtoType>(NewFunction->
getFunctionType());
3388 return FunctionParamTypesAreEqual(OldPT->param_types().slice(OldIgnore),
3389 NewPT->param_types().slice(NewIgnore),
3402 bool IgnoreBaseAccess,
3405 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
3409 if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->
isAnyPointerType() &&
3413 DiagRuntimeBehavior(From->
getExprLoc(), From,
3414 PDiag(diag::warn_impcast_bool_to_null_pointer)
3416 else if (!isUnevaluatedContext())
3425 if (FromPointeeType->
isRecordType() && ToPointeeType->isRecordType() &&
3429 unsigned InaccessibleID = 0;
3430 unsigned AmbiguousID = 0;
3432 InaccessibleID = diag::err_upcast_to_inaccessible_base;
3433 AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
3435 if (CheckDerivedToBaseConversion(
3436 FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
3438 &BasePath, IgnoreBaseAccess))
3442 Kind = CK_DerivedToBase;
3445 if (Diagnose && !IsCStyleOrFunctionalCast &&
3446 FromPointeeType->
isFunctionType() && ToPointeeType->isVoidType()) {
3447 assert(getLangOpts().MSVCCompat &&
3448 "this should only be possible with MSVCCompat!");
3460 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
3463 Kind = CK_BlockPointerToObjCPointerCast;
3465 Kind = CK_CPointerToObjCPointerCast;
3469 Kind = CK_AnyPointerToBlockPointerCast;
3475 Kind = CK_NullToPointer;
3487 bool InOverloadResolution,
3497 ConvertedType = ToType;
3512 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass)) {
3530 bool IgnoreBaseAccess) {
3537 "Expr must be null pointer constant!");
3538 Kind = CK_NullToMemberPointer;
3543 assert(ToPtrType &&
"No member pointer cast has a target type "
3544 "that is not a member pointer.");
3550 assert(FromClass->
isRecordType() &&
"Pointer into non-class.");
3551 assert(ToClass->
isRecordType() &&
"Pointer into non-class.");
3555 bool DerivationOkay =
3556 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass, Paths);
3557 assert(DerivationOkay &&
3558 "Should not have been called if derivation isn't OK.");
3559 (void)DerivationOkay;
3562 getUnqualifiedType())) {
3563 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3565 << 0 << FromClass << ToClass << PathDisplayStr << From->
getSourceRange();
3569 if (
const RecordType *VBase = Paths.getDetectedVirtual()) {
3571 << FromClass << ToClass <<
QualType(VBase, 0)
3576 if (!IgnoreBaseAccess)
3577 CheckBaseClassAccess(From->
getExprLoc(), FromClass, ToClass,
3579 diag::err_downcast_from_inaccessible_base);
3583 Kind = CK_BaseToDerivedMemberPointer;
3606 bool CStyle,
bool IsTopLevel,
3607 bool &PreviousToQualsIncludeConst,
3608 bool &ObjCLifetimeConversion) {
3620 ObjCLifetimeConversion =
true;
3656 !PreviousToQualsIncludeConst)
3674 PreviousToQualsIncludeConst =
3675 PreviousToQualsIncludeConst && ToQuals.
hasConst();
3688 bool CStyle,
bool &ObjCLifetimeConversion) {
3691 ObjCLifetimeConversion =
false;
3701 bool PreviousToQualsIncludeConst =
true;
3702 bool UnwrappedAnyPointer =
false;
3705 FromType, ToType, CStyle, !UnwrappedAnyPointer,
3706 PreviousToQualsIncludeConst, ObjCLifetimeConversion))
3708 UnwrappedAnyPointer =
true;
3725 bool InOverloadResolution,
3734 InOverloadResolution, InnerSCS,
3751 if (CtorType->getNumParams() > 0) {
3752 QualType FirstArg = CtorType->getParamType(0);
3764 bool AllowExplicit) {
3771 bool Usable = !Info.Constructor->isInvalidDecl() &&
3774 bool SuppressUserConversions =
false;
3775 if (Info.ConstructorTmpl)
3778 CandidateSet, SuppressUserConversions,
3783 CandidateSet, SuppressUserConversions,
3784 false, AllowExplicit);
3788 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3797 QualType ThisType = Constructor->getFunctionObjectParameterType();
3815 llvm_unreachable(
"Invalid OverloadResult!");
3837 bool AllowObjCConversionOnExplicit) {
3838 assert(AllowExplicit != AllowedExplicit::None ||
3839 !AllowObjCConversionOnExplicit);
3843 bool ConstructorsOnly =
false;
3859 ConstructorsOnly =
true;
3864 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3866 Expr **Args = &From;
3867 unsigned NumArgs = 1;
3868 bool ListInitializing =
false;
3869 if (
InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3872 S, From, ToType, ToRecordDecl, User, CandidateSet,
3873 AllowExplicit == AllowedExplicit::All);
3882 Args = InitList->getInits();
3883 NumArgs = InitList->getNumInits();
3884 ListInitializing =
true;
3892 bool Usable = !Info.Constructor->isInvalidDecl();
3893 if (!ListInitializing)
3894 Usable = Usable && Info.Constructor->isConvertingConstructor(
3897 bool SuppressUserConversions = !ConstructorsOnly;
3905 if (SuppressUserConversions && ListInitializing) {
3906 SuppressUserConversions =
3907 NumArgs == 1 && isa<InitListExpr>(Args[0]) &&
3911 if (Info.ConstructorTmpl)
3913 Info.ConstructorTmpl, Info.FoundDecl,
3915 CandidateSet, SuppressUserConversions,
3917 AllowExplicit == AllowedExplicit::All);
3923 SuppressUserConversions,
3925 AllowExplicit == AllowedExplicit::All);
3932 if (ConstructorsOnly || isa<InitListExpr>(From)) {
3935 }
else if (
const RecordType *FromRecordType =
3938 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3940 const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3941 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3945 if (isa<UsingShadowDecl>(D))
3946 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3950 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3953 Conv = cast<CXXConversionDecl>(D);
3957 ConvTemplate, FoundDecl, ActingContext, From, ToType,
3958 CandidateSet, AllowObjCConversionOnExplicit,
3959 AllowExplicit != AllowedExplicit::None);
3962 CandidateSet, AllowObjCConversionOnExplicit,
3963 AllowExplicit != AllowedExplicit::None);
3968 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3977 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3984 if (isa<InitListExpr>(From)) {
3988 if (Best->Conversions[0].isEllipsis())
3991 User.
Before = Best->Conversions[0].Standard;
4004 = dyn_cast<CXXConversionDecl>(Best->Function)) {
4011 User.
Before = Best->Conversions[0].Standard;
4026 User.
After = Best->FinalConversion;
4029 llvm_unreachable(
"Not a constructor or conversion function?");
4038 llvm_unreachable(
"Invalid OverloadResult!");
4048 CandidateSet, AllowedExplicit::None,
false);
4062 if (!RequireCompleteType(From->
getBeginLoc(), ToType,
4063 diag::err_typecheck_nonviable_condition_incomplete,
4070 *
this, From, Cands);
4096 if (!Conv1 || !Conv2)
4111 if (Block1 != Block2)
4124 if (Conv1FuncRet && Conv2FuncRet &&
4135 CallOpProto->isVariadic(),
false);
4137 CallOpProto->isVariadic(),
true);
4139 CallingConv PrefOrder[] = {DefaultFree, DefaultMember, CallOpCC};
4234 if (!ICS1.
isBad()) {
4235 bool StdInit1 =
false, StdInit2 =
false;
4242 if (StdInit1 != StdInit2)
4253 CAT2->getElementType())) {
4255 if (CAT1->getSize() != CAT2->getSize())
4257 return CAT1->getSize().ult(CAT2->getSize())
4379 return FixedEnumPromotion::None;
4383 return FixedEnumPromotion::None;
4386 if (!
Enum->isFixed())
4387 return FixedEnumPromotion::None;
4391 return FixedEnumPromotion::ToUnderlyingType;
4393 return FixedEnumPromotion::ToPromotedUnderlyingType;
4422 else if (Rank2 < Rank1)
4445 if (FEP1 != FixedEnumPromotion::None && FEP2 != FixedEnumPromotion::None &&
4447 return FEP1 == FixedEnumPromotion::ToUnderlyingType
4457 bool SCS1ConvertsToVoid
4459 bool SCS2ConvertsToVoid
4461 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
4466 }
else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
4472 }
else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
4501 if (FromObjCPtr1 && FromObjCPtr2) {
4506 if (AssignLeft != AssignRight) {
4541 if (UnqualT1 == UnqualT2) {
4553 if (isa<ArrayType>(T1) && T1Quals)
4555 if (isa<ArrayType>(T2) && T2Quals)
4603 if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
4604 return SCS1IsCompatibleVectorConversion
4611 bool SCS1IsCompatibleSVEVectorConversion =
4613 bool SCS2IsCompatibleSVEVectorConversion =
4616 if (SCS1IsCompatibleSVEVectorConversion !=
4617 SCS2IsCompatibleSVEVectorConversion)
4618 return SCS1IsCompatibleSVEVectorConversion
4625 bool SCS1IsCompatibleRVVVectorConversion =
4627 bool SCS2IsCompatibleRVVVectorConversion =
4630 if (SCS1IsCompatibleRVVVectorConversion !=
4631 SCS2IsCompatibleRVVVectorConversion)
4632 return SCS1IsCompatibleRVVVectorConversion
4673 if (UnqualT1 == UnqualT2)
4691 bool ObjCLifetimeConversion;
4701 if (CanPick1 != CanPick2)
4755 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4763 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4780 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4787 bool FromAssignRight
4796 if (ToPtr1->isObjCIdType() &&
4797 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4799 if (ToPtr2->isObjCIdType() &&
4800 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4805 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4807 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4812 if (ToPtr1->isObjCClassType() &&
4813 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4815 if (ToPtr2->isObjCClassType() &&
4816 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4821 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4823 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4829 (ToAssignLeft != ToAssignRight)) {
4840 }
else if (IsSecondSame)
4849 (FromAssignLeft != FromAssignRight))
4863 const Type *FromPointeeType1 = FromMemPointer1->getClass();
4864 const Type *ToPointeeType1 = ToMemPointer1->
getClass();
4865 const Type *FromPointeeType2 = FromMemPointer2->
getClass();
4866 const Type *ToPointeeType2 = ToMemPointer2->
getClass();
4872 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4879 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4917 if (!
T.getQualifiers().hasUnaligned())
4937 "T1 must be the pointee type of the reference type");
4938 assert(!OrigT2->
isReferenceType() &&
"T2 cannot be a reference type");
4962 if (UnqualT1 == UnqualT2) {
4964 }
else if (isCompleteType(Loc, OrigT2) &&
4965 IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4966 Conv |= ReferenceConversions::DerivedToBase;
4970 Conv |= ReferenceConversions::ObjC;
4972 IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2)) {
4973 Conv |= ReferenceConversions::Function;
4975 return Ref_Compatible;
4977 bool ConvertedReferent = Conv != 0;
4981 bool PreviousToQualsIncludeConst =
true;
4982 bool TopLevel =
true;
4988 Conv |= ReferenceConversions::Qualification;
4994 Conv |= ReferenceConversions::NestedQualification;
5002 bool ObjCLifetimeConversion =
false;
5004 PreviousToQualsIncludeConst,
5005 ObjCLifetimeConversion))
5011 if (ObjCLifetimeConversion)
5012 Conv |= ReferenceConversions::ObjCLifetime;
5031 bool AllowExplicit) {
5032 assert(T2->
isRecordType() &&
"Can only find conversions of record types.");
5037 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
5038 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5041 if (isa<UsingShadowDecl>(D))
5042 D = cast<UsingShadowDecl>(D)->getTargetDecl();
5045 = dyn_cast<FunctionTemplateDecl>(D);
5050 Conv = cast<CXXConversionDecl>(D);
5062 if (!ConvTemplate &&
5086 ConvTemplate, I.getPair(), ActingDC,
Init, DeclType, CandidateSet,
5087 false, AllowExplicit);
5090 Conv, I.getPair(), ActingDC,
Init, DeclType, CandidateSet,
5091 false, AllowExplicit);
5094 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5109 if (!Best->FinalConversion.DirectBinding)
5121 "Expected a direct reference binding!");
5127 Cand != CandidateSet.
end(); ++Cand)
5139 llvm_unreachable(
"Invalid OverloadResult!");
5147 bool SuppressUserConversions,
5148 bool AllowExplicit) {
5149 assert(DeclType->
isReferenceType() &&
"Reference init needs a reference");
5176 auto SetAsReferenceBinding = [&](
bool BindsDirectly) {
5181 ICS.
Standard.
Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
5183 : (RefConv & Sema::ReferenceConversions::ObjC)
5191 Sema::ReferenceConversions::NestedQualification)
5205 (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
5228 SetAsReferenceBinding(
true);
5277 SetAsReferenceBinding(S.
getLangOpts().CPlusPlus11 ||
5368 AllowedExplicit::None,
5393 if (isRValRef && LValRefType) {
5411 bool SuppressUserConversions,
5412 bool InOverloadResolution,
5413 bool AllowObjCWritebackConversion,
5414 bool AllowExplicit =
false);
5420 bool SuppressUserConversions,
5421 bool InOverloadResolution,
5422 bool AllowObjCWritebackConversion) {
5435 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
5437 InitTy = IAT->getElementType();
5463 if (From->
getNumInits() == 1 && !IsDesignatedInit) {
5469 SuppressUserConversions,
5470 InOverloadResolution,
5471 AllowObjCWritebackConversion);
5480 Result.Standard.setAsIdentityConversion();
5481 Result.Standard.setFromType(ToType);
5482 Result.Standard.setAllToTypes(ToType);
5507 bool IsUnbounded =
false;
5511 if (CT->getSize().ult(e)) {
5515 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5518 if (CT->getSize().ugt(e)) {
5524 S, &EmptyList, InitTy, SuppressUserConversions,
5525 InOverloadResolution, AllowObjCWritebackConversion);
5526 if (DfltElt.
isBad()) {
5530 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5535 assert(isa<IncompleteArrayType>(AT) &&
"Expected incomplete array");
5541 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5551 Result.Standard.setAsIdentityConversion();
5552 Result.Standard.setFromType(InitTy);
5553 Result.Standard.setAllToTypes(InitTy);
5554 for (
unsigned i = 0; i < e; ++i) {
5557 S,
Init, InitTy, SuppressUserConversions, InOverloadResolution,
5558 AllowObjCWritebackConversion);
5569 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5583 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5597 AllowedExplicit::None,
5598 InOverloadResolution,
false,
5599 AllowObjCWritebackConversion,
5618 Result.UserDefined.Before.setAsIdentityConversion();
5623 Result.UserDefined.After.setAsIdentityConversion();
5624 Result.UserDefined.After.setFromType(ToType);
5625 Result.UserDefined.After.setAllToTypes(ToType);
5626 Result.UserDefined.ConversionFunction =
nullptr;
5643 if (From->
getNumInits() == 1 && !IsDesignatedInit) {
5654 Init, ToType,
false, Found))
5664 SuppressUserConversions,
5672 InOverloadResolution,
5673 AllowObjCWritebackConversion);
5676 assert(!
Result.isEllipsis() &&
5677 "Sub-initialization cannot result in ellipsis conversion.");
5683 Result.UserDefined.After;
5704 if (NumInits == 1 && !isa<InitListExpr>(From->
getInit(0)))
5706 SuppressUserConversions,
5707 InOverloadResolution,
5708 AllowObjCWritebackConversion);
5711 else if (NumInits == 0) {
5713 Result.Standard.setAsIdentityConversion();
5714 Result.Standard.setFromType(ToType);
5715 Result.Standard.setAllToTypes(ToType);
5734 bool SuppressUserConversions,
5735 bool InOverloadResolution,
5736 bool AllowObjCWritebackConversion,
5737 bool AllowExplicit) {
5738 if (
InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
5740 InOverloadResolution,AllowObjCWritebackConversion);
5745 SuppressUserConversions, AllowExplicit);
5748 SuppressUserConversions,
5749 AllowedExplicit::None,
5750 InOverloadResolution,
5752 AllowObjCWritebackConversion,
5765 return !ICS.
isBad();
5774 const CXXRecordDecl *ActingContext,
bool InOverloadResolution =
false,
5776 bool SuppressUserConversion =
false) {
5784 assert(FromClassification.
isLValue());
5796 if (ExplicitParameterType.isNull())
5799 ValueKindFromClassification(FromClassification));
5801 S, &TmpExpr, ExplicitParameterType, SuppressUserConversion,
5819 if (isa<CXXDestructorDecl>(Method) || Method->
isStatic()) {
5856 FromType, ImplicitParamType);
5865 FromType, ImplicitParamType);
5880 FromType, ImplicitParamType);
5900 if (!FromClassification.
isRValue()) {
5940 FromRecordType = From->
getType();
5941 DestType = ImplicitParamRecordType;
5942 FromClassification = From->
Classify(Context);
5946 From = CreateMaterializeTemporaryExpr(FromRecordType, From,
5965 << Method->
getDeclName() << FromRecordType << (CVR - 1)
5976 bool IsRValueQualified =
5980 << IsRValueQualified;
5992 llvm_unreachable(
"Lists are not objects");
5995 return Diag(From->
getBeginLoc(), diag::err_member_function_call_bad_type)
5996 << ImplicitParamRecordType << FromRecordType
6002 PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
6005 From = FromRes.
get();
6014 CK = CK_AddressSpaceConversion;
6017 From = ImpCastExprToType(From, DestType, CK, From->
getValueKind()).get();
6039 AllowedExplicit::Conversions,
6054 return PerformImplicitConversion(From, Context.
BoolTy, ICS, AA_Converting);
6056 if (!DiagnoseMultipleUserDefinedConversion(From, Context.
BoolTy))
6120 llvm_unreachable(
"found a first conversion kind in Second");
6124 llvm_unreachable(
"found a third conversion kind in Second");
6130 llvm_unreachable(
"unknown conversion kind");
6142 "converted constant expression outside C++11");
6175 diag::err_typecheck_converted_constant_expression)
6181 llvm_unreachable(
"bad conversion in converted constant expression");
6187 diag::err_typecheck_converted_constant_expression_disallowed)
6193 diag::err_typecheck_converted_constant_expression_indirect)
6203 diag::err_reference_bind_to_bitfield_in_cce)
6213 "unexpected class type converted constant expr");
6216 T, cast<NonTypeTemplateParmDecl>(Dest)),
6233 bool ReturnPreNarrowingValue =
false;
6236 PreNarrowingType)) {
6249 PreNarrowingValue.
isInt()) {
6252 ReturnPreNarrowingValue =
true;
6264 << CCE << 0 << From->
getType() <<
T;
6267 if (!ReturnPreNarrowingValue)
6268 PreNarrowingValue = {};
6285 if (
Result.isInvalid() ||
Result.get()->isValueDependent()) {
6290 RequireInt, PreNarrowingValue);
6297 return ::BuildConvertedConstantExpression(*
this, From,
T, CCE, Dest,
6304 return ::CheckConvertedConstantExpression(*
this, From,
T,
Value, CCE,
false,
6309 llvm::APSInt &
Value,
6316 if (!R.isInvalid() && !R.get()->isValueDependent())
6327 const APValue &PreNarrowingValue) {
6337 Kind = ConstantExprKind::ClassTemplateArgument;
6339 Kind = ConstantExprKind::NonClassTemplateArgument;
6341 Kind = ConstantExprKind::Normal;
6344 (RequireInt && !Eval.
Val.
isInt())) {
6351 if (Notes.empty()) {
6354 if (
const auto *CE = dyn_cast<ConstantExpr>(E)) {
6358 "ConstantExpr has no value associated with it");
6364 Value = std::move(PreNarrowingValue);
6370 if (Notes.size() == 1 &&
6371 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
6372 Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
6373 }
else if (!Notes.empty() && Notes[0].second.getDiagID() ==
6374 diag::note_constexpr_invalid_template_arg) {
6375 Notes[0].second.setDiagID(diag::err_constexpr_invalid_template_arg);
6376 for (
unsigned I = 0; I < Notes.size(); ++I)
6377 Diag(Notes[I].first, Notes[I].second);
6381 for (
unsigned I = 0; I < Notes.size(); ++I)
6382 Diag(Notes[I].first, Notes[I].second);
6409 AllowedExplicit::Conversions,
6446 return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
6452 assert((isa<UnresolvedMemberExpr, MemberExpr>(MemExprE)) &&
6453 "expected a member expression");
6455 if (
const auto M = dyn_cast<UnresolvedMemberExpr>(MemExprE);
6456 M && !M->isImplicitAccess())
6457 Base = M->getBase();
6458 else if (
const auto M = dyn_cast<MemberExpr>(MemExprE);
6459 M && !M->isImplicitAccess())
6460 Base = M->getBase();
6499 "Method is not an explicit member function");
6500 assert(NewArgs.empty() &&
"NewArgs should be empty");
6501 NewArgs.reserve(Args.size() + 1);
6503 NewArgs.push_back(This);
6504 NewArgs.append(Args.begin(), Args.end());
6524 for (
unsigned I = 0, N = ViableConversions.
size(); I != N; ++I) {
6526 cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
6538 if (ExplicitConversions.
size() == 1 && !Converter.
Suppress) {
6546 std::string TypeStr;
6551 "static_cast<" + TypeStr +
">(")
6563 HadMultipleCandidates);
6568 CK_UserDefinedConversion,
Result.get(),
6569 nullptr,
Result.get()->getValueKind(),
6593 HadMultipleCandidates);
6598 CK_UserDefinedConversion,
Result.get(),
6599 nullptr,
Result.get()->getValueKind(),
6618 for (
unsigned I = 0, N = ViableConversions.
size(); I != N; ++I) {
6622 if (isa<UsingShadowDecl>(D))
6623 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6627 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
6630 Conv = cast<CXXConversionDecl>(D);
6634 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
6638 ToType, CandidateSet,
6670 ExprResult result = CheckPlaceholderExpr(From);
6673 From = result.
get();
6677 ExprResult Converted = DefaultLvalueConversion(From);
6688 if (!RecordTy || !getLangOpts().CPlusPlus) {
6700 : Converter(Converter), From(From) {}
6705 } IncompleteDiagnoser(Converter, From);
6707 if (Converter.
Suppress ? !isCompleteType(Loc,
T)
6708 : RequireCompleteType(Loc,
T, IncompleteDiagnoser))
6715 const auto &Conversions =
6716 cast<CXXRecordDecl>(RecordTy->
getDecl())->getVisibleConversionFunctions();
6718 bool HadMultipleCandidates =
6719 (std::distance(Conversions.begin(), Conversions.end()) > 1);
6723 bool HasUniqueTargetType =
true;
6726 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
6736 Conversion = cast<CXXConversionDecl>(D);
6738 assert((!ConvTemplate || getLangOpts().
CPlusPlus14) &&
6739 "Conversion operator templates are considered potentially "
6743 if (Converter.
match(CurToType) || ConvTemplate) {
6749 ExplicitConversions.
addDecl(I.getDecl(), I.getAccess());
6754 else if (HasUniqueTargetType &&
6756 HasUniqueTargetType =
false;
6758 ViableConversions.
addDecl(I.getDecl(), I.getAccess());
6776 HadMultipleCandidates,
6777 ExplicitConversions))
6783 if (!HasUniqueTargetType)
6802 HadMultipleCandidates, Found))
6811 HadMultipleCandidates,
6812 ExplicitConversions))
6820 switch (ViableConversions.
size()) {
6823 HadMultipleCandidates,
6824 ExplicitConversions))
6834 HadMultipleCandidates, Found))
6865 if (Proto->getNumParams() < 1)
6869 QualType ArgType = Proto->getParamType(0).getNonReferenceType();
6874 if (Proto->getNumParams() < 2)
6878 QualType ArgType = Proto->getParamType(1).getNonReferenceType();
6898 unsigned SeenAt = 0;
6900 bool HasDefault =
false;
6909 return HasDefault || SeenAt != 0;
6923 bool PartialOverloading,
bool AllowExplicit,
bool AllowExplicitConversions,
6928 assert(Proto &&
"Functions without a prototype cannot be overloaded");
6929 assert(!
Function->getDescribedFunctionTemplate() &&
6930 "Use AddTemplateOverloadCandidate for function templates");
6933 if (!isa<CXXConstructorDecl>(Method)) {
6943 CandidateSet, SuppressUserConversions,
6944 PartialOverloading, EarlyConversions, PO);
6958 if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
6959 Constructor->isMoveConstructor())
6979 CandidateSet.
addCandidate(Args.size(), EarlyConversions);
6994 Candidate.
Viable =
false;
7000 if (getLangOpts().CPlusPlusModules &&
Function->isInAnotherModuleUnit()) {
7007 if (
auto *SpecInfo =
Function->getTemplateSpecializationInfo())
7008 ND = SpecInfo->getTemplate();
7011 Candidate.
Viable =
false;
7018 Candidate.
Viable =
false;
7028 if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
7030 IsDerivedFrom(Args[0]->getBeginLoc(), Args[0]->getType(),
7032 Candidate.
Viable =
false;
7044 auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
7045 if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
7046 Constructor->getParamDecl(0)->getType()->isReferenceType()) {
7047 QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
7053 Candidate.
Viable =
false;
7062 Constructor->getMethodQualifiers().getAddressSpace(),
7064 Candidate.
Viable =
false;
7077 Candidate.
Viable =
false;
7087 unsigned MinRequiredArgs =
Function->getMinRequiredArguments();
7088 if (!AggregateCandidateDeduction && Args.size() < MinRequiredArgs &&
7089 !PartialOverloading) {
7091 Candidate.
Viable =
false;
7097 if (getLangOpts().
CUDA) {
7105 Candidate.
Viable =
false;
7111 if (
Function->getTrailingRequiresClause()) {
7113 if (CheckFunctionConstraints(
Function, Satisfaction, {},
7116 Candidate.
Viable =
false;
7124 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7127 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7130 }
else if (ArgIdx < NumParams) {
7137 *
this, Args[ArgIdx], ParamType, SuppressUserConversions,
7140 getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
7142 Candidate.
Viable =
false;
7154 if (EnableIfAttr *FailedAttr =
7156 Candidate.
Viable =
false;
7166 if (Methods.size() <= 1)
7169 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7177 if (Args.size() < NumNamedArgs)
7180 for (
unsigned i = 0; i < NumNamedArgs; i++) {
7182 if (Args[i]->isTypeDependent()) {
7188 Expr *argExpr = Args[i];
7189 assert(argExpr &&
"SelectBestMethod(): missing expression");
7194 !param->
hasAttr<CFConsumedAttr>())
7195 argExpr = stripARCUnbridgedCast(argExpr);
7208 getLangOpts().ObjCAutoRefCount,
7212 if (ConversionState.
isBad() ||
7222 for (
unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
7223 if (Args[i]->isTypeDependent()) {
7227 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
7236 if (Args.size() != NumNamedArgs)
7238 else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
7241 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7242 QualType ReturnT = Methods[
b]->getReturnType();
7261 assert(!isa<CXXConstructorDecl>(Method) &&
7262 "Shouldn't have `this` for ctors!");
7263 assert(!Method->
isStatic() &&
"Shouldn't have `this` for static methods!");
7265 ThisArg,
nullptr, Method, Method);
7268 ConvertedThis = R.
get();
7270 if (
auto *MD = dyn_cast<CXXMethodDecl>(
Function)) {
7272 assert((MissingImplicitThis || MD->isStatic() ||
7273 isa<CXXConstructorDecl>(MD)) &&
7274 "Expected `this` for non-ctor instance methods");
7276 ConvertedThis =
nullptr;
7281 unsigned ArgSizeNoVarargs = std::min(
Function->param_size(), Args.size());
7284 for (
unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
7293 ConvertedArgs.push_back(R.
get());
7301 for (
unsigned i = Args.size(), e =
Function->getNumParams(); i != e; ++i) {
7303 if (!
P->hasDefaultArg())
7308 ConvertedArgs.push_back(R.
get());
7320 bool MissingImplicitThis) {
7321 auto EnableIfAttrs =
Function->specific_attrs<EnableIfAttr>();
7322 if (EnableIfAttrs.begin() == EnableIfAttrs.end())
7328 Expr *DiscardedThis;
7330 *
this,
Function,
nullptr, CallLoc, Args, Trap,
7331 true, DiscardedThis, ConvertedArgs))
7332 return *EnableIfAttrs.begin();
7334 for (
auto *EIA : EnableIfAttrs) {
7338 if (EIA->getCond()->isValueDependent() ||
7339 !EIA->getCond()->EvaluateWithSubstitution(
7343 if (!
Result.isInt() || !
Result.getInt().getBoolValue())
7349template <
typename CheckFn>
7352 CheckFn &&IsSuccessful) {
7355 if (ArgDependent == DIA->getArgDependent())
7356 Attrs.push_back(DIA);
7363 auto WarningBegin = std::stable_partition(
7364 Attrs.begin(), Attrs.end(),
7365 [](
const DiagnoseIfAttr *DIA) { return DIA->isError(); });
7369 auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
7371 if (ErrAttr != WarningBegin) {
7372 const DiagnoseIfAttr *DIA = *ErrAttr;
7373 S.
Diag(Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
7374 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7375 << DIA->getParent() << DIA->getCond()->getSourceRange();
7379 for (
const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
7380 if (IsSuccessful(DIA)) {
7381 S.
Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
7382 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7383 << DIA->getParent() << DIA->getCond()->getSourceRange();
7390 const Expr *ThisArg,
7395 [&](
const DiagnoseIfAttr *DIA) {
7400 if (!DIA->getCond()->EvaluateWithSubstitution(
7401 Result, Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
7403 return Result.isInt() &&
Result.getInt().getBoolValue();
7410 *
this, ND,
false, Loc,
7411 [&](
const DiagnoseIfAttr *DIA) {
7424 bool SuppressUserConversions,
7425 bool PartialOverloading,
7426 bool FirstArgumentIsBase) {
7435 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
7438 if (Args.size() > 0) {
7439 if (
Expr *E = Args[0]) {
7441 ObjectType = E->getType();
7447 ObjectClassification = E->Classify(Context);
7449 FunctionArgs = Args.slice(1);
7452 AddMethodTemplateCandidate(
7453 FunTmpl, F.getPair(),
7455 ExplicitTemplateArgs, ObjectType, ObjectClassification,
7456 FunctionArgs, CandidateSet, SuppressUserConversions,
7457 PartialOverloading);
7459 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
7460 cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
7461 ObjectClassification, FunctionArgs, CandidateSet,
7462 SuppressUserConversions, PartialOverloading);
7469 if (Args.size() > 0 &&
7470 (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
7471 !isa<CXXConstructorDecl>(FD)))) {
7472 assert(cast<CXXMethodDecl>(FD)->isStatic());
7473 FunctionArgs = Args.slice(1);
7476 AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
7477 ExplicitTemplateArgs, FunctionArgs,
7478 CandidateSet, SuppressUserConversions,
7479 PartialOverloading);
7481 AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet,
7482 SuppressUserConversions, PartialOverloading);
7494 bool SuppressUserConversions,
7499 if (isa<UsingShadowDecl>(
Decl))
7500 Decl = cast<UsingShadowDecl>(
Decl)->getTargetDecl();
7503 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
7504 "Expected a member function template");
7505 AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
7506 nullptr, ObjectType,
7507 ObjectClassification, Args, CandidateSet,
7508 SuppressUserConversions,
false, PO);
7510 AddMethodCandidate(cast<CXXMethodDecl>(
Decl), FoundDecl, ActingContext,
7511 ObjectType, ObjectClassification, Args, CandidateSet,
7512 SuppressUserConversions,
false, std::nullopt, PO);
7529 bool SuppressUserConversions,
7530 bool PartialOverloading,
7535 assert(Proto &&
"Methods without a prototype cannot be overloaded");
7536 assert(!isa<CXXConstructorDecl>(Method) &&
7537 "Use AddOverloadCandidate for constructors");
7555 CandidateSet.
addCandidate(Args.size() + 1, EarlyConversions);
7573 Candidate.
Viable =
false;
7584 if (Args.size() < MinRequiredArgs && !PartialOverloading) {
7586 Candidate.
Viable =
false;
7606 Candidate.
Conversions[FirstConvIdx].setStaticObjectArgument();
7611 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7612 Method, ActingContext,
true);
7613 if (Candidate.
Conversions[FirstConvIdx].isBad()) {
7614 Candidate.
Viable =
false;
7621 if (getLangOpts().
CUDA)
7622 if (!
CUDA().IsAllowedCall(getCurFunctionDecl(
true),
7624 Candidate.
Viable =
false;
7631 if (CheckFunctionConstraints(Method, Satisfaction, {},
7634 Candidate.
Viable =
false;
7642 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7645 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7648 }
else if (ArgIdx < NumParams) {
7656 SuppressUserConversions,
7659 getLangOpts().ObjCAutoRefCount);
7661 Candidate.
Viable =
false;
7673 if (EnableIfAttr *FailedAttr =
7674 CheckEnableIf(Method, CandidateSet.
getLocation(), Args,
true)) {
7675 Candidate.
Viable =
false;
7682 Candidate.
Viable =
false;
7714 PartialOverloading,
false, ObjectType,
7715 ObjectClassification,
7717 return CheckNonDependentConversions(
7718 MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
7719 SuppressUserConversions, ActingContext, ObjectType,
7720 ObjectClassification, PO);
7724 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7727 Candidate.
Viable =
false;
7732 cast<CXXMethodDecl>(Candidate.
Function)->isStatic() ||
7747 assert(
Specialization &&
"Missing member function template specialization?");
7749 "Specialization is not a member function?");
7750 AddMethodCandidate(cast<CXXMethodDecl>(
Specialization), FoundDecl,
7751 ActingContext, ObjectType, ObjectClassification, Args,
7752 CandidateSet, SuppressUserConversions, PartialOverloading,
7769 bool PartialOverloading,
bool AllowExplicit,
ADLCallKind IsADLCandidate,
7781 Candidate.
Viable =
false;
7800 FunctionTemplate, ExplicitTemplateArgs, Args,
Specialization, Info,
7801 PartialOverloading, AggregateCandidateDeduction,
7805 return CheckNonDependentConversions(
7806 FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions,
7807 SuppressUserConversions,
nullptr,
QualType(), {}, PO);
7811 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7814 Candidate.
Viable =
false;
7822 isa<CXXMethodDecl>(Candidate.
Function) &&
7823 !isa<CXXConstructorDecl>(Candidate.
Function);
7837 assert(
Specialization &&
"Missing function template specialization?");
7838 AddOverloadCandidate(
7839 Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
7840 PartialOverloading, AllowExplicit,
7841 false, IsADLCandidate, Conversions, PO,
7857 const bool AllowExplicit =
false;
7860 auto *Method = dyn_cast<CXXMethodDecl>(FD);
7861 bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
7862 unsigned ThisConversions = HasThisConversion ? 1 : 0;
7874 if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
7877 if (!FD->hasCXXExplicitFunctionObjectParameter() ||
7878 !ParamTypes[0]->isDependentType()) {
7880 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7881 Method, ActingContext,
true,
7882 FD->hasCXXExplicitFunctionObjectParameter() ? ParamTypes[0]
7884 if (Conversions[ConvIdx].isBad())
7890 Method && Method->hasCXXExplicitFunctionObjectParameter() ? 1 : 0;
7892 for (
unsigned I = 0, N = std::min(ParamTypes.size() - Offset, Args.size());
7894 QualType ParamType = ParamTypes[I + Offset];
7898 ConvIdx = Args.size() - 1 - I;
7899 assert(Args.size() + ThisConversions == 2 &&
7900 "number of args (including 'this') must be exactly 2 for "
7904 assert(!HasThisConversion || (ConvIdx == 0 && I == 0));
7907 ConvIdx = ThisConversions + I;
7909 Conversions[ConvIdx]
7911 SuppressUserConversions,
7914 getLangOpts().ObjCAutoRefCount,
7916 if (Conversions[ConvIdx].isBad())
7938 bool AllowObjCPointerConversion) {
7946 bool ObjCLifetimeConversion;
7948 ObjCLifetimeConversion))
7953 if (!AllowObjCPointerConversion)
7957 bool IncompatibleObjC =
false;
7973 bool AllowExplicit,
bool AllowResultConversion) {
7975 "Conversion function templates use AddTemplateConversionCandidate");
7983 if (DeduceReturnType(Conversion, From->
getExprLoc()))
7990 if (!AllowResultConversion &&
8002 AllowObjCConversionOnExplicit))
8024 if (!AllowExplicit && Conversion->
isExplicit()) {
8025 Candidate.
Viable =
false;
8040 const auto *ConversionContext =
8049 From->
Classify(Context), Conversion, ConversionContext,
8054 Candidate.
Viable =
false;
8061 if (CheckFunctionConstraints(Conversion, Satisfaction) ||
8063 Candidate.
Viable =
false;
8075 if (FromCanon == ToCanon ||
8076 IsDerivedFrom(CandidateSet.
getLocation(), FromCanon, ToCanon)) {
8077 Candidate.
Viable =
false;
8094 CK_FunctionToPointerDecay, &ConversionRef,
8098 if (!isCompleteType(From->
getBeginLoc(), ConversionType)) {
8099 Candidate.
Viable =
false;
8113 Buffer, &ConversionFn, CallResultType, VK, From->
getBeginLoc());
8131 Candidate.
Viable =
false;
8143 Candidate.
Viable =
false;
8150 Candidate.
Viable =
false;
8156 "Can only end up with a standard conversion sequence or failure");
8159 if (EnableIfAttr *FailedAttr =
8160 CheckEnableIf(Conversion, CandidateSet.
getLocation(), std::nullopt)) {
8161 Candidate.
Viable =
false;
8168 Candidate.
Viable =
false;
8182 bool AllowExplicit,
bool AllowResultConversion) {
8184 "Only conversion function templates permitted here");
8196 Candidate.
Viable =
false;
8207 FunctionTemplate, ObjectType, ObjectClassification, ToType,
8213 Candidate.
Viable =
false;
8225 assert(
Specialization &&
"Missing function template specialization?");
8226 AddConversionCandidate(
Specialization, FoundDecl, ActingDC, From, ToType,
8227 CandidateSet, AllowObjCConversionOnExplicit,
8228 AllowExplicit, AllowResultConversion);
8269 *
this, CandidateSet.
getLocation(), Object->getType(),
8270 Object->Classify(Context), Conversion, ActingContext);
8273 if (ObjectInit.
isBad()) {
8274 Candidate.
Viable =
false;
8285 Candidate.
Conversions[0].UserDefined.EllipsisConversion =
false;
8286 Candidate.
Conversions[0].UserDefined.HadMultipleCandidates =
false;
8287 Candidate.
Conversions[0].UserDefined.ConversionFunction = Conversion;
8288 Candidate.
Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
8291 Candidate.
Conversions[0].UserDefined.After.setAsIdentityConversion();
8299 if (Args.size() > NumParams && !Proto->
isVariadic()) {
8300 Candidate.
Viable =
false;
8307 if (Args.size() < NumParams) {
8309 Candidate.
Viable =
false;
8316 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8317 if (ArgIdx < NumParams) {
8328 getLangOpts().ObjCAutoRefCount);
8330 Candidate.
Viable =
false;
8344 if (CheckFunctionConstraints(Conversion, Satisfaction, {},
8347 Candidate.
Viable =
false;
8353 if (EnableIfAttr *FailedAttr =
8354 CheckEnableIf(Conversion, CandidateSet.
getLocation(), std::nullopt)) {
8355 Candidate.
Viable =
false;
8380 assert(!isa<CXXMethodDecl>(FD) &&
8381 "unqualified operator lookup found a member function");
8384 AddTemplateOverloadCandidate(FunTmpl, F.getPair(), ExplicitTemplateArgs,
8385 FunctionArgs, CandidateSet);
8387 AddTemplateOverloadCandidate(
8388 FunTmpl, F.getPair(), ExplicitTemplateArgs,
8389 {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
false,
false,
8392 if (ExplicitTemplateArgs)
8394 AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet);
8396 AddOverloadCandidate(
8397 FD, F.getPair(), {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
8398 false,
false,
true,
false, ADLCallKind::NotADL, std::nullopt,
8435 if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
8438 if (!T1Rec->getDecl()->getDefinition())
8441 LookupResult Operators(*
this, OpName, OpLoc, LookupOrdinaryName);
8442 LookupQualifiedName(Operators, T1Rec->getDecl());
8446 OperEnd = Operators.
end();
8447 Oper != OperEnd; ++Oper) {
8448 if (Oper->getAsFunction() &&
8451 *
this, {Args[1], Args[0]}, Oper->getAsFunction()))
8453 AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
8454 Args[0]->Classify(Context), Args.slice(1),
8455 CandidateSet,
false, PO);
8470 bool IsAssignmentOperator,
8471 unsigned NumContextualBoolArguments) {
8488 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8501 if (ArgIdx < NumContextualBoolArguments) {
8502 assert(ParamTys[ArgIdx] == Context.
BoolTy &&
8503 "Contextual conversion to bool requires bool type");
8509 ArgIdx == 0 && IsAssignmentOperator,
8512 getLangOpts().ObjCAutoRefCount);
8515 Candidate.
Viable =
false;
8528class BuiltinCandidateTypeSet {
8534 TypeSet PointerTypes;
8538 TypeSet MemberPointerTypes;
8542 TypeSet EnumerationTypes;
8546 TypeSet VectorTypes;
8550 TypeSet MatrixTypes;
8553 TypeSet BitIntTypes;
8556 bool HasNonRecordTypes;
8560 bool HasArithmeticOrEnumeralTypes;
8564 bool HasNullPtrType;
8573 bool AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8575 bool AddMemberPointerWithMoreQualifiedTypeVariants(
QualType Ty);
8579 typedef TypeSet::iterator iterator;
8581 BuiltinCandidateTypeSet(
Sema &SemaRef)
8582 : HasNonRecordTypes(
false),
8583 HasArithmeticOrEnumeralTypes(
false),
8584 HasNullPtrType(
false),
8586 Context(SemaRef.Context) { }
8588 void AddTypesConvertedFrom(
QualType Ty,
8590 bool AllowUserConversions,
8591 bool AllowExplicitConversions,
8592 const Qualifiers &VisibleTypeConversionsQuals);
8594 llvm::iterator_range<iterator> pointer_types() {
return PointerTypes; }
8595 llvm::iterator_range<iterator> member_pointer_types() {
8596 return MemberPointerTypes;
8598 llvm::iterator_range<iterator> enumeration_types() {
8599 return EnumerationTypes;
8601 llvm::iterator_range<iterator> vector_types() {
return VectorTypes; }
8602 llvm::iterator_range<iterator> matrix_types() {
return MatrixTypes; }
8603 llvm::iterator_range<iterator> bitint_types() {
return BitIntTypes; }
8605 bool containsMatrixType(
QualType Ty)
const {
return MatrixTypes.count(Ty); }
8606 bool hasNonRecordTypes() {
return HasNonRecordTypes; }
8607 bool hasArithmeticOrEnumeralTypes() {
return HasArithmeticOrEnumeralTypes; }
8608 bool hasNullPtrType()
const {
return HasNullPtrType; }
8623BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8627 if (!PointerTypes.insert(Ty))
8632 bool buildObjCPtr =
false;
8636 buildObjCPtr =
true;
8648 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
8654 if ((CVR | BaseCVR) != CVR)
continue;
8676 PointerTypes.insert(QPointerTy);
8692BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
8695 if (!MemberPointerTypes.insert(Ty))
8699 assert(PointerTy &&
"type was not a member pointer type!");
8714 if ((CVR | BaseCVR) != CVR)
continue;
8717 MemberPointerTypes.insert(
8733BuiltinCandidateTypeSet::AddTypesConvertedFrom(
QualType Ty,
8735 bool AllowUserConversions,
8736 bool AllowExplicitConversions,
8748 Ty = SemaRef.Context.getArrayDecayedType(Ty);
8755 HasNonRecordTypes = HasNonRecordTypes || !TyRec;
8758 HasArithmeticOrEnumeralTypes =
8762 PointerTypes.insert(Ty);
8766 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
8770 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
8773 HasArithmeticOrEnumeralTypes =
true;
8774 EnumerationTypes.insert(Ty);
8776 HasArithmeticOrEnumeralTypes =
true;
8777 BitIntTypes.insert(Ty);
8781 HasArithmeticOrEnumeralTypes =
true;
8782 VectorTypes.insert(Ty);
8786 HasArithmeticOrEnumeralTypes =
true;
8787 MatrixTypes.insert(Ty);
8789 HasNullPtrType =
true;
8790 }
else if (AllowUserConversions && TyRec) {
8792 if (!SemaRef.isCompleteType(Loc, Ty))
8797 if (isa<UsingShadowDecl>(D))
8798 D = cast<UsingShadowDecl>(D)->getTargetDecl();
8802 if (isa<FunctionTemplateDecl>(D))
8806 if (AllowExplicitConversions || !Conv->
isExplicit()) {
8869 if (isa<UsingShadowDecl>(D))
8870 D = cast<UsingShadowDecl>(D)->getTargetDecl();
8904 if (Available.hasAtomic()) {
8905 Available.removeAtomic();
8912 if (Available.hasVolatile()) {
8913 Available.removeVolatile();
8947class BuiltinOperatorOverloadBuilder {
8952 bool HasArithmeticOrEnumeralCandidateType;
8956 static constexpr int ArithmeticTypesCap = 26;
8962 unsigned FirstIntegralType,
8964 unsigned FirstPromotedIntegralType,
8965 LastPromotedIntegralType;
8966 unsigned FirstPromotedArithmeticType,
8967 LastPromotedArithmeticType;
8968 unsigned NumArithmeticTypes;
8970 void InitArithmeticTypes() {
8972 FirstPromotedArithmeticType = 0;
8982 FirstIntegralType = ArithmeticTypes.size();
8983 FirstPromotedIntegralType = ArithmeticTypes.size();
9006 llvm::for_each(CandidateTypes, [&BitIntCandidates](
9007 BuiltinCandidateTypeSet &Candidate) {
9008 for (
QualType BitTy : Candidate.bitint_types())
9011 llvm::move(BitIntCandidates, std::back_inserter(ArithmeticTypes));
9012 LastPromotedIntegralType = ArithmeticTypes.size();
9013 LastPromotedArithmeticType = ArithmeticTypes.size();
9027 LastIntegralType = ArithmeticTypes.size();
9028 NumArithmeticTypes = ArithmeticTypes.size();
9035 assert(ArithmeticTypes.size() - BitIntCandidates.size() <=
9036 ArithmeticTypesCap &&
9037 "Enough inline storage for all arithmetic types.");
9042 void addPlusPlusMinusMinusStyleOverloads(
QualType CandidateTy,
9091 BuiltinOperatorOverloadBuilder(
9094 bool HasArithmeticOrEnumeralCandidateType,
9098 VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
9099 HasArithmeticOrEnumeralCandidateType(
9100 HasArithmeticOrEnumeralCandidateType),
9101 CandidateTypes(CandidateTypes),
9102 CandidateSet(CandidateSet) {
9104 InitArithmeticTypes();
9127 if (!HasArithmeticOrEnumeralCandidateType)
9130 for (
unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
9131 const auto TypeOfT = ArithmeticTypes[Arith];
9133 if (Op == OO_MinusMinus)
9135 if (Op == OO_PlusPlus && S.
getLangOpts().CPlusPlus17)
9138 addPlusPlusMinusMinusStyleOverloads(
9155 void addPlusPlusMinusMinusPointerOverloads() {
9156 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9158 if (!PtrTy->getPointeeType()->isObjectType())
9161 addPlusPlusMinusMinusStyleOverloads(
9163 (!PtrTy.isVolatileQualified() &&
9165 (!PtrTy.isRestrictQualified() &&
9180 void addUnaryStarPointerOverloads() {
9181 for (
QualType ParamTy : CandidateTypes[0].pointer_types()) {
9187 if (Proto->getMethodQuals() || Proto->getRefQualifier())
9200 void addUnaryPlusOrMinusArithmeticOverloads() {
9201 if (!HasArithmeticOrEnumeralCandidateType)
9204 for (
unsigned Arith = FirstPromotedArithmeticType;
9205 Arith < LastPromotedArithmeticType; ++Arith) {
9206 QualType ArithTy = ArithmeticTypes[Arith];
9211 for (
QualType VecTy : CandidateTypes[0].vector_types())
9220 void addUnaryPlusPointerOverloads() {
9221 for (
QualType ParamTy : CandidateTypes[0].pointer_types())
9230 void addUnaryTildePromotedIntegralOverloads() {
9231 if (!HasArithmeticOrEnumeralCandidateType)
9234 for (
unsigned Int = FirstPromotedIntegralType;
9235 Int < LastPromotedIntegralType; ++
Int) {
9241 for (
QualType VecTy : CandidateTypes[0].vector_types())
9251 void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
9255 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9256 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9261 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9265 if (CandidateTypes[ArgIdx].hasNullPtrType()) {
9267 if (AddedTypes.insert(NullPtrTy).second) {
9268 QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
9287 void addGenericBinaryPointerOrEnumeralOverloads(
bool IsSpaceship) {
9301 UserDefinedBinaryOperators;
9303 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9304 if (!CandidateTypes[ArgIdx].enumeration_types().empty()) {
9306 CEnd = CandidateSet.
end();
9308 if (!
C->Viable || !
C->Function ||
C->Function->getNumParams() != 2)
9311 if (
C->Function->isFunctionTemplateSpecialization())
9320 .getUnqualifiedType();
9323 .getUnqualifiedType();
9331 UserDefinedBinaryOperators.insert(
9341 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9342 for (
QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9346 if (IsSpaceship && PtrTy->isFunctionPointerType())
9349 QualType ParamTypes[2] = {PtrTy, PtrTy};
9352 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9357 if (!AddedTypes.insert(CanonType).second ||
9358 UserDefinedBinaryOperators.count(std::make_pair(CanonType,
9361 QualType ParamTypes[2] = {EnumTy, EnumTy};
9388 for (
int Arg = 0; Arg < 2; ++Arg) {
9389 QualType AsymmetricParamTypes[2] = {
9393 for (
QualType PtrTy : CandidateTypes[Arg].pointer_types()) {
9398 AsymmetricParamTypes[Arg] = PtrTy;
9399 if (Arg == 0 || Op == OO_Plus) {
9404 if (Op == OO_Minus) {
9409 QualType ParamTypes[2] = {PtrTy, PtrTy};
9445 void addGenericBinaryArithmeticOverloads() {
9446 if (!HasArithmeticOrEnumeralCandidateType)
9449 for (
unsigned Left = FirstPromotedArithmeticType;
9450 Left < LastPromotedArithmeticType; ++Left) {
9451 for (
unsigned Right = FirstPromotedArithmeticType;
9452 Right < LastPromotedArithmeticType; ++Right) {
9453 QualType LandR[2] = { ArithmeticTypes[Left],
9454 ArithmeticTypes[Right] };
9461 for (
QualType Vec1Ty : CandidateTypes[0].vector_types())
9462 for (
QualType Vec2Ty : CandidateTypes[1].vector_types()) {
9463 QualType LandR[2] = {Vec1Ty, Vec2Ty};
9473 void addMatrixBinaryArithmeticOverloads() {
9474 if (!HasArithmeticOrEnumeralCandidateType)
9477 for (
QualType M1 : CandidateTypes[0].matrix_types()) {
9478 AddCandidate(M1, cast<MatrixType>(M1)->getElementType());
9479 AddCandidate(M1, M1);
9482 for (
QualType M2 : CandidateTypes[1].matrix_types()) {
9483 AddCandidate(cast<MatrixType>(M2)->getElementType(), M2);
9484 if (!CandidateTypes[0].containsMatrixType(M2))
9485 AddCandidate(M2, M2);
9520 void addThreeWayArithmeticOverloads() {
9521 addGenericBinaryArithmeticOverloads();
9538 void addBinaryBitwiseArithmeticOverloads() {
9539 if (!HasArithmeticOrEnumeralCandidateType)
9542 for (
unsigned Left = FirstPromotedIntegralType;
9543 Left < LastPromotedIntegralType; ++Left) {
9544 for (
unsigned Right = FirstPromotedIntegralType;
9545 Right < LastPromotedIntegralType; ++Right) {
9546 QualType LandR[2] = { ArithmeticTypes[Left],
9547 ArithmeticTypes[Right] };
9560 void addAssignmentMemberPointerOrEnumeralOverloads() {
9564 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9565 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9572 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9597 void addAssignmentPointerOverloads(
bool isEqualOp) {
9601 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9605 else if (!PtrTy->getPointeeType()->isObjectType())
9616 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9626 if (!PtrTy.isRestrictQualified() &&
9646 for (
QualType PtrTy : CandidateTypes[1].pointer_types()) {
9660 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9670 if (!PtrTy.isRestrictQualified() &&
9703 void addAssignmentArithmeticOverloads(
bool isEqualOp) {
9704 if (!HasArithmeticOrEnumeralCandidateType)
9707 for (
unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
9708 for (
unsigned Right = FirstPromotedArithmeticType;
9709 Right < LastPromotedArithmeticType; ++Right) {
9711 ParamTypes[1] = ArithmeticTypes[Right];
9713 S, ArithmeticTypes[Left], Args[0]);
9726 for (
QualType Vec1Ty : CandidateTypes[0].vector_types())
9727 for (
QualType Vec2Ty : CandidateTypes[0].vector_types()) {
9729 ParamTypes[1] = Vec2Ty;
9757 void addAssignmentIntegralOverloads() {
9758 if (!HasArithmeticOrEnumeralCandidateType)
9761 for (
unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
9762 for (
unsigned Right = FirstPromotedIntegralType;
9763 Right < LastPromotedIntegralType; ++Right) {
9765 ParamTypes[1] = ArithmeticTypes[Right];
9767 S, ArithmeticTypes[Left], Args[0]);
9786 void addExclaimOverload() {
9792 void addAmpAmpOrPipePipeOverload() {
9809 void addSubscriptOverloads() {
9810 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9820 for (
QualType PtrTy : CandidateTypes[1].pointer_types()) {
9840 void addArrowStarOverloads() {
9841 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9846 if (!isa<RecordType>(C1))
9855 for (
QualType MemPtrTy : CandidateTypes[1].member_pointer_types()) {
9861 QualType ParamTypes[2] = {PtrTy, MemPtrTy};
9865 T.isVolatileQualified())
9868 T.isRestrictQualified())
9886 void addConditionalOperatorOverloads() {
9890 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9891 for (
QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9895 QualType ParamTypes[2] = {PtrTy, PtrTy};
9899 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9903 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9908 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9915 QualType ParamTypes[2] = {EnumTy, EnumTy};
9939 VisibleTypeConversionsQuals.
addConst();
9940 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9942 if (Args[ArgIdx]->getType()->isAtomicType())
9943 VisibleTypeConversionsQuals.
addAtomic();
9946 bool HasNonRecordCandidateType =
false;
9947 bool HasArithmeticOrEnumeralCandidateType =
false;
9949 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9950 CandidateTypes.emplace_back(*
this);
9951 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
9954 (Op == OO_Exclaim ||
9957 VisibleTypeConversionsQuals);
9958 HasNonRecordCandidateType = HasNonRecordCandidateType ||
9959 CandidateTypes[ArgIdx].hasNonRecordTypes();
9960 HasArithmeticOrEnumeralCandidateType =
9961 HasArithmeticOrEnumeralCandidateType ||
9962 CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
9970 if (!HasNonRecordCandidateType &&
9971 !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
9975 BuiltinOperatorOverloadBuilder OpBuilder(*
this, Args,
9976 VisibleTypeConversionsQuals,
9977 HasArithmeticOrEnumeralCandidateType,
9978 CandidateTypes, CandidateSet);
9984 llvm_unreachable(
"Expected an overloaded operator");
9989 case OO_Array_Delete:
9992 "Special operators don't use AddBuiltinOperatorCandidates");
10004 if (Args.size() == 1)
10005 OpBuilder.addUnaryPlusPointerOverloads();
10009 if (Args.size() == 1) {
10010 OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
10012 OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
10013 OpBuilder.addGenericBinaryArithmeticOverloads();
10014 OpBuilder.addMatrixBinaryArithmeticOverloads();
10019 if (Args.size() == 1)
10020 OpBuilder.addUnaryStarPointerOverloads();
10022 OpBuilder.addGenericBinaryArithmeticOverloads();
10023 OpBuilder.addMatrixBinaryArithmeticOverloads();
10028 OpBuilder.addGenericBinaryArithmeticOverloads();
10032 case OO_MinusMinus:
10033 OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
10034 OpBuilder.addPlusPlusMinusMinusPointerOverloads();
10037 case OO_EqualEqual:
10038 case OO_ExclaimEqual:
10039 OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
10040 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10041 OpBuilder.addGenericBinaryArithmeticOverloads();
10047 case OO_GreaterEqual:
10048 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10049 OpBuilder.addGenericBinaryArithmeticOverloads();
10053 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
true);
10054 OpBuilder.addThreeWayArithmeticOverloads();
10061 case OO_GreaterGreater:
10062 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10066 if (Args.size() == 1)
10072 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10076 OpBuilder.addUnaryTildePromotedIntegralOverloads();
10080 OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
10084 case OO_MinusEqual:
10085 OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
10089 case OO_SlashEqual:
10090 OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
10093 case OO_PercentEqual:
10094 case OO_LessLessEqual:
10095 case OO_GreaterGreaterEqual:
10097 case OO_CaretEqual:
10099 OpBuilder.addAssignmentIntegralOverloads();
10103 OpBuilder.addExclaimOverload();
10108 OpBuilder.addAmpAmpOrPipePipeOverload();
10112 if (Args.size() == 2)
10113 OpBuilder.addSubscriptOverloads();
10117 OpBuilder.addArrowStarOverloads();
10120 case OO_Conditional:
10121 OpBuilder.addConditionalOperatorOverloads();
10122 OpBuilder.addGenericBinaryArithmeticOverloads();
10140 bool PartialOverloading) {
10151 ArgumentDependentLookup(Name, Loc, Args, Fns);
10155 CandEnd = CandidateSet.
end();
10156 Cand != CandEnd; ++Cand)
10157 if (Cand->Function) {
10158 Fns.
erase(Cand->Function);
10160 Fns.
erase(FunTmpl);
10169 if (ExplicitTemplateArgs)
10172 AddOverloadCandidate(
10173 FD, FoundDecl, Args, CandidateSet,
false,
10174 PartialOverloading,
true,
10175 false, ADLCallKind::UsesADL);
10177 AddOverloadCandidate(
10178 FD, FoundDecl, {Args[1], Args[0]}, CandidateSet,
10179 false, PartialOverloading,
10181 ADLCallKind::UsesADL, std::nullopt,
10185 auto *FTD = cast<FunctionTemplateDecl>(*I);
10186 AddTemplateOverloadCandidate(
10187 FTD, FoundDecl, ExplicitTemplateArgs, Args, CandidateSet,
10188 false, PartialOverloading,
10189 true, ADLCallKind::UsesADL);
10191 *
this, Args, FTD->getTemplatedDecl())) {
10192 AddTemplateOverloadCandidate(
10193 FTD, FoundDecl, ExplicitTemplateArgs, {Args[1], Args[0]},
10194 CandidateSet,
false, PartialOverloading,
10195 true, ADLCallKind::UsesADL,
10203enum class Comparison {
Equal, Better, Worse };
10220 bool Cand1Attr = Cand1->
hasAttr<EnableIfAttr>();
10221 bool Cand2Attr = Cand2->
hasAttr<EnableIfAttr>();
10222 if (!Cand1Attr || !Cand2Attr) {
10223 if (Cand1Attr == Cand2Attr)
10224 return Comparison::Equal;
10225 return Cand1Attr ? Comparison::Better : Comparison::Worse;
10231 llvm::FoldingSetNodeID Cand1ID, Cand2ID;
10232 for (
auto Pair : zip_longest(Cand1Attrs, Cand2Attrs)) {
10233 std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
10234 std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
10239 return Comparison::Worse;
10241 return Comparison::Better;
10246 (*Cand1A)->getCond()->Profile(Cand1ID, S.
getASTContext(),
true);
10247 (*Cand2A)->getCond()->Profile(Cand2ID, S.
getASTContext(),
true);
10248 if (Cand1ID != Cand2ID)
10249 return Comparison::Worse;
10252 return Comparison::Equal;
10260 return Comparison::Equal;
10266 return Comparison::Equal;
10267 return Comparison::Worse;
10270 return Comparison::Better;
10276 const auto *Cand1CPUSpec = Cand1.
Function->
getAttr<CPUSpecificAttr>();
10277 const auto *Cand2CPUSpec = Cand2.
Function->
getAttr<CPUSpecificAttr>();
10279 if (!Cand1CPUDisp && !Cand2CPUDisp && !Cand1CPUSpec && !Cand2CPUSpec)
10280 return Comparison::Equal;
10282 if (Cand1CPUDisp && !Cand2CPUDisp)
10283 return Comparison::Better;
10284 if (Cand2CPUDisp && !Cand1CPUDisp)
10285 return Comparison::Worse;
10287 if (Cand1CPUSpec && Cand2CPUSpec) {
10288 if (Cand1CPUSpec->cpus_size() != Cand2CPUSpec->cpus_size())
10289 return Cand1CPUSpec->cpus_size() < Cand2CPUSpec->cpus_size()
10290 ? Comparison::Better
10291 : Comparison::Worse;
10293 std::pair<CPUSpecificAttr::cpus_iterator, CPUSpecificAttr::cpus_iterator>
10294 FirstDiff = std::mismatch(
10295 Cand1CPUSpec->cpus_begin(), Cand1CPUSpec->cpus_end(),
10296 Cand2CPUSpec->cpus_begin(),
10298 return LHS->getName() == RHS->getName();
10301 assert(FirstDiff.first != Cand1CPUSpec->cpus_end() &&
10302 "Two different cpu-specific versions should not have the same "
10303 "identifier list, otherwise they'd be the same decl!");
10304 return (*FirstDiff.first)->getName() < (*FirstDiff.second)->
getName()
10305 ? Comparison::Better
10306 : Comparison::Worse;
10308 llvm_unreachable(
"No way to get here unless both had cpu_dispatch");
10314static std::optional<QualType>
10316 if (!isa<CXXMethodDecl>(F) || isa<CXXConstructorDecl>(F))
10317 return std::nullopt;
10319 auto *M = cast<CXXMethodDecl>(F);
10323 return M->getFunctionObjectParameterReferenceType();
10337 PT2->getInstantiatedFromMemberTemplate()))
10348 assert(I < F->getNumParams());
10352 unsigned F1NumParams = F1->
getNumParams() + isa<CXXMethodDecl>(F1);
10353 unsigned F2NumParams = F2->
getNumParams() + isa<CXXMethodDecl>(F2);
10355 if (F1NumParams != F2NumParams)
10358 unsigned I1 = 0, I2 = 0;
10359 for (
unsigned I = 0; I != F1NumParams; ++I) {
10360 QualType T1 = NextParam(F1, I1, I == 0);
10361 QualType T2 = NextParam(F2, I2, I == 0);
10362 assert(!T1.
isNull() && !T2.
isNull() &&
"Unexpected null param types");
10390 auto *Mem1 = dyn_cast<CXXMethodDecl>(Fn1);
10391 auto *Mem2 = dyn_cast<CXXMethodDecl>(Fn2);
10392 if (Mem1 && Mem2) {
10395 if (Mem1->getParent() != Mem2->getParent())
10399 if (Mem1->isInstance() && Mem2->isInstance() &&
10401 Mem1->getFunctionObjectParameterReferenceType(),
10402 Mem1->getFunctionObjectParameterReferenceType()))
10458 bool IsCand1ImplicitHD =
10460 bool IsCand2ImplicitHD =
10475 auto EmitThreshold =
10476 (S.
getLangOpts().CUDAIsDevice && IsCallerImplicitHD &&
10477 (IsCand1ImplicitHD || IsCand2ImplicitHD))
10480 auto Cand1Emittable = P1 > EmitThreshold;
10481 auto Cand2Emittable = P2 > EmitThreshold;
10482 if (Cand1Emittable && !Cand2Emittable)
10484 if (!Cand1Emittable && Cand2Emittable)
10495 unsigned StartArg = 0;
10502 return ICS.isStandard() &&
10514 assert(Cand2.
Conversions.size() == NumArgs &&
"Overload candidate mismatch");
10515 bool HasBetterConversion =
false;
10516 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10517 bool Cand1Bad = IsIllFormedConversion(Cand1.
Conversions[ArgIdx]);
10518 bool Cand2Bad = IsIllFormedConversion(Cand2.
Conversions[ArgIdx]);
10519 if (Cand1Bad != Cand2Bad) {
10522 HasBetterConversion =
true;
10526 if (HasBetterConversion)
10533 bool HasWorseConversion =
false;
10534 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10540 HasBetterConversion =
true;
10559 HasWorseConversion =
true;
10574 if (HasBetterConversion && !HasWorseConversion)
10585 isa<CXXConversionDecl>(Cand1.
Function) &&
10586 isa<CXXConversionDecl>(Cand2.
Function)) {
10614 isa<CXXConstructorDecl>(Cand1.
Function) !=
10615 isa<CXXConstructorDecl>(Cand2.
Function))
10616 return isa<CXXConstructorDecl>(Cand1.
Function);
10620 bool Cand1IsSpecialization = Cand1.
Function &&
10622 bool Cand2IsSpecialization = Cand2.
Function &&
10624 if (Cand1IsSpecialization != Cand2IsSpecialization)
10625 return Cand2IsSpecialization;
10631 if (Cand1IsSpecialization && Cand2IsSpecialization) {
10632 const auto *Obj1Context =
10634 const auto *Obj2Context =
10642 Obj1Context ?
QualType(Obj1Context->getTypeForDecl(), 0)
10644 Obj2Context ?
QualType(Obj2Context->getTypeForDecl(), 0)
10653 if (!Cand1IsSpecialization && !Cand2IsSpecialization &&
10665 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
10667 AtLeastAsConstrained1) ||
10669 AtLeastAsConstrained2))
10671 if (AtLeastAsConstrained1 != AtLeastAsConstrained2)
10672 return AtLeastAsConstrained1;
10673 }
else if (RC1 || RC2) {
10674 return RC1 !=
nullptr;
10682 bool Cand1IsInherited =
10684 bool Cand2IsInherited =
10686 if (Cand1IsInherited != Cand2IsInherited)
10687 return Cand2IsInherited;
10688 else if (Cand1IsInherited) {
10689 assert(Cand2IsInherited);
10692 if (Cand1Class->isDerivedFrom(Cand2Class))
10694 if (Cand2Class->isDerivedFrom(Cand1Class))
10711 auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.
Function);
10712 auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.
Function);
10713 if (Guide1 && Guide2) {
10715 if (Guide1->isImplicit() != Guide2->isImplicit())
10716 return Guide2->isImplicit();
10726 const auto *Constructor1 = Guide1->getCorrespondingConstructor();
10727 const auto *Constructor2 = Guide2->getCorrespondingConstructor();
10728 if (Constructor1 && Constructor2) {
10729 bool isC1Templated = Constructor1->getTemplatedKind() !=
10731 bool isC2Templated = Constructor2->getTemplatedKind() !=
10733 if (isC1Templated != isC2Templated)
10734 return isC2Templated;
10742 if (Cmp != Comparison::Equal)
10743 return Cmp == Comparison::Better;
10746 bool HasPS1 = Cand1.
Function !=
nullptr &&
10748 bool HasPS2 = Cand2.
Function !=
nullptr &&
10750 if (HasPS1 != HasPS2 && HasPS1)
10754 if (MV == Comparison::Better)
10756 if (MV == Comparison::Worse)
10771 const auto *CD1 = dyn_cast_or_null<CXXConstructorDecl>(Cand1.
Function);
10772 const auto *CD2 = dyn_cast_or_null<CXXConstructorDecl>(Cand2.
Function);
10774 LangAS AS1 = CD1->getMethodQualifiers().getAddressSpace();
10775 LangAS AS2 = CD2->getMethodQualifiers().getAddressSpace();
10796 auto *VA = dyn_cast_or_null<ValueDecl>(A);
10797 auto *VB = dyn_cast_or_null<ValueDecl>(B);
10803 if (!VA->getDeclContext()->getRedeclContext()->Equals(
10804 VB->getDeclContext()->getRedeclContext()) ||
10805 getOwningModule(VA) == getOwningModule(VB) ||
10806 VA->isExternallyVisible() || VB->isExternallyVisible())
10814 if (Context.
hasSameType(VA->getType(), VB->getType()))
10819 if (
auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
10820 if (
auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
10823 auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
10824 auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
10825 if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
10827 EnumB->getIntegerType()))
10830 return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
10840 assert(D &&
"Unknown declaration");
10841 Diag(Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
10843 Module *M = getOwningModule(D);
10847 for (
auto *E : Equiv) {
10848 Module *M = getOwningModule(E);
10849 Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
10858 static_cast<CNSInfo *
>(DeductionFailure.Data)
10859 ->Satisfaction.ContainsErrors;
10876 std::transform(
begin(),
end(), std::back_inserter(Candidates),
10892 bool ContainsSameSideCandidate =
10896 S.
CUDA().IdentifyPreference(Caller, Cand->
Function) ==
10899 if (ContainsSameSideCandidate) {
10906 llvm::erase_if(Candidates, IsWrongSideCandidate);
10912 for (
auto *Cand : Candidates) {
10913 Cand->
Best =
false;
10915 if (Best ==
end() ||
10935 PendingBest.push_back(&*Best);
10940 while (!PendingBest.empty()) {
10941 auto *Curr = PendingBest.pop_back_val();
10942 for (
auto *Cand : Candidates) {
10945 PendingBest.push_back(Cand);
10950 EquivalentCands.push_back(Cand->
Function);
10962 if (Best->Function && Best->Function->isDeleted())
10965 if (!EquivalentCands.empty())
10974enum OverloadCandidateKind {
10977 oc_reversed_binary_operator,
10979 oc_implicit_default_constructor,
10980 oc_implicit_copy_constructor,
10981 oc_implicit_move_constructor,
10982 oc_implicit_copy_assignment,
10983 oc_implicit_move_assignment,
10984 oc_implicit_equality_comparison,
10985 oc_inherited_constructor
10988enum OverloadCandidateSelect {
10991 ocs_described_template,
10994static std::pair<OverloadCandidateKind, OverloadCandidateSelect>
10998 std::string &Description) {
11007 OverloadCandidateSelect Select = [&]() {
11008 if (!Description.empty())
11009 return ocs_described_template;
11010 return isTemplate ? ocs_template : ocs_non_template;
11013 OverloadCandidateKind Kind = [&]() {
11015 return oc_implicit_equality_comparison;
11018 return oc_reversed_binary_operator;
11020 if (
const auto *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
11021 if (!Ctor->isImplicit()) {
11022 if (isa<ConstructorUsingShadowDecl>(Found))
11023 return oc_inherited_constructor;
11025 return oc_constructor;
11028 if (Ctor->isDefaultConstructor())
11029 return oc_implicit_default_constructor;
11031 if (Ctor->isMoveConstructor())
11032 return oc_implicit_move_constructor;
11034 assert(Ctor->isCopyConstructor() &&
11035 "unexpected sort of implicit constructor");
11036 return oc_implicit_copy_constructor;
11039 if (
const auto *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
11042 if (!Meth->isImplicit())
11045 if (Meth->isMoveAssignmentOperator())
11046 return oc_implicit_move_assignment;
11048 if (Meth->isCopyAssignmentOperator())
11049 return oc_implicit_copy_assignment;
11051 assert(isa<CXXConversionDecl>(Meth) &&
"expected conversion");
11055 return oc_function;
11058 return std::make_pair(Kind, Select);
11061void MaybeEmitInheritedConstructorNote(
Sema &S,
const Decl *FoundDecl) {
11064 if (
const auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
11066 diag::note_ovl_candidate_inherited_constructor)
11067 << Shadow->getNominatedBaseClass();
11076 if (EnableIf->getCond()->isValueDependent() ||
11077 !EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
11094 bool InOverloadResolution,
11098 if (InOverloadResolution)
11100 diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
11102 S.
Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
11113 if (InOverloadResolution) {
11116 TemplateArgString +=
" ";
11118 FunTmpl->getTemplateParameters(),
11123 diag::note_ovl_candidate_unsatisfied_constraints)
11124 << TemplateArgString;
11126 S.
Diag(Loc, diag::err_addrof_function_constraints_not_satisfied)
11135 return P->hasAttr<PassObjectSizeAttr>();
11142 unsigned ParamNo = std::distance(FD->
param_begin(), I) + 1;
11143 if (InOverloadResolution)
11145 diag::note_ovl_candidate_has_pass_object_size_params)
11148 S.
Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
11164 return ::checkAddressOfFunctionIsAvailable(*
this,
Function, Complain,
11172 const auto *ConvD = dyn_cast<CXXConversionDecl>(Fn);
11176 const auto *RD = cast<CXXRecordDecl>(Fn->
getParent());
11177 if (!RD->isLambda())
11187 return ConvToCC != CallOpCC;
11193 QualType DestType,
bool TakingAddress) {
11197 !Fn->
getAttr<TargetAttr>()->isDefaultVersion())
11200 !Fn->
getAttr<TargetVersionAttr>()->isDefaultVersion())
11205 std::string FnDesc;
11206 std::pair<OverloadCandidateKind, OverloadCandidateSelect> KSPair =
11207 ClassifyOverloadCandidate(*
this, Found, Fn, RewriteKind, FnDesc);
11209 << (
unsigned)KSPair.first << (
unsigned)KSPair.second
11212 HandleFunctionTypeMismatch(PD, Fn->
getType(), DestType);
11214 MaybeEmitInheritedConstructorNote(*
this, Found);
11232 FunctionDecl *FirstCand =
nullptr, *SecondCand =
nullptr;
11233 for (
auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
11237 if (
auto *Template = I->Function->getPrimaryTemplate())
11238 Template->getAssociatedConstraints(AC);
11240 I->Function->getAssociatedConstraints(AC);
11243 if (FirstCand ==
nullptr) {
11244 FirstCand = I->Function;
11246 }
else if (SecondCand ==
nullptr) {
11247 SecondCand = I->Function;
11260 SecondCand, SecondAC))
11269 bool TakingAddress) {
11279 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
11280 NoteOverloadCandidate(*I, FunTmpl->getTemplatedDecl(),
CRK_None, DestType,
11283 = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
11284 NoteOverloadCandidate(*I, Fun,
CRK_None, DestType, TakingAddress);
11296 S.
Diag(CaretLoc, PDiag)
11297 << Ambiguous.getFromType() << Ambiguous.getToType();
11298 unsigned CandsShown = 0;
11300 for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
11312 unsigned I,
bool TakingCandidateAddress) {
11314 assert(Conv.
isBad());
11315 assert(Cand->
Function &&
"for now, candidate must be a function");
11321 bool isObjectArgument =
false;
11322 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
11324 isObjectArgument =
true;
11329 std::string FnDesc;
11330 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11341 assert(FromExpr &&
"overload set argument came from implicit argument?");
11343 if (isa<UnaryOperator>(E))
11344 E = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
11348 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11349 << ToParamRange << ToTy << Name << I + 1;
11350 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11359 CToTy = RT->getPointeeType();
11364 CFromTy = FromPT->getPointeeType();
11365 CToTy = ToPT->getPointeeType();
11375 if (isObjectArgument)
11376 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_addrspace_this)
11377 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11381 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11384 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11390 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11393 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11399 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11402 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11407 assert(CVR &&
"expected qualifiers mismatch");
11409 if (isObjectArgument) {
11411 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11412 << FromTy << (CVR - 1);
11415 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11416 << ToParamRange << FromTy << (CVR - 1) << I + 1;
11418 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11424 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_value_category)
11425 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11426 << (
unsigned)isObjectArgument << I + 1
11429 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11435 if (FromExpr && isa<InitListExpr>(FromExpr)) {
11436 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_list_argument)
11437 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11438 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11443 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11455 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
11456 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11457 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11458 << (
unsigned)(Cand->
Fix.
Kind);
11460 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11465 unsigned BaseToDerivedConversion = 0;
11468 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11469 FromPtrTy->getPointeeType()) &&
11470 !FromPtrTy->getPointeeType()->isIncompleteType() &&
11471 !ToPtrTy->getPointeeType()->isIncompleteType() &&
11473 FromPtrTy->getPointeeType()))
11474 BaseToDerivedConversion = 1;
11482 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11483 FromPtrTy->getPointeeType()) &&
11484 FromIface->isSuperClassOf(ToIface))
11485 BaseToDerivedConversion = 2;
11487 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
11489 !ToRefTy->getPointeeType()->isIncompleteType() &&
11491 BaseToDerivedConversion = 3;
11495 if (BaseToDerivedConversion) {
11496 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv)
11497 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11498 << ToParamRange << (BaseToDerivedConversion - 1) << FromTy << ToTy
11500 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11504 if (isa<ObjCObjectPointerType>(CFromTy) &&
11505 isa<PointerType>(CToTy)) {
11510 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11511 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument
11513 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11518 if (TakingCandidateAddress &&
11524 FDiag << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11525 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11526 << (
unsigned)(Cand->
Fix.
Kind);
11537 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11544 unsigned NumArgs) {
11557 if (NumArgs < MinParams) {
11574 unsigned NumFormalArgs) {
11575 assert(isa<FunctionDecl>(D) &&
11576 "The templated declaration should at least be a function"
11577 " when diagnosing bad template argument deduction due to too many"
11578 " or too few arguments");
11588 unsigned ParamCount = FnTy->getNumParams() - (HasExplicitObjectParam ? 1 : 0);
11589 unsigned mode, modeCount;
11590 if (NumFormalArgs < MinParams) {
11591 if (MinParams != ParamCount || FnTy->isVariadic() ||
11592 FnTy->isTemplateVariadic())
11596 modeCount = MinParams;
11598 if (MinParams != ParamCount)
11602 modeCount = ParamCount;
11605 std::string Description;
11606 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11607 ClassifyOverloadCandidate(S, Found, Fn,
CRK_None, Description);
11609 if (modeCount == 1 &&
11612 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11613 << Description << mode
11614 << Fn->
getParamDecl(HasExplicitObjectParam ? 1 : 0) << NumFormalArgs
11618 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11619 << Description << mode << modeCount << NumFormalArgs
11622 MaybeEmitInheritedConstructorNote(S, Found);
11627 unsigned NumFormalArgs) {
11635 llvm_unreachable(
"Unsupported: Getting the described template declaration"
11636 " for bad deduction diagnosis");
11643 bool TakingCandidateAddress) {
11649 switch (DeductionFailure.
getResult()) {
11652 "TemplateDeductionResult::Success while diagnosing bad deduction");
11654 llvm_unreachable(
"TemplateDeductionResult::NonDependentConversionFailure "
11655 "while diagnosing bad deduction");
11661 assert(ParamD &&
"no parameter found for incomplete deduction result");
11663 diag::note_ovl_candidate_incomplete_deduction)
11665 MaybeEmitInheritedConstructorNote(S, Found);
11670 assert(ParamD &&
"no parameter found for incomplete deduction result");
11672 diag::note_ovl_candidate_incomplete_deduction_pack)
11676 MaybeEmitInheritedConstructorNote(S, Found);
11681 assert(ParamD &&
"no parameter found for bad qualifiers deduction result");
11699 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_underqualified)
11700 << ParamD->
getDeclName() << Arg << NonCanonParam;
11701 MaybeEmitInheritedConstructorNote(S, Found);
11706 assert(ParamD &&
"no parameter found for inconsistent deduction result");
11708 if (isa<TemplateTypeParmDecl>(ParamD))
11710 else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
11720 diag::note_ovl_candidate_inconsistent_deduction_types)
11723 MaybeEmitInheritedConstructorNote(S, Found);
11743 diag::note_ovl_candidate_inconsistent_deduction)
11746 MaybeEmitInheritedConstructorNote(S, Found);
11751 assert(ParamD &&
"no parameter found for invalid explicit arguments");
11754 diag::note_ovl_candidate_explicit_arg_mismatch_named)
11759 index = TTP->getIndex();
11761 = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
11762 index = NTTP->getIndex();
11764 index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
11766 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
11769 MaybeEmitInheritedConstructorNote(S, Found);
11776 TemplateArgString =
" ";
11779 if (TemplateArgString.size() == 1)
11780 TemplateArgString.clear();
11782 diag::note_ovl_candidate_unsatisfied_constraints)
11783 << TemplateArgString;
11786 static_cast<CNSInfo*
>(DeductionFailure.
Data)->Satisfaction);
11796 diag::note_ovl_candidate_instantiation_depth);
11797 MaybeEmitInheritedConstructorNote(S, Found);
11805 TemplateArgString =
" ";
11808 if (TemplateArgString.size() == 1)
11809 TemplateArgString.clear();
11814 if (PDiag && PDiag->second.getDiagID() ==
11815 diag::err_typename_nested_not_found_enable_if) {
11818 S.
Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
11819 <<
"'enable_if'" << TemplateArgString;
11824 if (PDiag && PDiag->second.getDiagID() ==
11825 diag::err_typename_nested_not_found_requirement) {
11827 diag::note_ovl_candidate_disabled_by_requirement)
11828 << PDiag->second.getStringArg(0) << TemplateArgString;
11838 SFINAEArgString =
": ";
11840 PDiag->second.EmitToString(S.
getDiagnostics(), SFINAEArgString);
11844 diag::note_ovl_candidate_substitution_failure)
11845 << TemplateArgString << SFINAEArgString << R;
11846 MaybeEmitInheritedConstructorNote(S, Found);
11856 TemplateArgString =
" ";
11859 if (TemplateArgString.size() == 1)
11860 TemplateArgString.clear();
11863 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_deduced_mismatch)
11866 << TemplateArgString
11891 diag::note_ovl_candidate_non_deduced_mismatch_qualified)
11898 if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
11907 diag::note_ovl_candidate_non_deduced_mismatch)
11908 << FirstTA << SecondTA;
11914 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_bad_deduction);
11915 MaybeEmitInheritedConstructorNote(S, Found);
11919 diag::note_cuda_ovl_candidate_target_mismatch);
11927 bool TakingCandidateAddress) {
11946 std::string FnDesc;
11947 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11948 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Callee,
11951 S.
Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
11952 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
11954 << llvm::to_underlying(CalleeTarget) << llvm::to_underlying(CallerTarget);
11959 if (Meth !=
nullptr && Meth->
isImplicit()) {
11963 switch (FnKindPair.first) {
11966 case oc_implicit_default_constructor:
11969 case oc_implicit_copy_constructor:
11972 case oc_implicit_move_constructor:
11975 case oc_implicit_copy_assignment:
11978 case oc_implicit_move_assignment:
11983 bool ConstRHS =
false;
11987 ConstRHS = RT->getPointeeType().isConstQualified();
12001 S.
Diag(Callee->getLocation(),
12002 diag::note_ovl_candidate_disabled_by_function_cond_attr)
12003 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
12008 assert(ES.
isExplicit() &&
"not an explicit candidate");
12012 case Decl::Kind::CXXConstructor:
12015 case Decl::Kind::CXXConversion:
12018 case Decl::Kind::CXXDeductionGuide:
12022 llvm_unreachable(
"invalid Decl");
12031 First = Pattern->getFirstDecl();
12034 diag::note_ovl_candidate_explicit)
12035 << Kind << (ES.
getExpr() ? 1 : 0)
12056 bool TakingCandidateAddress,
12072 std::string FnDesc;
12073 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12074 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12078 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
12080 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12096 TakingCandidateAddress);
12099 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_illegal_constructor)
12101 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12109 diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch)
12110 << QualsForPrinting;
12111 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12122 for (
unsigned N = Cand->
Conversions.size(); I != N; ++I)
12143 if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
12146 diag::note_ovl_candidate_inherited_constructor_slice)
12149 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12155 assert(!Available);
12163 std::string FnDesc;
12164 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12165 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12169 diag::note_ovl_candidate_constraints_not_satisfied)
12170 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
12188 bool isLValueReference =
false;
12189 bool isRValueReference =
false;
12190 bool isPointer =
false;
12194 isLValueReference =
true;
12198 isRValueReference =
true;
12214 diag::note_ovl_surrogate_constraints_not_satisfied)
12228 assert(Cand->
Conversions.size() <= 2 &&
"builtin operator is not binary");
12229 std::string TypeStr(
"operator");
12235 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12240 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12247 if (ICS.
isBad())
break;
12251 S, OpLoc, S.
PDiag(diag::note_ambiguous_type_conversion));
12268 llvm_unreachable(
"non-deduction failure while diagnosing bad deduction");
12298 llvm_unreachable(
"Unhandled deduction result");
12303struct CompareOverloadCandidatesForDisplay {
12309 CompareOverloadCandidatesForDisplay(
12312 : S(S), NumArgs(NArgs), CSK(CSK) {}
12322 if (NumArgs >
C->Function->getNumParams() && !
C->Function->isVariadic())
12324 if (NumArgs < C->
Function->getMinRequiredArguments())
12334 if (L == R)
return false;
12338 if (!R->
Viable)
return true;
12340 if (
int Ord = CompareConversions(*L, *R))
12360 if (LDist == RDist) {
12361 if (LFailureKind == RFailureKind)
12369 return LDist < RDist;
12387 numLFixes = (numLFixes == 0) ?
UINT_MAX : numLFixes;
12388 numRFixes = (numRFixes == 0) ?
UINT_MAX : numRFixes;
12389 if (numLFixes != numRFixes) {
12390 return numLFixes < numRFixes;
12394 if (
int Ord = CompareConversions(*L, *R))
12406 if (LRank != RRank)
12407 return LRank < RRank;
12433 struct ConversionSignals {
12434 unsigned KindRank = 0;
12438 ConversionSignals Sig;
12439 Sig.KindRank =
Seq.getKindRank();
12440 if (
Seq.isStandard())
12441 Sig.Rank =
Seq.Standard.getRank();
12442 else if (
Seq.isUserDefined())
12443 Sig.Rank =
Seq.UserDefined.After.getRank();
12449 static ConversionSignals ForObjectArgument() {
12465 for (
unsigned I = 0, N = L.
Conversions.size(); I != N; ++I) {
12467 ? ConversionSignals::ForObjectArgument()
12468 : ConversionSignals::ForSequence(L.Conversions[I]);
12470 ? ConversionSignals::ForObjectArgument()
12471 : ConversionSignals::ForSequence(R.Conversions[I]);
12472 if (std::tie(LS.KindRank, LS.Rank) != std::tie(RS.KindRank, RS.Rank))
12473 return std::tie(LS.KindRank, LS.Rank) < std::tie(RS.KindRank, RS.Rank)
12498 bool Unfixable =
false;
12506 assert(ConvIdx != ConvCount &&
"no bad conversion in candidate");
12507 if (Cand->
Conversions[ConvIdx].isInitialized() &&
12516 bool SuppressUserConversions =
false;
12518 unsigned ConvIdx = 0;
12519 unsigned ArgIdx = 0;
12534 if (isa<CXXMethodDecl>(Cand->
Function) &&
12547 assert(ConvCount <= 3);
12553 ConvIdx != ConvCount;
12555 assert(ArgIdx < Args.size() &&
"no argument for this arg conversion");
12556 if (Cand->
Conversions[ConvIdx].isInitialized()) {
12558 }
else if (
ParamIdx < ParamTypes.size()) {
12559 if (ParamTypes[
ParamIdx]->isDependentType())
12560 Cand->
Conversions[ConvIdx].setAsIdentityConversion(
12561 Args[ArgIdx]->getType());
12565 SuppressUserConversions,
12570 if (!Unfixable && Cand->
Conversions[ConvIdx].isBad())
12586 for (
iterator Cand =
begin(), LastCand =
end(); Cand != LastCand; ++Cand) {
12587 if (!Filter(*Cand))
12591 if (!Cand->Viable) {
12592 if (!Cand->Function && !Cand->IsSurrogate) {
12612 Cands.push_back(Cand);
12616 Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
12623 bool DeferHint =
false;
12627 auto WrongSidedCands =
12629 return (Cand.Viable ==
false &&
12632 Cand.Function->template hasAttr<CUDAHostAttr>() &&
12633 Cand.Function->template hasAttr<CUDADeviceAttr>());
12635 DeferHint = !WrongSidedCands.empty();
12653 bool NoteCands =
true;
12654 for (
const Expr *Arg : Args) {
12655 if (Arg->getType()->isWebAssemblyTableType())
12669 bool ReportedAmbiguousConversions =
false;
12672 unsigned CandsShown = 0;
12673 auto I = Cands.begin(), E = Cands.end();
12674 for (; I != E; ++I) {
12690 "Non-viable built-in candidates are not added to Cands.");
12697 if (!ReportedAmbiguousConversions) {
12699 ReportedAmbiguousConversions =
true;
12712 S.
Diag(OpLoc, diag::note_ovl_too_many_candidates,
12724struct CompareTemplateSpecCandidatesForDisplay {
12726 CompareTemplateSpecCandidatesForDisplay(
Sema &S) : S(S) {}
12760 bool ForTakingAddress) {
12762 DeductionFailure, 0, ForTakingAddress);
12765void TemplateSpecCandidateSet::destroyCandidates() {
12767 i->DeductionFailure.Destroy();
12772 destroyCandidates();
12773 Candidates.clear();
12786 Cands.reserve(
size());
12787 for (
iterator Cand =
begin(), LastCand =
end(); Cand != LastCand; ++Cand) {
12788 if (Cand->Specialization)
12789 Cands.push_back(Cand);
12794 llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S));
12801 unsigned CandsShown = 0;
12802 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
12808 if (CandsShown >= 4 && ShowOverloads ==
Ovl_Best)
12813 "Non-matching built-in candidates are not added to Cands.");
12818 S.
Diag(Loc, diag::note_ovl_too_many_candidates) <<
int(E - I);
12828 QualType Ret = PossiblyAFunctionType;
12831 Ret = ToTypePtr->getPointeeType();
12834 Ret = ToTypeRef->getPointeeType();
12837 Ret = MemTypePtr->getPointeeType();
12844 bool Complain =
true) {
12861class AddressOfFunctionResolver {
12871 bool TargetTypeIsNonStaticMemberFunction;
12872 bool FoundNonTemplateFunction;
12873 bool StaticMemberFunctionFromBoundPointer;
12874 bool HasComplained;
12883 AddressOfFunctionResolver(
Sema &S,
Expr *SourceExpr,
12884 const QualType &TargetType,
bool Complain)
12885 : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
12886 Complain(Complain), Context(S.getASTContext()),
12887 TargetTypeIsNonStaticMemberFunction(
12889 FoundNonTemplateFunction(
false),
12890 StaticMemberFunctionFromBoundPointer(
false),
12891 HasComplained(
false),
12894 FailedCandidates(OvlExpr->getNameLoc(),
true) {
12895 ExtractUnqualifiedFunctionTypeFromTargetType();
12899 if (!UME->isImplicitAccess() &&
12901 StaticMemberFunctionFromBoundPointer =
true;
12905 OvlExpr,
false, &dap)) {
12907 if (!Method->isStatic()) {
12911 TargetTypeIsNonStaticMemberFunction =
true;
12919 Matches.push_back(std::make_pair(dap, Fn));
12927 if (FindAllFunctionsThatMatchTargetTypeExactly()) {
12930 if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
12931 if (FoundNonTemplateFunction)
12932 EliminateAllTemplateMatches();
12934 EliminateAllExceptMostSpecializedTemplate();
12939 EliminateSuboptimalCudaMatches();
12942 bool hasComplained()
const {
return HasComplained; }
12945 bool candidateHasExactlyCorrectType(
const FunctionDecl *FD) {
12957 return candidateHasExactlyCorrectType(A) &&
12958 (!candidateHasExactlyCorrectType(B) ||
12964 bool eliminiateSuboptimalOverloadCandidates() {
12967 auto Best = Matches.begin();
12968 for (
auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
12969 if (isBetterCandidate(I->second, Best->second))
12973 auto IsBestOrInferiorToBest = [
this, BestFn](
12974 const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
12975 return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
12980 if (!llvm::all_of(Matches, IsBestOrInferiorToBest))
12982 Matches[0] = *Best;
12987 bool isTargetTypeAFunction()
const {
12996 void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
13007 bool CanConvertToFunctionPointer =
13008 Method->isStatic() || Method->isExplicitObjectMemberFunction();
13009 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13012 else if (TargetTypeIsNonStaticMemberFunction)
13024 FunctionTemplate, &OvlExplicitTemplateArgs, TargetFunctionType,
13026 Result != TemplateDeductionResult::Success) {
13044 Matches.push_back(std::make_pair(CurAccessFunPair,
Specialization));
13048 bool AddMatchingNonTemplateFunction(
NamedDecl* Fn,
13053 bool CanConvertToFunctionPointer =
13054 Method->isStatic() || Method->isExplicitObjectMemberFunction();
13055 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13058 else if (TargetTypeIsNonStaticMemberFunction)
13061 if (
FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
13068 if (FunDecl->isMultiVersion()) {
13069 const auto *TA = FunDecl->
getAttr<TargetAttr>();
13070 if (TA && !TA->isDefaultVersion())
13072 const auto *TVA = FunDecl->getAttr<TargetVersionAttr>();
13073 if (TVA && !TVA->isDefaultVersion())
13081 HasComplained |= Complain;
13090 candidateHasExactlyCorrectType(FunDecl)) {
13091 Matches.push_back(std::make_pair(
13092 CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
13093 FoundNonTemplateFunction =
true;
13101 bool FindAllFunctionsThatMatchTargetTypeExactly() {
13106 if (IsInvalidFormOfPointerToMemberFunction())
13122 = dyn_cast<FunctionTemplateDecl>(Fn)) {
13123 if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
13128 AddMatchingNonTemplateFunction(Fn, I.getPair()))
13131 assert(Ret || Matches.empty());
13135 void EliminateAllExceptMostSpecializedTemplate() {
13148 for (
unsigned I = 0, E = Matches.size(); I != E; ++I)
13149 MatchesCopy.
addDecl(Matches[I].second, Matches[I].first.getAccess());
13154 MatchesCopy.
begin(), MatchesCopy.
end(), FailedCandidates,
13156 S.
PDiag(diag::err_addr_ovl_ambiguous)
13157 << Matches[0].second->getDeclName(),
13158 S.
PDiag(diag::note_ovl_candidate)
13159 << (
unsigned)oc_function << (
unsigned)ocs_described_template,
13160 Complain, TargetFunctionType);
13162 if (Result != MatchesCopy.
end()) {
13164 Matches[0].first = Matches[Result - MatchesCopy.
begin()].first;
13165 Matches[0].second = cast<FunctionDecl>(*Result);
13168 HasComplained |= Complain;
13171 void EliminateAllTemplateMatches() {
13174 for (
unsigned I = 0, N = Matches.size(); I != N; ) {
13175 if (Matches[I].second->getPrimaryTemplate() ==
nullptr)
13178 Matches[I] = Matches[--N];
13184 void EliminateSuboptimalCudaMatches() {
13190 void ComplainNoMatchesFound()
const {
13191 assert(Matches.empty());
13193 << OvlExpr->
getName() << TargetFunctionType
13195 if (FailedCandidates.
empty())
13206 dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
13214 bool IsInvalidFormOfPointerToMemberFunction()
const {
13215 return TargetTypeIsNonStaticMemberFunction &&
13219 void ComplainIsInvalidFormOfPointerToMemberFunction()
const {
13227 bool IsStaticMemberFunctionFromBoundPointer()
const {
13228 return StaticMemberFunctionFromBoundPointer;
13231 void ComplainIsStaticMemberFunctionFromBoundPointer()
const {
13233 diag::err_invalid_form_pointer_member_function)
13237 void ComplainOfInvalidConversion()
const {
13239 << OvlExpr->
getName() << TargetType;
13242 void ComplainMultipleMatchesFound()
const {
13243 assert(Matches.size() > 1);
13250 bool hadMultipleCandidates()
const {
return (OvlExpr->
getNumDecls() > 1); }
13252 int getNumMatches()
const {
return Matches.size(); }
13255 if (Matches.size() != 1)
return nullptr;
13256 return Matches[0].second;
13260 if (Matches.size() != 1)
return nullptr;
13261 return &Matches[0].first;
13286 bool *pHadMultipleCandidates) {
13289 AddressOfFunctionResolver Resolver(*
this, AddressOfExpr, TargetType,
13291 int NumMatches = Resolver.getNumMatches();
13293 bool ShouldComplain = Complain && !Resolver.hasComplained();
13294 if (NumMatches == 0 && ShouldComplain) {
13295 if (Resolver.IsInvalidFormOfPointerToMemberFunction())
13296 Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
13298 Resolver.ComplainNoMatchesFound();
13300 else if (NumMatches > 1 && ShouldComplain)
13301 Resolver.ComplainMultipleMatchesFound();
13302 else if (NumMatches == 1) {
13303 Fn = Resolver.getMatchingFunctionDecl();
13306 ResolveExceptionSpec(AddressOfExpr->
getExprLoc(), FPT);
13307 FoundResult = *Resolver.getMatchingFunctionAccessPair();
13309 if (Resolver.IsStaticMemberFunctionFromBoundPointer())
13310 Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
13312 CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
13316 if (pHadMultipleCandidates)
13317 *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
13332 bool IsResultAmbiguous =
false;
13340 return static_cast<int>(
CUDA().IdentifyPreference(Caller, FD1)) -
13341 static_cast<int>(
CUDA().IdentifyPreference(Caller, FD2));
13352 FD2->getAssociatedConstraints(AC2);
13353 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
13354 if (IsAtLeastAsConstrained(FD1, AC1, FD2, AC2, AtLeastAsConstrained1))
13355 return std::nullopt;
13356 if (IsAtLeastAsConstrained(FD2, AC2, FD1, AC1, AtLeastAsConstrained2))
13357 return std::nullopt;
13358 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
13359 return std::nullopt;
13360 return AtLeastAsConstrained1;
13367 auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
13375 auto FoundBetter = [&]() {
13376 IsResultAmbiguous =
false;
13387 if (getLangOpts().CUDA) {
13388 int PreferenceByCUDA = CheckCUDAPreference(FD,
Result);
13390 if (PreferenceByCUDA != 0) {
13392 if (PreferenceByCUDA > 0)
13399 std::optional<bool> MoreConstrainedThanPrevious =
13400 CheckMoreConstrained(FD,
Result);
13401 if (!MoreConstrainedThanPrevious) {
13402 IsResultAmbiguous =
true;
13403 AmbiguousDecls.push_back(FD);
13406 if (!*MoreConstrainedThanPrevious)
13413 if (IsResultAmbiguous)
13424 if (getLangOpts().
CUDA && CheckCUDAPreference(Skipped,
Result) != 0)
13426 if (!CheckMoreConstrained(Skipped,
Result))
13442 ExprResult &SrcExpr,
bool DoFunctionPointerConversion) {
13447 FunctionDecl *Found = resolveAddressOfSingleOverloadCandidate(E, DAP);
13456 CheckAddressOfMemberAccess(E, DAP);
13457 ExprResult Res = FixOverloadedFunctionReference(E, DAP, Found);
13462 SrcExpr = DefaultFunctionArrayConversion(Fixed,
false);
13507 = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
13536 NoteAllOverloadCandidates(ovl);
13542 if (FoundResult) *FoundResult = I.getPair();
13561 ExprResult &SrcExpr,
bool doFunctionPointerConversion,
bool complain,
13563 unsigned DiagIDForComplaining) {
13570 if (
FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
13582 isa<CXXMethodDecl>(fn) &&
13583 cast<CXXMethodDecl>(fn)->isInstance()) {
13584 if (!complain)
return false;
13587 diag::err_bound_member_function)
13600 SingleFunctionExpression =
13601 FixOverloadedFunctionReference(SrcExpr.
get(), found, fn);
13604 if (doFunctionPointerConversion) {
13605 SingleFunctionExpression =
13606 DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.
get());
13607 if (SingleFunctionExpression.
isInvalid()) {
13614 if (!SingleFunctionExpression.
isUsable()) {
13616 Diag(OpRangeForComplaining.
getBegin(), DiagIDForComplaining)
13618 << DestTypeForComplaining
13619 << OpRangeForComplaining
13621 NoteAllOverloadCandidates(SrcExpr.
get());
13630 SrcExpr = SingleFunctionExpression;
13640 bool PartialOverloading,
13642 NamedDecl *Callee = FoundDecl.getDecl();
13643 if (isa<UsingShadowDecl>(Callee))
13644 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
13647 if (ExplicitTemplateArgs) {
13648 assert(!KnownValid &&
"Explicit template arguments?");
13657 PartialOverloading);
13662 = dyn_cast<FunctionTemplateDecl>(Callee)) {
13664 ExplicitTemplateArgs, Args, CandidateSet,
13666 PartialOverloading);
13670 assert(!KnownValid &&
"unhandled case in overloaded call candidate");
13678 bool PartialOverloading) {
13701 assert(!(*I)->getDeclContext()->isRecord());
13702 assert(isa<UsingShadowDecl>(*I) ||
13703 !(*I)->getDeclContext()->isFunctionOrMethod());
13704 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
13714 ExplicitTemplateArgs = &TABuffer;
13720 CandidateSet, PartialOverloading,
13725 Args, ExplicitTemplateArgs,
13726 CandidateSet, PartialOverloading);
13736 CandidateSet,
false,
false);
13742 switch (Name.getCXXOverloadedOperator()) {
13743 case OO_New:
case OO_Array_New:
13744 case OO_Delete:
case OO_Array_Delete:
13767 if (DC->isTransparentContext())
13783 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC)) {
13788 if (FoundInClass) {
13789 *FoundInClass = RD;
13792 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
13809 AssociatedNamespaces,
13810 AssociatedClasses);
13814 for (Sema::AssociatedNamespaceSet::iterator
13815 it = AssociatedNamespaces.begin(),
13816 end = AssociatedNamespaces.end(); it !=
end; ++it) {
13818 if (
Std &&
Std->Encloses(*it))
13828 SuggestedNamespaces.insert(*it);
13832 SemaRef.
Diag(R.
getNameLoc(), diag::err_not_found_by_two_phase_lookup)
13834 if (SuggestedNamespaces.empty()) {
13835 SemaRef.
Diag(Best->Function->getLocation(),
13836 diag::note_not_found_by_two_phase_lookup)
13838 }
else if (SuggestedNamespaces.size() == 1) {
13839 SemaRef.
Diag(Best->Function->getLocation(),
13840 diag::note_not_found_by_two_phase_lookup)
13846 SemaRef.
Diag(Best->Function->getLocation(),
13847 diag::note_not_found_by_two_phase_lookup)
13879class BuildRecoveryCallExprRAII {
13884 BuildRecoveryCallExprRAII(
Sema &S) : SemaRef(S), SatStack(S) {
13906 bool EmptyLookup,
bool AllowTypoCorrection) {
13914 BuildRecoveryCallExprRAII RCE(SemaRef);
13924 ExplicitTemplateArgs = &TABuffer;
13932 ExplicitTemplateArgs, Args, &FoundInClass)) {
13934 }
else if (EmptyLookup) {
13939 ExplicitTemplateArgs !=
nullptr,
13940 dyn_cast<MemberExpr>(Fn));
13942 AllowTypoCorrection
13948 }
else if (FoundInClass && SemaRef.
getLangOpts().MSVCCompat) {
13963 assert(!R.
empty() &&
"lookup results empty despite recovery");
13974 if ((*R.
begin())->isCXXClassMember())
13976 ExplicitTemplateArgs, S);
13977 else if (ExplicitTemplateArgs || TemplateKWLoc.
isValid())
13979 ExplicitTemplateArgs);
14006 assert(!ULE->
getQualifier() &&
"qualified name with ADL");
14013 (F = dyn_cast<FunctionDecl>(*ULE->
decls_begin())) &&
14015 llvm_unreachable(
"performing ADL for builtin");
14018 assert(getLangOpts().
CPlusPlus &&
"ADL enabled in C");
14022 UnbridgedCastsSet UnbridgedCasts;
14030 AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
14032 if (getLangOpts().MSVCCompat &&
14033 CurContext->isDependentContext() && !isSFINAEContext() &&
14034 (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
14037 if (CandidateSet->
empty() ||
14046 RParenLoc, CurFPFeatureOverrides());
14053 if (CandidateSet->
empty())
14056 UnbridgedCasts.restore();
14063 std::optional<QualType>
Result;
14066 if (!Candidate.Function)
14068 if (Candidate.Function->isInvalidDecl())
14070 QualType T = Candidate.Function->getReturnType();
14083 if (Best && *Best != CS.
end())
14084 ConsiderCandidate(**Best);
14087 for (
const auto &
C : CS)
14089 ConsiderCandidate(
C);
14092 for (
const auto &
C : CS)
14093 ConsiderCandidate(
C);
14098 if (
Value.isNull() ||
Value->isUndeducedType())
14115 bool AllowTypoCorrection) {
14116 switch (OverloadResult) {
14127 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14128 false, (*Best)->IsADLCandidate);
14136 CandidateSet->
empty(),
14137 AllowTypoCorrection);
14144 for (
const Expr *Arg : Args) {
14145 if (!Arg->getType()->isFunctionType())
14147 if (
auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
14148 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
14151 Arg->getExprLoc()))
14159 SemaRef.
PDiag(diag::err_ovl_no_viable_function_in_call)
14168 SemaRef.
PDiag(diag::err_ovl_ambiguous_call)
14177 *CandidateSet, FDecl, Args);
14186 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14187 false, (*Best)->IsADLCandidate);
14193 SubExprs.append(Args.begin(), Args.end());
14200 for (
auto I = CS.
begin(), E = CS.
end(); I != E; ++I) {
14221 bool AllowTypoCorrection,
14222 bool CalleesAddressIsTaken) {
14227 if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
14233 if (CalleesAddressIsTaken)
14247 if (
const auto *TP =
14251 VK_PRValue, RParenLoc, CurFPFeatureOverrides());
14257 ExecConfig, &CandidateSet, &Best,
14258 OverloadResult, AllowTypoCorrection);
14262 return Functions.
size() > 1 ||
14263 (Functions.
size() == 1 &&
14264 isa<FunctionTemplateDecl>((*Functions.
begin())->getUnderlyingDecl()));
14279 bool HadMultipleCandidates) {
14284 Exp = InitializeExplicitObjectArgument(*
this, E, Method);
14286 Exp = PerformImplicitObjectArgumentInitialization(E,
nullptr,
14287 FoundDecl, Method);
14296 auto *CE = dyn_cast<CastExpr>(SubE);
14297 if (CE && CE->getCastKind() == CK_NoOp)
14298 SubE = CE->getSubExpr();
14300 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
14301 SubE = BE->getSubExpr();
14302 if (isa<LambdaExpr>(SubE)) {
14308 PushExpressionEvaluationContext(
14309 ExpressionEvaluationContext::PotentiallyEvaluated);
14310 ExprResult BlockExp = BuildBlockForLambdaConversion(
14312 PopExpressionEvaluationContext();
14330 Expr *ObjectParam = Exp.
get();
14333 CurFPFeatureOverrides());
14343 Exp.
get()->getEndLoc(),
14344 CurFPFeatureOverrides());
14347 if (CheckFunctionCall(Method, CE,
14372 Expr *Input,
bool PerformADL) {
14374 assert(Op !=
OO_None &&
"Invalid opcode for overloaded unary operator");
14382 Expr *Args[2] = { Input,
nullptr };
14383 unsigned NumArgs = 1;
14388 if (Opc == UO_PostInc || Opc == UO_PostDec) {
14402 if (Opc == UO_PreDec || Opc == UO_PreInc || Opc == UO_Deref)
14408 CurFPFeatureOverrides());
14417 CurFPFeatureOverrides());
14424 AddNonMemberOperatorCandidates(Fns, ArgsArray, CandidateSet);
14427 AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
14431 AddArgumentDependentLookupCandidates(OpName, OpLoc, ArgsArray,
14437 AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
14439 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
14454 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14455 CheckMemberOperatorAccess(OpLoc, Input,
nullptr, Best->FoundDecl);
14458 if (Method->isExplicitObjectMemberFunction())
14459 InputInit = InitializeExplicitObjectArgument(*
this, Input, Method);
14461 InputInit = PerformImplicitObjectArgumentInitialization(
14462 Input,
nullptr, Best->FoundDecl, Method);
14465 Base = Input = InputInit.
get();
14476 Input = InputInit.
get();
14481 Base, HadMultipleCandidates,
14493 Context, Op, FnExpr.
get(), ArgsArray, ResultTy, VK, OpLoc,
14494 CurFPFeatureOverrides(), Best->IsADLCandidate);
14496 if (CheckCallReturnType(FnDecl->
getReturnType(), OpLoc, TheCall, FnDecl))
14499 if (CheckFunctionCall(FnDecl, TheCall,
14502 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FnDecl);
14507 ExprResult InputRes = PerformImplicitConversion(
14508 Input, Best->BuiltinParamTypes[0], Best->Conversions[0], AA_Passing,
14512 Input = InputRes.
get();
14532 PDiag(diag::err_ovl_ambiguous_oper_unary)
14549 << (Msg !=
nullptr)
14550 << (Msg ? Msg->
getString() : StringRef())
14561 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
14578 AddNonMemberOperatorCandidates(Fns, Args, CandidateSet);
14581 AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
14583 AddMemberOperatorCandidates(Op, OpLoc, {Args[1], Args[0]}, CandidateSet,
14588 AddMemberOperatorCandidates(ExtraOp, OpLoc, Args, CandidateSet);
14590 AddMemberOperatorCandidates(ExtraOp, OpLoc, {Args[1], Args[0]},
14598 if (Op != OO_Equal && PerformADL) {
14600 AddArgumentDependentLookupCandidates(OpName, OpLoc, Args,
14606 AddArgumentDependentLookupCandidates(ExtraOpName, OpLoc, Args,
14625 AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
14654 Expr *RHS,
bool PerformADL,
14655 bool AllowRewrittenCandidates,
14657 Expr *Args[2] = { LHS, RHS };
14661 AllowRewrittenCandidates =
false;
14667 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
14692 CurFPFeatureOverrides());
14697 if (Opc == BO_PtrMemD) {
14698 auto CheckPlaceholder = [&](
Expr *&Arg) {
14707 if (CheckPlaceholder(Args[0]) || CheckPlaceholder(Args[1]))
14709 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14728 if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
14729 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14734 Op, OpLoc, AllowRewrittenCandidates));
14736 CandidateSet.
exclude(DefaultedFn);
14737 LookupOverloadedBinOp(CandidateSet, Op, Fns, Args, PerformADL);
14739 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
14748 bool IsReversed = Best->isReversed();
14750 std::swap(Args[0], Args[1]);
14767 if (Best->RewriteKind && ChosenOp == OO_EqualEqual &&
14771 Diag(OpLoc, IsExtension ? diag::ext_ovl_rewrite_equalequal_not_bool
14772 : diag::err_ovl_rewrite_equalequal_not_bool)
14780 if (AllowRewrittenCandidates && !IsReversed &&
14788 if (Cand.Viable && Cand.Function && Cand.isReversed() &&
14790 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
14792 *
this, OpLoc, Cand.Conversions[ArgIdx],
14793 Best->Conversions[ArgIdx]) ==
14795 AmbiguousWith.push_back(Cand.Function);
14802 if (!AmbiguousWith.empty()) {
14803 bool AmbiguousWithSelf =
14804 AmbiguousWith.size() == 1 &&
14806 Diag(OpLoc, diag::ext_ovl_ambiguous_oper_binary_reversed)
14808 << Args[0]->
getType() << Args[1]->
getType() << AmbiguousWithSelf
14810 if (AmbiguousWithSelf) {
14812 diag::note_ovl_ambiguous_oper_binary_reversed_self);
14817 if (
auto *MD = dyn_cast<CXXMethodDecl>(FnDecl))
14818 if (Op == OverloadedOperatorKind::OO_EqualEqual &&
14820 !MD->hasCXXExplicitFunctionObjectParameter() &&
14822 MD->getFunctionObjectParameterType(),
14823 MD->getParamDecl(0)->getType().getNonReferenceType()) &&
14825 MD->getFunctionObjectParameterType(),
14828 MD->getFunctionObjectParameterType(),
14831 diag::note_ovl_ambiguous_eqeq_reversed_self_non_const);
14834 diag::note_ovl_ambiguous_oper_binary_selected_candidate);
14835 for (
auto *F : AmbiguousWith)
14836 Diag(F->getLocation(),
14837 diag::note_ovl_ambiguous_oper_binary_reversed_candidate);
14845 if (Op == OO_Equal)
14846 diagnoseNullableToNonnullConversion(Args[0]->getType(),
14847 Args[1]->getType(), OpLoc);
14850 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14852 CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
14856 if (Method->isExplicitObjectMemberFunction()) {
14857 Arg0 = InitializeExplicitObjectArgument(*
this, Args[0], FnDecl);
14860 Arg0 = PerformImplicitObjectArgumentInitialization(
14861 Args[0],
nullptr, Best->FoundDecl, Method);
14863 Arg1 = PerformCopyInitialization(
14874 ExprResult Arg0 = PerformCopyInitialization(
14882 PerformCopyInitialization(
14894 Best->FoundDecl,
Base,
14895 HadMultipleCandidates, OpLoc);
14906 const Expr *ImplicitThis =
nullptr;
14911 Context, ChosenOp, FnExpr.
get(), Args, ResultTy, VK, OpLoc,
14912 CurFPFeatureOverrides(), Best->IsADLCandidate);
14914 if (
const auto *Method = dyn_cast<CXXMethodDecl>(FnDecl);
14915 Method && Method->isImplicitObjectMemberFunction()) {
14917 ImplicitThis = ArgsArray[0];
14918 ArgsArray = ArgsArray.slice(1);
14921 if (CheckCallReturnType(FnDecl->
getReturnType(), OpLoc, TheCall,
14926 if (Op == OO_Equal)
14927 DiagnoseSelfMove(Args[0], Args[1], OpLoc);
14929 if (ImplicitThis) {
14932 cast<CXXMethodDecl>(FnDecl)->getFunctionObjectParameterType());
14934 CheckArgAlignment(OpLoc, FnDecl,
"'this'", ThisType,
14938 checkCall(FnDecl,
nullptr, ImplicitThis, ArgsArray,
14940 VariadicDoesNotApply);
14942 ExprResult R = MaybeBindToTemporary(TheCall);
14946 R = CheckForImmediateInvocation(R, FnDecl);
14953 (Op == OO_Spaceship && IsReversed)) {
14954 if (Op == OO_ExclaimEqual) {
14955 assert(ChosenOp == OO_EqualEqual &&
"unexpected operator name");
14956 R = CreateBuiltinUnaryOp(OpLoc, UO_LNot, R.
get());
14958 assert(ChosenOp == OO_Spaceship &&
"unexpected operator name");
14960 Expr *ZeroLiteral =
14966 pushCodeSynthesisContext(Ctx);
14968 R = CreateOverloadedBinOp(
14969 OpLoc, Opc, Fns, IsReversed ? ZeroLiteral : R.
get(),
14970 IsReversed ? R.
get() : ZeroLiteral,
true,
14973 popCodeSynthesisContext();
14978 assert(ChosenOp == Op &&
"unexpected operator name");
14982 if (Best->RewriteKind !=
CRK_None)
14990 ExprResult ArgsRes0 = PerformImplicitConversion(
14991 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
14995 Args[0] = ArgsRes0.
get();
14997 ExprResult ArgsRes1 = PerformImplicitConversion(
14998 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
15002 Args[1] = ArgsRes1.
get();
15012 if (Opc == BO_Comma)
15017 if (DefaultedFn && Opc == BO_Cmp) {
15018 ExprResult E = BuildSynthesizedThreeWayComparison(OpLoc, Fns, Args[0],
15019 Args[1], DefaultedFn);
15034 Opc >= BO_Assign && Opc <= BO_OrAssign) {
15035 Diag(OpLoc, diag::err_ovl_no_viable_oper)
15038 if (Args[0]->getType()->isIncompleteType()) {
15039 Diag(OpLoc, diag::note_assign_lhs_incomplete)
15053 Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
15055 assert(
Result.isInvalid() &&
15056 "C++ binary operator overloading is missing candidates!");
15065 << Args[0]->getType()
15066 << Args[1]->getType()
15067 << Args[0]->getSourceRange()
15068 << Args[1]->getSourceRange()),
15074 if (isImplicitlyDeleted(Best->Function)) {
15078 Diag(OpLoc, diag::err_ovl_deleted_special_oper)
15083 Diag(OpLoc, diag::err_ovl_deleted_comparison)
15084 << Args[0]->
getType() << DeletedFD;
15089 NoteDeletedFunction(DeletedFD);
15097 PDiag(diag::err_ovl_deleted_oper)
15099 .getCXXOverloadedOperator())
15100 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef())
15101 << Args[0]->getSourceRange() << Args[1]->getSourceRange()),
15109 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
15125 "cannot use prvalue expressions more than once");
15126 Expr *OrigLHS = LHS;
15127 Expr *OrigRHS = RHS;
15131 LHS =
new (Context)
15134 RHS =
new (Context)
15138 ExprResult Eq = CreateOverloadedBinOp(OpLoc, BO_EQ, Fns, LHS, RHS,
true,
true,
15140 if (
Eq.isInvalid())
15143 ExprResult Less = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, LHS, RHS,
true,
15144 true, DefaultedFn);
15145 if (
Less.isInvalid())
15150 Greater = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, RHS, LHS,
true,
true,
15157 struct Comparison {
15172 for (; I >= 0; --I) {
15174 auto *VI = Info->lookupValueInfo(Comparisons[I].
Result);
15185 Result = ActOnConditionalOp(OpLoc, OpLoc, Comparisons[I].Cmp.get(),
15197 Context, OrigLHS, OrigRHS, BO_Cmp,
Result.get()->getType(),
15198 Result.get()->getValueKind(),
Result.get()->getObjectKind(), OpLoc,
15199 CurFPFeatureOverrides());
15200 Expr *SemanticForm[] = {LHS, RHS,
Result.get()};
15210 unsigned NumArgsSlots =
15211 MethodArgs.size() + std::max<unsigned>(Args.size(), NumParams);
15214 MethodArgs.reserve(MethodArgs.size() + NumArgsSlots);
15215 bool IsError =
false;
15218 for (
unsigned i = 0; i != NumParams; i++) {
15220 if (i < Args.size()) {
15238 MethodArgs.push_back(Arg);
15248 Args.push_back(
Base);
15249 for (
auto *e : ArgExpr) {
15258 ArgExpr.back()->getEndLoc());
15276 CurFPFeatureOverrides());
15280 UnbridgedCastsSet UnbridgedCasts;
15290 AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
15293 if (Args.size() == 2)
15294 AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
15296 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15309 CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, Best->FoundDecl);
15318 InitializeExplicitObjectArgument(*
this, Args[0], Method);
15321 Args[0] = Res.
get();
15324 ExprResult Arg0 = PerformImplicitObjectArgumentInitialization(
15325 Args[0],
nullptr, Best->FoundDecl, Method);
15329 MethodArgs.push_back(Arg0.
get());
15333 *
this, MethodArgs, Method, ArgExpr, LLoc);
15341 *
this, FnDecl, Best->FoundDecl,
Base, HadMultipleCandidates,
15352 Context, OO_Subscript, FnExpr.
get(), MethodArgs, ResultTy, VK, RLoc,
15353 CurFPFeatureOverrides());
15355 if (CheckCallReturnType(FnDecl->
getReturnType(), LLoc, TheCall, FnDecl))
15358 if (CheckFunctionCall(Method, TheCall,
15362 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
15368 ExprResult ArgsRes0 = PerformImplicitConversion(
15369 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
15373 Args[0] = ArgsRes0.
get();
15375 ExprResult ArgsRes1 = PerformImplicitConversion(
15376 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
15380 Args[1] = ArgsRes1.
get();
15388 CandidateSet.
empty()
15389 ? (PDiag(diag::err_ovl_no_oper)
15390 << Args[0]->getType() << 0
15391 << Args[0]->getSourceRange() << Range)
15392 : (PDiag(diag::err_ovl_no_viable_subscript)
15393 << Args[0]->getType() << Args[0]->getSourceRange() << Range);
15400 if (Args.size() == 2) {
15403 LLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
15404 <<
"[]" << Args[0]->getType() << Args[1]->getType()
15405 << Args[0]->getSourceRange() << Range),
15410 PDiag(diag::err_ovl_ambiguous_subscript_call)
15411 << Args[0]->getType()
15412 << Args[0]->getSourceRange() << Range),
15421 PDiag(diag::err_ovl_deleted_oper)
15422 <<
"[]" << (Msg !=
nullptr)
15423 << (Msg ? Msg->
getString() : StringRef())
15424 << Args[0]->getSourceRange() << Range),
15431 return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
15445 Expr *ExecConfig,
bool IsExecConfig,
15446 bool AllowRecovery) {
15455 if (
BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
15457 assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
15470 QualType objectType = op->getLHS()->getType();
15471 if (op->getOpcode() == BO_PtrMemI)
15475 Qualifiers difference = objectQuals - funcQuals;
15479 std::string qualsString = difference.
getAsString();
15480 Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
15483 << (qualsString.find(
' ') == std::string::npos ? 1 : 2);
15487 Context, MemExprE, Args, resultType, valueKind, RParenLoc,
15490 if (CheckCallReturnType(proto->
getReturnType(), op->getRHS()->getBeginLoc(),
15494 if (ConvertArgumentsForCall(call, op,
nullptr, proto, Args, RParenLoc))
15497 if (CheckOtherCall(call, proto))
15500 return MaybeBindToTemporary(call);
15507 if (!AllowRecovery)
15509 std::vector<Expr *> SubExprs = {MemExprE};
15510 llvm::append_range(SubExprs, Args);
15511 return CreateRecoveryExpr(MemExprE->
getBeginLoc(), RParenLoc, SubExprs,
15514 if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
15516 RParenLoc, CurFPFeatureOverrides());
15518 UnbridgedCastsSet UnbridgedCasts;
15524 bool HadMultipleCandidates =
false;
15527 if (isa<MemberExpr>(NakedMemExpr)) {
15528 MemExpr = cast<MemberExpr>(NakedMemExpr);
15532 UnbridgedCasts.restore();
15550 TemplateArgs = &TemplateArgsBuffer;
15554 E = UnresExpr->
decls_end(); I != E; ++I) {
15556 QualType ExplicitObjectType = ObjectType;
15560 if (isa<UsingShadowDecl>(
Func))
15561 Func = cast<UsingShadowDecl>(
Func)->getTargetDecl();
15563 bool HasExplicitParameter =
false;
15564 if (
const auto *M = dyn_cast<FunctionDecl>(
Func);
15565 M && M->hasCXXExplicitFunctionObjectParameter())
15566 HasExplicitParameter =
true;
15567 else if (
const auto *M = dyn_cast<FunctionTemplateDecl>(
Func);
15569 M->getTemplatedDecl()->hasCXXExplicitFunctionObjectParameter())
15570 HasExplicitParameter =
true;
15572 if (HasExplicitParameter)
15576 if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(
Func)) {
15577 AddOverloadCandidate(cast<CXXConstructorDecl>(
Func), I.getPair(), Args,
15580 }
else if ((Method = dyn_cast<CXXMethodDecl>(
Func))) {
15586 AddMethodCandidate(Method, I.getPair(), ActingDC, ExplicitObjectType,
15587 ObjectClassification, Args, CandidateSet,
15590 AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(
Func),
15591 I.getPair(), ActingDC, TemplateArgs,
15592 ExplicitObjectType, ObjectClassification,
15593 Args, CandidateSet,
15598 HadMultipleCandidates = (CandidateSet.
size() > 1);
15602 UnbridgedCasts.restore();
15605 bool Succeeded =
false;
15609 Method = cast<CXXMethodDecl>(Best->Function);
15610 FoundDecl = Best->FoundDecl;
15611 CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
15612 if (DiagnoseUseOfOverloadedDecl(Best->FoundDecl, UnresExpr->
getNameLoc()))
15620 if (Method != FoundDecl.getDecl() &&
15621 DiagnoseUseOfOverloadedDecl(Method, UnresExpr->
getNameLoc()))
15630 PDiag(diag::err_ovl_no_viable_member_function_in_call)
15637 PDiag(diag::err_ovl_ambiguous_member_call)
15642 DiagnoseUseOfDeletedFunction(
15644 CandidateSet, Best->Function, Args,
true);
15652 FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
15655 MemExprE = Res.
get();
15660 return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args, RParenLoc,
15661 ExecConfig, IsExecConfig);
15671 assert(Method &&
"Member call to something that isn't a method?");
15682 HadMultipleCandidates, MemExpr->
getExprLoc());
15688 CurFPFeatureOverrides(), Proto->getNumParams());
15693 ExprResult ObjectArg = PerformImplicitObjectArgumentInitialization(
15694 MemExpr->
getBase(), Qualifier, FoundDecl, Method);
15699 RParenLoc, CurFPFeatureOverrides(),
15700 Proto->getNumParams());
15706 return BuildRecoveryExpr(ResultType);
15709 if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
15711 return BuildRecoveryExpr(ResultType);
15713 DiagnoseSentinelCalls(Method, LParenLoc, Args);
15715 if (CheckFunctionCall(Method, TheCall, Proto))
15721 if (
auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
15722 if (
const EnableIfAttr *
Attr =
15723 CheckEnableIf(Method, LParenLoc, Args,
true)) {
15724 Diag(MemE->getMemberLoc(),
15725 diag::err_ovl_no_viable_member_function_in_call)
15728 diag::note_ovl_candidate_disabled_by_function_cond_attr)
15729 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
15734 if (isa<CXXConstructorDecl, CXXDestructorDecl>(CurContext) &&
15735 TheCall->getDirectCallee()->isPureVirtual()) {
15741 diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
15742 << MD->
getDeclName() << isa<CXXDestructorDecl>(CurContext)
15746 if (getLangOpts().AppleKext)
15752 if (
auto *DD = dyn_cast<CXXDestructorDecl>(TheCall->getDirectCallee())) {
15754 bool CallCanBeVirtual = !MemExpr->
hasQualifier() || getLangOpts().AppleKext;
15755 CheckVirtualDtorCall(DD, MemExpr->
getBeginLoc(),
false,
15756 CallCanBeVirtual,
true,
15760 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
15761 TheCall->getDirectCallee());
15777 UnbridgedCastsSet UnbridgedCasts;
15781 assert(Object.get()->getType()->isRecordType() &&
15782 "Requires object type argument");
15795 if (RequireCompleteType(LParenLoc, Object.get()->getType(),
15796 diag::err_incomplete_object_call, Object.get()))
15800 LookupResult R(*
this, OpName, LParenLoc, LookupOrdinaryName);
15801 LookupQualifiedName(R,
Record->getDecl());
15802 R.suppressAccessDiagnostics();
15805 Oper != OperEnd; ++Oper) {
15806 AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
15807 Object.get()->Classify(Context), Args, CandidateSet,
15819 bool IgnoreSurrogateFunctions =
false;
15820 if (CandidateSet.
size() == 1 &&
Record->getAsCXXRecordDecl()->isLambda()) {
15822 if (!Candidate.
Viable &&
15824 IgnoreSurrogateFunctions =
true;
15844 const auto &Conversions =
15845 cast<CXXRecordDecl>(
Record->getDecl())->getVisibleConversionFunctions();
15846 for (
auto I = Conversions.begin(), E = Conversions.end();
15847 !IgnoreSurrogateFunctions && I != E; ++I) {
15850 if (isa<UsingShadowDecl>(D))
15851 D = cast<UsingShadowDecl>(D)->getTargetDecl();
15855 if (isa<FunctionTemplateDecl>(D))
15868 AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
15869 Object.get(), Args, CandidateSet);
15874 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15887 CandidateSet.
empty()
15888 ? (PDiag(diag::err_ovl_no_oper)
15889 << Object.get()->getType() << 1
15890 << Object.get()->getSourceRange())
15891 : (PDiag(diag::err_ovl_no_viable_object_call)
15892 << Object.get()->getType() << Object.get()->getSourceRange());
15899 if (!R.isAmbiguous())
15902 PDiag(diag::err_ovl_ambiguous_object_call)
15903 << Object.get()->getType()
15904 << Object.get()->getSourceRange()),
15915 PDiag(diag::err_ovl_deleted_object_call)
15916 << Object.get()->getType() << (Msg !=
nullptr)
15917 << (Msg ? Msg->
getString() : StringRef())
15918 << Object.get()->getSourceRange()),
15924 if (Best == CandidateSet.
end())
15927 UnbridgedCasts.restore();
15929 if (Best->Function ==
nullptr) {
15933 = cast<CXXConversionDecl>(
15934 Best->Conversions[0].UserDefined.ConversionFunction);
15936 CheckMemberOperatorAccess(LParenLoc, Object.get(),
nullptr,
15938 if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
15940 assert(Conv == Best->FoundDecl.getDecl() &&
15941 "Found Decl & conversion-to-functionptr should be same, right?!");
15948 ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
15949 Conv, HadMultipleCandidates);
15950 if (
Call.isInvalid())
15954 Context,
Call.get()->getType(), CK_UserDefinedConversion,
Call.get(),
15955 nullptr,
VK_PRValue, CurFPFeatureOverrides());
15957 return BuildCallExpr(S,
Call.get(), LParenLoc, Args, RParenLoc);
15960 CheckMemberOperatorAccess(LParenLoc, Object.get(),
nullptr, Best->FoundDecl);
15965 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
15978 Obj, HadMultipleCandidates,
15985 MethodArgs.reserve(NumParams + 1);
15987 bool IsError =
false;
15993 DiagnoseInvalidExplicitObjectParameterInLambda(Method);
15996 ExprResult ObjRes = PerformImplicitObjectArgumentInitialization(
15997 Object.get(),
nullptr, Best->FoundDecl, Method);
16002 MethodArgs.push_back(Object.get());
16006 *
this, MethodArgs, Method, Args, LParenLoc);
16009 if (Proto->isVariadic()) {
16011 for (
unsigned i = NumParams, e = Args.size(); i < e; i++) {
16012 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
16015 MethodArgs.push_back(Arg.
get());
16022 DiagnoseSentinelCalls(Method, LParenLoc, Args);
16030 Context, OO_Call, NewFn.
get(), MethodArgs, ResultTy, VK, RParenLoc,
16031 CurFPFeatureOverrides());
16033 if (CheckCallReturnType(Method->
getReturnType(), LParenLoc, TheCall, Method))
16036 if (CheckFunctionCall(Method, TheCall, Proto))
16039 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
16047 bool *NoArrowOperatorFound) {
16048 assert(
Base->getType()->isRecordType() &&
16049 "left-hand side must have class type");
16066 if (RequireCompleteType(Loc,
Base->getType(),
16067 diag::err_typecheck_incomplete_tag,
Base))
16070 LookupResult R(*
this, OpName, OpLoc, LookupOrdinaryName);
16075 Oper != OperEnd; ++Oper) {
16076 AddMethodCandidate(Oper.getPair(),
Base->getType(),
Base->Classify(Context),
16077 std::nullopt, CandidateSet,
16081 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16092 if (CandidateSet.
empty()) {
16094 if (NoArrowOperatorFound) {
16097 *NoArrowOperatorFound =
true;
16100 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
16101 << BaseType <<
Base->getSourceRange();
16103 Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
16107 Diag(OpLoc, diag::err_ovl_no_viable_oper)
16108 <<
"operator->" <<
Base->getSourceRange();
16116 <<
"->" <<
Base->getType()
16117 <<
Base->getSourceRange()),
16125 <<
"->" << (Msg !=
nullptr)
16126 << (Msg ? Msg->
getString() : StringRef())
16127 <<
Base->getSourceRange()),
16133 CheckMemberOperatorAccess(OpLoc,
Base,
nullptr, Best->FoundDecl);
16136 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
16139 ExprResult R = InitializeExplicitObjectArgument(*
this,
Base, Method);
16145 Base,
nullptr, Best->FoundDecl, Method);
16153 Base, HadMultipleCandidates, OpLoc);
16163 ResultTy, VK, OpLoc, CurFPFeatureOverrides());
16165 if (CheckCallReturnType(Method->
getReturnType(), OpLoc, TheCall, Method))
16168 if (CheckFunctionCall(Method, TheCall,
16172 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
16186 AddNonMemberOperatorCandidates(R.
asUnresolvedSet(), Args, CandidateSet,
16189 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16202 PDiag(diag::err_ovl_no_viable_function_in_call)
16217 nullptr, HadMultipleCandidates,
16226 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
16227 ExprResult InputInit = PerformCopyInitialization(
16232 ConvArgs[ArgIdx] = InputInit.
get();
16241 LitEndLoc, UDSuffixLoc, CurFPFeatureOverrides());
16243 if (CheckCallReturnType(FD->
getReturnType(), UDSuffixLoc, UDL, FD))
16246 if (CheckFunctionCall(FD, UDL,
nullptr))
16249 return CheckForImmediateInvocation(MaybeBindToTemporary(UDL), FD);
16266 Scope *S =
nullptr;
16269 if (!MemberLookup.
empty()) {
16271 BuildMemberReferenceExpr(Range, Range->getType(), Loc,
16279 return FRS_DiagnosticIssued;
16282 BuildCallExpr(S, MemberRef.
get(), Loc, std::nullopt, Loc,
nullptr);
16285 return FRS_DiagnosticIssued;
16288 ExprResult FnR = CreateUnresolvedLookupExpr(
nullptr,
16292 return FRS_DiagnosticIssued;
16295 bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc,
16297 if (CandidateSet->
empty() || CandidateSetError) {
16299 return FRS_NoViableFunction;
16307 return FRS_NoViableFunction;
16310 Loc,
nullptr, CandidateSet, &Best,
16315 return FRS_DiagnosticIssued;
16318 return FRS_Success;
16329 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
16331 FixOverloadedFunctionReference(PE->getSubExpr(), Found, Fn);
16334 if (SubExpr.
get() == PE->getSubExpr())
16337 return new (Context)
16338 ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.
get());
16343 FixOverloadedFunctionReference(ICE->getSubExpr(), Found, Fn);
16346 assert(Context.
hasSameType(ICE->getSubExpr()->getType(),
16348 "Implicit cast type cannot be determined from overload");
16349 assert(ICE->path_empty() &&
"fixing up hierarchy conversion?");
16350 if (SubExpr.
get() == ICE->getSubExpr())
16355 CurFPFeatureOverrides());
16358 if (
auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
16359 if (!GSE->isResultDependent()) {
16361 FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
16364 if (SubExpr.
get() == GSE->getResultExpr())
16371 unsigned ResultIdx = GSE->getResultIndex();
16372 AssocExprs[ResultIdx] = SubExpr.
get();
16374 if (GSE->isExprPredicate())
16376 Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
16377 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16378 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16381 Context, GSE->getGenericLoc(), GSE->getControllingType(),
16382 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16383 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16392 assert(UnOp->getOpcode() == UO_AddrOf &&
16393 "Can only take the address of an overloaded function");
16395 if (Method->isStatic()) {
16403 FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
16406 if (SubExpr.
get() == UnOp->getSubExpr())
16409 if (CheckUseOfCXXMethodAsAddressOfOperand(UnOp->getBeginLoc(),
16410 SubExpr.
get(), Method))
16413 assert(isa<DeclRefExpr>(SubExpr.
get()) &&
16414 "fixed to something other than a decl ref");
16415 assert(cast<DeclRefExpr>(SubExpr.
get())->getQualifier() &&
16416 "fixed to a member ref with no nested name qualifier");
16427 (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
16431 UnOp->getOperatorLoc(),
false,
16432 CurFPFeatureOverrides());
16436 FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
16439 if (SubExpr.
get() == UnOp->getSubExpr())
16442 return CreateBuiltinUnaryOp(UnOp->getOperatorLoc(), UO_AddrOf,
16449 if (ULE->hasExplicitTemplateArgs()) {
16450 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
16451 TemplateArgs = &TemplateArgsBuffer;
16466 Fn,
Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
16467 Found.
getDecl(), ULE->getTemplateKeywordLoc(), TemplateArgs);
16475 if (MemExpr->hasExplicitTemplateArgs()) {
16476 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
16477 TemplateArgs = &TemplateArgsBuffer;
16484 if (MemExpr->isImplicitAccess()) {
16485 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16488 MemExpr->getQualifierLoc(), Found.
getDecl(),
16489 MemExpr->getTemplateKeywordLoc(), TemplateArgs);
16494 if (MemExpr->getQualifier())
16495 Loc = MemExpr->getQualifierLoc().getBeginLoc();
16497 BuildCXXThisExpr(Loc, MemExpr->getBaseType(),
true);
16500 Base = MemExpr->getBase();
16504 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16512 return BuildMemberExpr(
16513 Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
16514 MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
16515 true, MemExpr->getMemberNameInfo(),
16519 llvm_unreachable(
"Invalid reference to overloaded function");
16525 return FixOverloadedFunctionReference(E.
get(), Found, Fn);
16530 if (!PartialOverloading || !
Function)
16534 if (
const auto *Proto =
16535 dyn_cast<FunctionProtoType>(
Function->getFunctionType()))
16536 if (Proto->isTemplateVariadic())
16538 if (
auto *Pattern =
Function->getTemplateInstantiationPattern())
16539 if (
const auto *Proto =
16540 dyn_cast<FunctionProtoType>(Pattern->getFunctionType()))
16541 if (Proto->isTemplateVariadic())
16554 << IsMember << Name << (Msg !=
nullptr)
16555 << (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...
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 bool IsOverloaded(const UnresolvedSetImpl &Functions)
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 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)
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 getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
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.
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...
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.
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...
void getAssociatedConstraints(SmallVectorImpl< const Expr * > &AC) const
Get the associated-constraints of this function declaration.
bool isTargetMultiVersionDefault() const
True if this function is the default version of a multiversioned dispatch function as a part of the t...
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
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_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
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
Qualifiers withoutObjCLifetime() 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...
void setObjCLifetime(ObjCLifetime type)
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...
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...
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)
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast.
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.
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...
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?
bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef< const Expr * > AC1, NamedDecl *D2, MutableArrayRef< const Expr * > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
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 isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
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.
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, UnresolvedLookupExpr *AsULE=nullptr)
Builds an expression which might be an implicit member expression.
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 isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool 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
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
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.
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.