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);
6570 From,
Result.get()->getType());
6596 HadMultipleCandidates);
6601 CK_UserDefinedConversion,
Result.get(),
6602 nullptr,
Result.get()->getValueKind(),
6621 for (
unsigned I = 0, N = ViableConversions.
size(); I != N; ++I) {
6625 if (isa<UsingShadowDecl>(D))
6626 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6630 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
6633 Conv = cast<CXXConversionDecl>(D);
6637 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
6641 ToType, CandidateSet,
6673 ExprResult result = CheckPlaceholderExpr(From);
6676 From = result.
get();
6680 ExprResult Converted = DefaultLvalueConversion(From);
6691 if (!RecordTy || !getLangOpts().CPlusPlus) {
6703 : Converter(Converter), From(From) {}
6708 } IncompleteDiagnoser(Converter, From);
6710 if (Converter.
Suppress ? !isCompleteType(Loc,
T)
6711 : RequireCompleteType(Loc,
T, IncompleteDiagnoser))
6718 const auto &Conversions =
6719 cast<CXXRecordDecl>(RecordTy->
getDecl())->getVisibleConversionFunctions();
6721 bool HadMultipleCandidates =
6722 (std::distance(Conversions.begin(), Conversions.end()) > 1);
6726 bool HasUniqueTargetType =
true;
6729 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
6739 Conversion = cast<CXXConversionDecl>(D);
6741 assert((!ConvTemplate || getLangOpts().
CPlusPlus14) &&
6742 "Conversion operator templates are considered potentially "
6746 if (Converter.
match(CurToType) || ConvTemplate) {
6752 ExplicitConversions.
addDecl(I.getDecl(), I.getAccess());
6757 else if (HasUniqueTargetType &&
6759 HasUniqueTargetType =
false;
6761 ViableConversions.
addDecl(I.getDecl(), I.getAccess());
6779 HadMultipleCandidates,
6780 ExplicitConversions))
6786 if (!HasUniqueTargetType)
6805 HadMultipleCandidates, Found))
6814 HadMultipleCandidates,
6815 ExplicitConversions))
6823 switch (ViableConversions.
size()) {
6826 HadMultipleCandidates,
6827 ExplicitConversions))
6837 HadMultipleCandidates, Found))
6868 if (Proto->getNumParams() < 1)
6872 QualType ArgType = Proto->getParamType(0).getNonReferenceType();
6877 if (Proto->getNumParams() < 2)
6881 QualType ArgType = Proto->getParamType(1).getNonReferenceType();
6901 unsigned SeenAt = 0;
6903 bool HasDefault =
false;
6912 return HasDefault || SeenAt != 0;
6926 bool PartialOverloading,
bool AllowExplicit,
bool AllowExplicitConversions,
6931 assert(Proto &&
"Functions without a prototype cannot be overloaded");
6932 assert(!
Function->getDescribedFunctionTemplate() &&
6933 "Use AddTemplateOverloadCandidate for function templates");
6936 if (!isa<CXXConstructorDecl>(Method)) {
6946 CandidateSet, SuppressUserConversions,
6947 PartialOverloading, EarlyConversions, PO);
6961 if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
6962 Constructor->isMoveConstructor())
6982 CandidateSet.
addCandidate(Args.size(), EarlyConversions);
6997 Candidate.
Viable =
false;
7003 if (getLangOpts().CPlusPlusModules &&
Function->isInAnotherModuleUnit()) {
7010 if (
auto *SpecInfo =
Function->getTemplateSpecializationInfo())
7011 ND = SpecInfo->getTemplate();
7014 Candidate.
Viable =
false;
7021 Candidate.
Viable =
false;
7031 if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
7033 IsDerivedFrom(Args[0]->getBeginLoc(), Args[0]->getType(),
7035 Candidate.
Viable =
false;
7047 auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
7048 if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
7049 Constructor->getParamDecl(0)->getType()->isReferenceType()) {
7050 QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
7056 Candidate.
Viable =
false;
7065 Constructor->getMethodQualifiers().getAddressSpace(),
7067 Candidate.
Viable =
false;
7080 Candidate.
Viable =
false;
7090 unsigned MinRequiredArgs =
Function->getMinRequiredArguments();
7091 if (!AggregateCandidateDeduction && Args.size() < MinRequiredArgs &&
7092 !PartialOverloading) {
7094 Candidate.
Viable =
false;
7100 if (getLangOpts().
CUDA) {
7108 Candidate.
Viable =
false;
7114 if (
Function->getTrailingRequiresClause()) {
7116 if (CheckFunctionConstraints(
Function, Satisfaction, {},
7119 Candidate.
Viable =
false;
7127 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7130 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7133 }
else if (ArgIdx < NumParams) {
7140 *
this, Args[ArgIdx], ParamType, SuppressUserConversions,
7143 getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
7145 Candidate.
Viable =
false;
7157 if (EnableIfAttr *FailedAttr =
7159 Candidate.
Viable =
false;
7169 if (Methods.size() <= 1)
7172 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7180 if (Args.size() < NumNamedArgs)
7183 for (
unsigned i = 0; i < NumNamedArgs; i++) {
7185 if (Args[i]->isTypeDependent()) {
7191 Expr *argExpr = Args[i];
7192 assert(argExpr &&
"SelectBestMethod(): missing expression");
7197 !param->
hasAttr<CFConsumedAttr>())
7198 argExpr = stripARCUnbridgedCast(argExpr);
7211 getLangOpts().ObjCAutoRefCount,
7215 if (ConversionState.
isBad() ||
7225 for (
unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
7226 if (Args[i]->isTypeDependent()) {
7230 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
7239 if (Args.size() != NumNamedArgs)
7241 else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
7244 for (
unsigned b = 0, e = Methods.size();
b < e;
b++) {
7245 QualType ReturnT = Methods[
b]->getReturnType();
7264 assert(!isa<CXXConstructorDecl>(Method) &&
7265 "Shouldn't have `this` for ctors!");
7266 assert(!Method->
isStatic() &&
"Shouldn't have `this` for static methods!");
7268 ThisArg,
nullptr, Method, Method);
7271 ConvertedThis = R.
get();
7273 if (
auto *MD = dyn_cast<CXXMethodDecl>(
Function)) {
7275 assert((MissingImplicitThis || MD->isStatic() ||
7276 isa<CXXConstructorDecl>(MD)) &&
7277 "Expected `this` for non-ctor instance methods");
7279 ConvertedThis =
nullptr;
7284 unsigned ArgSizeNoVarargs = std::min(
Function->param_size(), Args.size());
7287 for (
unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
7296 ConvertedArgs.push_back(R.
get());
7304 for (
unsigned i = Args.size(), e =
Function->getNumParams(); i != e; ++i) {
7306 if (!
P->hasDefaultArg())
7311 ConvertedArgs.push_back(R.
get());
7323 bool MissingImplicitThis) {
7324 auto EnableIfAttrs =
Function->specific_attrs<EnableIfAttr>();
7325 if (EnableIfAttrs.begin() == EnableIfAttrs.end())
7331 Expr *DiscardedThis;
7333 *
this,
Function,
nullptr, CallLoc, Args, Trap,
7334 true, DiscardedThis, ConvertedArgs))
7335 return *EnableIfAttrs.begin();
7337 for (
auto *EIA : EnableIfAttrs) {
7341 if (EIA->getCond()->isValueDependent() ||
7342 !EIA->getCond()->EvaluateWithSubstitution(
7346 if (!
Result.isInt() || !
Result.getInt().getBoolValue())
7352template <
typename CheckFn>
7355 CheckFn &&IsSuccessful) {
7358 if (ArgDependent == DIA->getArgDependent())
7359 Attrs.push_back(DIA);
7366 auto WarningBegin = std::stable_partition(
7367 Attrs.begin(), Attrs.end(),
7368 [](
const DiagnoseIfAttr *DIA) { return DIA->isError(); });
7372 auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
7374 if (ErrAttr != WarningBegin) {
7375 const DiagnoseIfAttr *DIA = *ErrAttr;
7376 S.
Diag(Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
7377 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7378 << DIA->getParent() << DIA->getCond()->getSourceRange();
7382 for (
const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
7383 if (IsSuccessful(DIA)) {
7384 S.
Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
7385 S.
Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7386 << DIA->getParent() << DIA->getCond()->getSourceRange();
7393 const Expr *ThisArg,
7398 [&](
const DiagnoseIfAttr *DIA) {
7403 if (!DIA->getCond()->EvaluateWithSubstitution(
7404 Result, Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
7406 return Result.isInt() &&
Result.getInt().getBoolValue();
7413 *
this, ND,
false, Loc,
7414 [&](
const DiagnoseIfAttr *DIA) {
7427 bool SuppressUserConversions,
7428 bool PartialOverloading,
7429 bool FirstArgumentIsBase) {
7438 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
7441 if (Args.size() > 0) {
7442 if (
Expr *E = Args[0]) {
7444 ObjectType = E->getType();
7450 ObjectClassification = E->Classify(Context);
7452 FunctionArgs = Args.slice(1);
7455 AddMethodTemplateCandidate(
7456 FunTmpl, F.getPair(),
7458 ExplicitTemplateArgs, ObjectType, ObjectClassification,
7459 FunctionArgs, CandidateSet, SuppressUserConversions,
7460 PartialOverloading);
7462 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
7463 cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
7464 ObjectClassification, FunctionArgs, CandidateSet,
7465 SuppressUserConversions, PartialOverloading);
7472 if (Args.size() > 0 &&
7473 (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
7474 !isa<CXXConstructorDecl>(FD)))) {
7475 assert(cast<CXXMethodDecl>(FD)->isStatic());
7476 FunctionArgs = Args.slice(1);
7479 AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
7480 ExplicitTemplateArgs, FunctionArgs,
7481 CandidateSet, SuppressUserConversions,
7482 PartialOverloading);
7484 AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet,
7485 SuppressUserConversions, PartialOverloading);
7497 bool SuppressUserConversions,
7502 if (isa<UsingShadowDecl>(
Decl))
7503 Decl = cast<UsingShadowDecl>(
Decl)->getTargetDecl();
7506 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
7507 "Expected a member function template");
7508 AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
7509 nullptr, ObjectType,
7510 ObjectClassification, Args, CandidateSet,
7511 SuppressUserConversions,
false, PO);
7513 AddMethodCandidate(cast<CXXMethodDecl>(
Decl), FoundDecl, ActingContext,
7514 ObjectType, ObjectClassification, Args, CandidateSet,
7515 SuppressUserConversions,
false, std::nullopt, PO);
7532 bool SuppressUserConversions,
7533 bool PartialOverloading,
7538 assert(Proto &&
"Methods without a prototype cannot be overloaded");
7539 assert(!isa<CXXConstructorDecl>(Method) &&
7540 "Use AddOverloadCandidate for constructors");
7558 CandidateSet.
addCandidate(Args.size() + 1, EarlyConversions);
7576 Candidate.
Viable =
false;
7587 if (Args.size() < MinRequiredArgs && !PartialOverloading) {
7589 Candidate.
Viable =
false;
7609 Candidate.
Conversions[FirstConvIdx].setStaticObjectArgument();
7614 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7615 Method, ActingContext,
true);
7616 if (Candidate.
Conversions[FirstConvIdx].isBad()) {
7617 Candidate.
Viable =
false;
7624 if (getLangOpts().
CUDA)
7625 if (!
CUDA().IsAllowedCall(getCurFunctionDecl(
true),
7627 Candidate.
Viable =
false;
7634 if (CheckFunctionConstraints(Method, Satisfaction, {},
7637 Candidate.
Viable =
false;
7645 for (
unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7648 if (Candidate.
Conversions[ConvIdx].isInitialized()) {
7651 }
else if (ArgIdx < NumParams) {
7659 SuppressUserConversions,
7662 getLangOpts().ObjCAutoRefCount);
7664 Candidate.
Viable =
false;
7676 if (EnableIfAttr *FailedAttr =
7677 CheckEnableIf(Method, CandidateSet.
getLocation(), Args,
true)) {
7678 Candidate.
Viable =
false;
7685 Candidate.
Viable =
false;
7717 PartialOverloading,
false, ObjectType,
7718 ObjectClassification,
7720 return CheckNonDependentConversions(
7721 MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
7722 SuppressUserConversions, ActingContext, ObjectType,
7723 ObjectClassification, PO);
7727 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7730 Candidate.
Viable =
false;
7735 cast<CXXMethodDecl>(Candidate.
Function)->isStatic() ||
7750 assert(
Specialization &&
"Missing member function template specialization?");
7752 "Specialization is not a member function?");
7753 AddMethodCandidate(cast<CXXMethodDecl>(
Specialization), FoundDecl,
7754 ActingContext, ObjectType, ObjectClassification, Args,
7755 CandidateSet, SuppressUserConversions, PartialOverloading,
7772 bool PartialOverloading,
bool AllowExplicit,
ADLCallKind IsADLCandidate,
7784 Candidate.
Viable =
false;
7803 FunctionTemplate, ExplicitTemplateArgs, Args,
Specialization, Info,
7804 PartialOverloading, AggregateCandidateDeduction,
7808 return CheckNonDependentConversions(
7809 FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions,
7810 SuppressUserConversions,
nullptr,
QualType(), {}, PO);
7814 CandidateSet.
addCandidate(Conversions.size(), Conversions);
7817 Candidate.
Viable =
false;
7825 isa<CXXMethodDecl>(Candidate.
Function) &&
7826 !isa<CXXConstructorDecl>(Candidate.
Function);
7840 assert(
Specialization &&
"Missing function template specialization?");
7841 AddOverloadCandidate(
7842 Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
7843 PartialOverloading, AllowExplicit,
7844 false, IsADLCandidate, Conversions, PO,
7860 const bool AllowExplicit =
false;
7863 auto *Method = dyn_cast<CXXMethodDecl>(FD);
7864 bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
7865 unsigned ThisConversions = HasThisConversion ? 1 : 0;
7877 if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
7880 if (!FD->hasCXXExplicitFunctionObjectParameter() ||
7881 !ParamTypes[0]->isDependentType()) {
7883 *
this, CandidateSet.
getLocation(), ObjectType, ObjectClassification,
7884 Method, ActingContext,
true,
7885 FD->hasCXXExplicitFunctionObjectParameter() ? ParamTypes[0]
7887 if (Conversions[ConvIdx].isBad())
7893 Method && Method->hasCXXExplicitFunctionObjectParameter() ? 1 : 0;
7895 for (
unsigned I = 0, N = std::min(ParamTypes.size() - Offset, Args.size());
7897 QualType ParamType = ParamTypes[I + Offset];
7901 ConvIdx = Args.size() - 1 - I;
7902 assert(Args.size() + ThisConversions == 2 &&
7903 "number of args (including 'this') must be exactly 2 for "
7907 assert(!HasThisConversion || (ConvIdx == 0 && I == 0));
7910 ConvIdx = ThisConversions + I;
7912 Conversions[ConvIdx]
7914 SuppressUserConversions,
7917 getLangOpts().ObjCAutoRefCount,
7919 if (Conversions[ConvIdx].isBad())
7941 bool AllowObjCPointerConversion) {
7949 bool ObjCLifetimeConversion;
7951 ObjCLifetimeConversion))
7956 if (!AllowObjCPointerConversion)
7960 bool IncompatibleObjC =
false;
7976 bool AllowExplicit,
bool AllowResultConversion) {
7978 "Conversion function templates use AddTemplateConversionCandidate");
7986 if (DeduceReturnType(Conversion, From->
getExprLoc()))
7993 if (!AllowResultConversion &&
8005 AllowObjCConversionOnExplicit))
8027 if (!AllowExplicit && Conversion->
isExplicit()) {
8028 Candidate.
Viable =
false;
8043 const auto *ConversionContext =
8052 From->
Classify(Context), Conversion, ConversionContext,
8057 Candidate.
Viable =
false;
8064 if (CheckFunctionConstraints(Conversion, Satisfaction) ||
8066 Candidate.
Viable =
false;
8078 if (FromCanon == ToCanon ||
8079 IsDerivedFrom(CandidateSet.
getLocation(), FromCanon, ToCanon)) {
8080 Candidate.
Viable =
false;
8097 CK_FunctionToPointerDecay, &ConversionRef,
8101 if (!isCompleteType(From->
getBeginLoc(), ConversionType)) {
8102 Candidate.
Viable =
false;
8116 Buffer, &ConversionFn, CallResultType, VK, From->
getBeginLoc());
8134 Candidate.
Viable =
false;
8146 Candidate.
Viable =
false;
8153 Candidate.
Viable =
false;
8159 "Can only end up with a standard conversion sequence or failure");
8162 if (EnableIfAttr *FailedAttr =
8163 CheckEnableIf(Conversion, CandidateSet.
getLocation(), std::nullopt)) {
8164 Candidate.
Viable =
false;
8171 Candidate.
Viable =
false;
8185 bool AllowExplicit,
bool AllowResultConversion) {
8187 "Only conversion function templates permitted here");
8199 Candidate.
Viable =
false;
8210 FunctionTemplate, ObjectType, ObjectClassification, ToType,
8216 Candidate.
Viable =
false;
8228 assert(
Specialization &&
"Missing function template specialization?");
8229 AddConversionCandidate(
Specialization, FoundDecl, ActingDC, From, ToType,
8230 CandidateSet, AllowObjCConversionOnExplicit,
8231 AllowExplicit, AllowResultConversion);
8272 *
this, CandidateSet.
getLocation(), Object->getType(),
8273 Object->Classify(Context), Conversion, ActingContext);
8276 if (ObjectInit.
isBad()) {
8277 Candidate.
Viable =
false;
8288 Candidate.
Conversions[0].UserDefined.EllipsisConversion =
false;
8289 Candidate.
Conversions[0].UserDefined.HadMultipleCandidates =
false;
8290 Candidate.
Conversions[0].UserDefined.ConversionFunction = Conversion;
8291 Candidate.
Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
8294 Candidate.
Conversions[0].UserDefined.After.setAsIdentityConversion();
8302 if (Args.size() > NumParams && !Proto->
isVariadic()) {
8303 Candidate.
Viable =
false;
8310 if (Args.size() < NumParams) {
8312 Candidate.
Viable =
false;
8319 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8320 if (ArgIdx < NumParams) {
8331 getLangOpts().ObjCAutoRefCount);
8333 Candidate.
Viable =
false;
8347 if (CheckFunctionConstraints(Conversion, Satisfaction, {},
8350 Candidate.
Viable =
false;
8356 if (EnableIfAttr *FailedAttr =
8357 CheckEnableIf(Conversion, CandidateSet.
getLocation(), std::nullopt)) {
8358 Candidate.
Viable =
false;
8383 assert(!isa<CXXMethodDecl>(FD) &&
8384 "unqualified operator lookup found a member function");
8387 AddTemplateOverloadCandidate(FunTmpl, F.getPair(), ExplicitTemplateArgs,
8388 FunctionArgs, CandidateSet);
8390 AddTemplateOverloadCandidate(
8391 FunTmpl, F.getPair(), ExplicitTemplateArgs,
8392 {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
false,
false,
8395 if (ExplicitTemplateArgs)
8397 AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet);
8399 AddOverloadCandidate(
8400 FD, F.getPair(), {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
8401 false,
false,
true,
false, ADLCallKind::NotADL, std::nullopt,
8438 if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
8441 if (!T1Rec->getDecl()->getDefinition())
8444 LookupResult Operators(*
this, OpName, OpLoc, LookupOrdinaryName);
8445 LookupQualifiedName(Operators, T1Rec->getDecl());
8449 OperEnd = Operators.
end();
8450 Oper != OperEnd; ++Oper) {
8451 if (Oper->getAsFunction() &&
8454 *
this, {Args[1], Args[0]}, Oper->getAsFunction()))
8456 AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
8457 Args[0]->Classify(Context), Args.slice(1),
8458 CandidateSet,
false, PO);
8473 bool IsAssignmentOperator,
8474 unsigned NumContextualBoolArguments) {
8491 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8504 if (ArgIdx < NumContextualBoolArguments) {
8505 assert(ParamTys[ArgIdx] == Context.
BoolTy &&
8506 "Contextual conversion to bool requires bool type");
8512 ArgIdx == 0 && IsAssignmentOperator,
8515 getLangOpts().ObjCAutoRefCount);
8518 Candidate.
Viable =
false;
8531class BuiltinCandidateTypeSet {
8537 TypeSet PointerTypes;
8541 TypeSet MemberPointerTypes;
8545 TypeSet EnumerationTypes;
8549 TypeSet VectorTypes;
8553 TypeSet MatrixTypes;
8556 TypeSet BitIntTypes;
8559 bool HasNonRecordTypes;
8563 bool HasArithmeticOrEnumeralTypes;
8567 bool HasNullPtrType;
8576 bool AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8578 bool AddMemberPointerWithMoreQualifiedTypeVariants(
QualType Ty);
8582 typedef TypeSet::iterator iterator;
8584 BuiltinCandidateTypeSet(
Sema &SemaRef)
8585 : HasNonRecordTypes(
false),
8586 HasArithmeticOrEnumeralTypes(
false),
8587 HasNullPtrType(
false),
8589 Context(SemaRef.Context) { }
8591 void AddTypesConvertedFrom(
QualType Ty,
8593 bool AllowUserConversions,
8594 bool AllowExplicitConversions,
8595 const Qualifiers &VisibleTypeConversionsQuals);
8597 llvm::iterator_range<iterator> pointer_types() {
return PointerTypes; }
8598 llvm::iterator_range<iterator> member_pointer_types() {
8599 return MemberPointerTypes;
8601 llvm::iterator_range<iterator> enumeration_types() {
8602 return EnumerationTypes;
8604 llvm::iterator_range<iterator> vector_types() {
return VectorTypes; }
8605 llvm::iterator_range<iterator> matrix_types() {
return MatrixTypes; }
8606 llvm::iterator_range<iterator> bitint_types() {
return BitIntTypes; }
8608 bool containsMatrixType(
QualType Ty)
const {
return MatrixTypes.count(Ty); }
8609 bool hasNonRecordTypes() {
return HasNonRecordTypes; }
8610 bool hasArithmeticOrEnumeralTypes() {
return HasArithmeticOrEnumeralTypes; }
8611 bool hasNullPtrType()
const {
return HasNullPtrType; }
8626BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(
QualType Ty,
8630 if (!PointerTypes.insert(Ty))
8635 bool buildObjCPtr =
false;
8639 buildObjCPtr =
true;
8651 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
8657 if ((CVR | BaseCVR) != CVR)
continue;
8679 PointerTypes.insert(QPointerTy);
8695BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
8698 if (!MemberPointerTypes.insert(Ty))
8702 assert(PointerTy &&
"type was not a member pointer type!");
8717 if ((CVR | BaseCVR) != CVR)
continue;
8720 MemberPointerTypes.insert(
8736BuiltinCandidateTypeSet::AddTypesConvertedFrom(
QualType Ty,
8738 bool AllowUserConversions,
8739 bool AllowExplicitConversions,
8751 Ty = SemaRef.Context.getArrayDecayedType(Ty);
8758 HasNonRecordTypes = HasNonRecordTypes || !TyRec;
8761 HasArithmeticOrEnumeralTypes =
8765 PointerTypes.insert(Ty);
8769 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
8773 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
8776 HasArithmeticOrEnumeralTypes =
true;
8777 EnumerationTypes.insert(Ty);
8779 HasArithmeticOrEnumeralTypes =
true;
8780 BitIntTypes.insert(Ty);
8784 HasArithmeticOrEnumeralTypes =
true;
8785 VectorTypes.insert(Ty);
8789 HasArithmeticOrEnumeralTypes =
true;
8790 MatrixTypes.insert(Ty);
8792 HasNullPtrType =
true;
8793 }
else if (AllowUserConversions && TyRec) {
8795 if (!SemaRef.isCompleteType(Loc, Ty))
8800 if (isa<UsingShadowDecl>(D))
8801 D = cast<UsingShadowDecl>(D)->getTargetDecl();
8805 if (isa<FunctionTemplateDecl>(D))
8809 if (AllowExplicitConversions || !Conv->
isExplicit()) {
8872 if (isa<UsingShadowDecl>(D))
8873 D = cast<UsingShadowDecl>(D)->getTargetDecl();
8907 if (Available.hasAtomic()) {
8908 Available.removeAtomic();
8915 if (Available.hasVolatile()) {
8916 Available.removeVolatile();
8950class BuiltinOperatorOverloadBuilder {
8955 bool HasArithmeticOrEnumeralCandidateType;
8959 static constexpr int ArithmeticTypesCap = 26;
8965 unsigned FirstIntegralType,
8967 unsigned FirstPromotedIntegralType,
8968 LastPromotedIntegralType;
8969 unsigned FirstPromotedArithmeticType,
8970 LastPromotedArithmeticType;
8971 unsigned NumArithmeticTypes;
8973 void InitArithmeticTypes() {
8975 FirstPromotedArithmeticType = 0;
8985 FirstIntegralType = ArithmeticTypes.size();
8986 FirstPromotedIntegralType = ArithmeticTypes.size();
9009 llvm::for_each(CandidateTypes, [&BitIntCandidates](
9010 BuiltinCandidateTypeSet &Candidate) {
9011 for (
QualType BitTy : Candidate.bitint_types())
9014 llvm::move(BitIntCandidates, std::back_inserter(ArithmeticTypes));
9015 LastPromotedIntegralType = ArithmeticTypes.size();
9016 LastPromotedArithmeticType = ArithmeticTypes.size();
9030 LastIntegralType = ArithmeticTypes.size();
9031 NumArithmeticTypes = ArithmeticTypes.size();
9038 assert(ArithmeticTypes.size() - BitIntCandidates.size() <=
9039 ArithmeticTypesCap &&
9040 "Enough inline storage for all arithmetic types.");
9045 void addPlusPlusMinusMinusStyleOverloads(
QualType CandidateTy,
9094 BuiltinOperatorOverloadBuilder(
9097 bool HasArithmeticOrEnumeralCandidateType,
9101 VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
9102 HasArithmeticOrEnumeralCandidateType(
9103 HasArithmeticOrEnumeralCandidateType),
9104 CandidateTypes(CandidateTypes),
9105 CandidateSet(CandidateSet) {
9107 InitArithmeticTypes();
9130 if (!HasArithmeticOrEnumeralCandidateType)
9133 for (
unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
9134 const auto TypeOfT = ArithmeticTypes[Arith];
9136 if (Op == OO_MinusMinus)
9138 if (Op == OO_PlusPlus && S.
getLangOpts().CPlusPlus17)
9141 addPlusPlusMinusMinusStyleOverloads(
9158 void addPlusPlusMinusMinusPointerOverloads() {
9159 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9161 if (!PtrTy->getPointeeType()->isObjectType())
9164 addPlusPlusMinusMinusStyleOverloads(
9166 (!PtrTy.isVolatileQualified() &&
9168 (!PtrTy.isRestrictQualified() &&
9183 void addUnaryStarPointerOverloads() {
9184 for (
QualType ParamTy : CandidateTypes[0].pointer_types()) {
9190 if (Proto->getMethodQuals() || Proto->getRefQualifier())
9203 void addUnaryPlusOrMinusArithmeticOverloads() {
9204 if (!HasArithmeticOrEnumeralCandidateType)
9207 for (
unsigned Arith = FirstPromotedArithmeticType;
9208 Arith < LastPromotedArithmeticType; ++Arith) {
9209 QualType ArithTy = ArithmeticTypes[Arith];
9214 for (
QualType VecTy : CandidateTypes[0].vector_types())
9223 void addUnaryPlusPointerOverloads() {
9224 for (
QualType ParamTy : CandidateTypes[0].pointer_types())
9233 void addUnaryTildePromotedIntegralOverloads() {
9234 if (!HasArithmeticOrEnumeralCandidateType)
9237 for (
unsigned Int = FirstPromotedIntegralType;
9238 Int < LastPromotedIntegralType; ++
Int) {
9244 for (
QualType VecTy : CandidateTypes[0].vector_types())
9254 void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
9258 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9259 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9264 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9268 if (CandidateTypes[ArgIdx].hasNullPtrType()) {
9270 if (AddedTypes.insert(NullPtrTy).second) {
9271 QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
9290 void addGenericBinaryPointerOrEnumeralOverloads(
bool IsSpaceship) {
9304 UserDefinedBinaryOperators;
9306 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9307 if (!CandidateTypes[ArgIdx].enumeration_types().empty()) {
9309 CEnd = CandidateSet.
end();
9311 if (!
C->Viable || !
C->Function ||
C->Function->getNumParams() != 2)
9314 if (
C->Function->isFunctionTemplateSpecialization())
9323 .getUnqualifiedType();
9326 .getUnqualifiedType();
9334 UserDefinedBinaryOperators.insert(
9344 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9345 for (
QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9349 if (IsSpaceship && PtrTy->isFunctionPointerType())
9352 QualType ParamTypes[2] = {PtrTy, PtrTy};
9355 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9360 if (!AddedTypes.insert(CanonType).second ||
9361 UserDefinedBinaryOperators.count(std::make_pair(CanonType,
9364 QualType ParamTypes[2] = {EnumTy, EnumTy};
9391 for (
int Arg = 0; Arg < 2; ++Arg) {
9392 QualType AsymmetricParamTypes[2] = {
9396 for (
QualType PtrTy : CandidateTypes[Arg].pointer_types()) {
9401 AsymmetricParamTypes[Arg] = PtrTy;
9402 if (Arg == 0 || Op == OO_Plus) {
9407 if (Op == OO_Minus) {
9412 QualType ParamTypes[2] = {PtrTy, PtrTy};
9448 void addGenericBinaryArithmeticOverloads() {
9449 if (!HasArithmeticOrEnumeralCandidateType)
9452 for (
unsigned Left = FirstPromotedArithmeticType;
9453 Left < LastPromotedArithmeticType; ++Left) {
9454 for (
unsigned Right = FirstPromotedArithmeticType;
9455 Right < LastPromotedArithmeticType; ++Right) {
9456 QualType LandR[2] = { ArithmeticTypes[Left],
9457 ArithmeticTypes[Right] };
9464 for (
QualType Vec1Ty : CandidateTypes[0].vector_types())
9465 for (
QualType Vec2Ty : CandidateTypes[1].vector_types()) {
9466 QualType LandR[2] = {Vec1Ty, Vec2Ty};
9476 void addMatrixBinaryArithmeticOverloads() {
9477 if (!HasArithmeticOrEnumeralCandidateType)
9480 for (
QualType M1 : CandidateTypes[0].matrix_types()) {
9481 AddCandidate(M1, cast<MatrixType>(M1)->getElementType());
9482 AddCandidate(M1, M1);
9485 for (
QualType M2 : CandidateTypes[1].matrix_types()) {
9486 AddCandidate(cast<MatrixType>(M2)->getElementType(), M2);
9487 if (!CandidateTypes[0].containsMatrixType(M2))
9488 AddCandidate(M2, M2);
9523 void addThreeWayArithmeticOverloads() {
9524 addGenericBinaryArithmeticOverloads();
9541 void addBinaryBitwiseArithmeticOverloads() {
9542 if (!HasArithmeticOrEnumeralCandidateType)
9545 for (
unsigned Left = FirstPromotedIntegralType;
9546 Left < LastPromotedIntegralType; ++Left) {
9547 for (
unsigned Right = FirstPromotedIntegralType;
9548 Right < LastPromotedIntegralType; ++Right) {
9549 QualType LandR[2] = { ArithmeticTypes[Left],
9550 ArithmeticTypes[Right] };
9563 void addAssignmentMemberPointerOrEnumeralOverloads() {
9567 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9568 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9575 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9600 void addAssignmentPointerOverloads(
bool isEqualOp) {
9604 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9608 else if (!PtrTy->getPointeeType()->isObjectType())
9619 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9629 if (!PtrTy.isRestrictQualified() &&
9649 for (
QualType PtrTy : CandidateTypes[1].pointer_types()) {
9663 bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9673 if (!PtrTy.isRestrictQualified() &&
9706 void addAssignmentArithmeticOverloads(
bool isEqualOp) {
9707 if (!HasArithmeticOrEnumeralCandidateType)
9710 for (
unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
9711 for (
unsigned Right = FirstPromotedArithmeticType;
9712 Right < LastPromotedArithmeticType; ++Right) {
9714 ParamTypes[1] = ArithmeticTypes[Right];
9716 S, ArithmeticTypes[Left], Args[0]);
9729 for (
QualType Vec1Ty : CandidateTypes[0].vector_types())
9730 for (
QualType Vec2Ty : CandidateTypes[0].vector_types()) {
9732 ParamTypes[1] = Vec2Ty;
9760 void addAssignmentIntegralOverloads() {
9761 if (!HasArithmeticOrEnumeralCandidateType)
9764 for (
unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
9765 for (
unsigned Right = FirstPromotedIntegralType;
9766 Right < LastPromotedIntegralType; ++Right) {
9768 ParamTypes[1] = ArithmeticTypes[Right];
9770 S, ArithmeticTypes[Left], Args[0]);
9789 void addExclaimOverload() {
9795 void addAmpAmpOrPipePipeOverload() {
9812 void addSubscriptOverloads() {
9813 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9823 for (
QualType PtrTy : CandidateTypes[1].pointer_types()) {
9843 void addArrowStarOverloads() {
9844 for (
QualType PtrTy : CandidateTypes[0].pointer_types()) {
9849 if (!isa<RecordType>(C1))
9858 for (
QualType MemPtrTy : CandidateTypes[1].member_pointer_types()) {
9864 QualType ParamTypes[2] = {PtrTy, MemPtrTy};
9868 T.isVolatileQualified())
9871 T.isRestrictQualified())
9889 void addConditionalOperatorOverloads() {
9893 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9894 for (
QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9898 QualType ParamTypes[2] = {PtrTy, PtrTy};
9902 for (
QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9906 QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9911 for (
QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9918 QualType ParamTypes[2] = {EnumTy, EnumTy};
9942 VisibleTypeConversionsQuals.
addConst();
9943 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9945 if (Args[ArgIdx]->getType()->isAtomicType())
9946 VisibleTypeConversionsQuals.
addAtomic();
9949 bool HasNonRecordCandidateType =
false;
9950 bool HasArithmeticOrEnumeralCandidateType =
false;
9952 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9953 CandidateTypes.emplace_back(*
this);
9954 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
9957 (Op == OO_Exclaim ||
9960 VisibleTypeConversionsQuals);
9961 HasNonRecordCandidateType = HasNonRecordCandidateType ||
9962 CandidateTypes[ArgIdx].hasNonRecordTypes();
9963 HasArithmeticOrEnumeralCandidateType =
9964 HasArithmeticOrEnumeralCandidateType ||
9965 CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
9973 if (!HasNonRecordCandidateType &&
9974 !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
9978 BuiltinOperatorOverloadBuilder OpBuilder(*
this, Args,
9979 VisibleTypeConversionsQuals,
9980 HasArithmeticOrEnumeralCandidateType,
9981 CandidateTypes, CandidateSet);
9987 llvm_unreachable(
"Expected an overloaded operator");
9992 case OO_Array_Delete:
9995 "Special operators don't use AddBuiltinOperatorCandidates");
10007 if (Args.size() == 1)
10008 OpBuilder.addUnaryPlusPointerOverloads();
10012 if (Args.size() == 1) {
10013 OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
10015 OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
10016 OpBuilder.addGenericBinaryArithmeticOverloads();
10017 OpBuilder.addMatrixBinaryArithmeticOverloads();
10022 if (Args.size() == 1)
10023 OpBuilder.addUnaryStarPointerOverloads();
10025 OpBuilder.addGenericBinaryArithmeticOverloads();
10026 OpBuilder.addMatrixBinaryArithmeticOverloads();
10031 OpBuilder.addGenericBinaryArithmeticOverloads();
10035 case OO_MinusMinus:
10036 OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
10037 OpBuilder.addPlusPlusMinusMinusPointerOverloads();
10040 case OO_EqualEqual:
10041 case OO_ExclaimEqual:
10042 OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
10043 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10044 OpBuilder.addGenericBinaryArithmeticOverloads();
10050 case OO_GreaterEqual:
10051 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
false);
10052 OpBuilder.addGenericBinaryArithmeticOverloads();
10056 OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(
true);
10057 OpBuilder.addThreeWayArithmeticOverloads();
10064 case OO_GreaterGreater:
10065 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10069 if (Args.size() == 1)
10075 OpBuilder.addBinaryBitwiseArithmeticOverloads();
10079 OpBuilder.addUnaryTildePromotedIntegralOverloads();
10083 OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
10087 case OO_MinusEqual:
10088 OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
10092 case OO_SlashEqual:
10093 OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
10096 case OO_PercentEqual:
10097 case OO_LessLessEqual:
10098 case OO_GreaterGreaterEqual:
10100 case OO_CaretEqual:
10102 OpBuilder.addAssignmentIntegralOverloads();
10106 OpBuilder.addExclaimOverload();
10111 OpBuilder.addAmpAmpOrPipePipeOverload();
10115 if (Args.size() == 2)
10116 OpBuilder.addSubscriptOverloads();
10120 OpBuilder.addArrowStarOverloads();
10123 case OO_Conditional:
10124 OpBuilder.addConditionalOperatorOverloads();
10125 OpBuilder.addGenericBinaryArithmeticOverloads();
10143 bool PartialOverloading) {
10154 ArgumentDependentLookup(Name, Loc, Args, Fns);
10158 CandEnd = CandidateSet.
end();
10159 Cand != CandEnd; ++Cand)
10160 if (Cand->Function) {
10161 Fns.
erase(Cand->Function);
10163 Fns.
erase(FunTmpl);
10172 if (ExplicitTemplateArgs)
10175 AddOverloadCandidate(
10176 FD, FoundDecl, Args, CandidateSet,
false,
10177 PartialOverloading,
true,
10178 false, ADLCallKind::UsesADL);
10180 AddOverloadCandidate(
10181 FD, FoundDecl, {Args[1], Args[0]}, CandidateSet,
10182 false, PartialOverloading,
10184 ADLCallKind::UsesADL, std::nullopt,
10188 auto *FTD = cast<FunctionTemplateDecl>(*I);
10189 AddTemplateOverloadCandidate(
10190 FTD, FoundDecl, ExplicitTemplateArgs, Args, CandidateSet,
10191 false, PartialOverloading,
10192 true, ADLCallKind::UsesADL);
10194 *
this, Args, FTD->getTemplatedDecl())) {
10195 AddTemplateOverloadCandidate(
10196 FTD, FoundDecl, ExplicitTemplateArgs, {Args[1], Args[0]},
10197 CandidateSet,
false, PartialOverloading,
10198 true, ADLCallKind::UsesADL,
10206enum class Comparison {
Equal, Better, Worse };
10223 bool Cand1Attr = Cand1->
hasAttr<EnableIfAttr>();
10224 bool Cand2Attr = Cand2->
hasAttr<EnableIfAttr>();
10225 if (!Cand1Attr || !Cand2Attr) {
10226 if (Cand1Attr == Cand2Attr)
10227 return Comparison::Equal;
10228 return Cand1Attr ? Comparison::Better : Comparison::Worse;
10234 llvm::FoldingSetNodeID Cand1ID, Cand2ID;
10235 for (
auto Pair : zip_longest(Cand1Attrs, Cand2Attrs)) {
10236 std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
10237 std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
10242 return Comparison::Worse;
10244 return Comparison::Better;
10249 (*Cand1A)->getCond()->Profile(Cand1ID, S.
getASTContext(),
true);
10250 (*Cand2A)->getCond()->Profile(Cand2ID, S.
getASTContext(),
true);
10251 if (Cand1ID != Cand2ID)
10252 return Comparison::Worse;
10255 return Comparison::Equal;
10263 return Comparison::Equal;
10269 return Comparison::Equal;
10270 return Comparison::Worse;
10273 return Comparison::Better;
10279 const auto *Cand1CPUSpec = Cand1.
Function->
getAttr<CPUSpecificAttr>();
10280 const auto *Cand2CPUSpec = Cand2.
Function->
getAttr<CPUSpecificAttr>();
10282 if (!Cand1CPUDisp && !Cand2CPUDisp && !Cand1CPUSpec && !Cand2CPUSpec)
10283 return Comparison::Equal;
10285 if (Cand1CPUDisp && !Cand2CPUDisp)
10286 return Comparison::Better;
10287 if (Cand2CPUDisp && !Cand1CPUDisp)
10288 return Comparison::Worse;
10290 if (Cand1CPUSpec && Cand2CPUSpec) {
10291 if (Cand1CPUSpec->cpus_size() != Cand2CPUSpec->cpus_size())
10292 return Cand1CPUSpec->cpus_size() < Cand2CPUSpec->cpus_size()
10293 ? Comparison::Better
10294 : Comparison::Worse;
10296 std::pair<CPUSpecificAttr::cpus_iterator, CPUSpecificAttr::cpus_iterator>
10297 FirstDiff = std::mismatch(
10298 Cand1CPUSpec->cpus_begin(), Cand1CPUSpec->cpus_end(),
10299 Cand2CPUSpec->cpus_begin(),
10301 return LHS->getName() == RHS->getName();
10304 assert(FirstDiff.first != Cand1CPUSpec->cpus_end() &&
10305 "Two different cpu-specific versions should not have the same "
10306 "identifier list, otherwise they'd be the same decl!");
10307 return (*FirstDiff.first)->getName() < (*FirstDiff.second)->
getName()
10308 ? Comparison::Better
10309 : Comparison::Worse;
10311 llvm_unreachable(
"No way to get here unless both had cpu_dispatch");
10317static std::optional<QualType>
10319 if (!isa<CXXMethodDecl>(F) || isa<CXXConstructorDecl>(F))
10320 return std::nullopt;
10322 auto *M = cast<CXXMethodDecl>(F);
10326 return M->getFunctionObjectParameterReferenceType();
10340 PT2->getInstantiatedFromMemberTemplate()))
10351 assert(I < F->getNumParams());
10355 unsigned F1NumParams = F1->
getNumParams() + isa<CXXMethodDecl>(F1);
10356 unsigned F2NumParams = F2->
getNumParams() + isa<CXXMethodDecl>(F2);
10358 if (F1NumParams != F2NumParams)
10361 unsigned I1 = 0, I2 = 0;
10362 for (
unsigned I = 0; I != F1NumParams; ++I) {
10363 QualType T1 = NextParam(F1, I1, I == 0);
10364 QualType T2 = NextParam(F2, I2, I == 0);
10365 assert(!T1.
isNull() && !T2.
isNull() &&
"Unexpected null param types");
10393 auto *Mem1 = dyn_cast<CXXMethodDecl>(Fn1);
10394 auto *Mem2 = dyn_cast<CXXMethodDecl>(Fn2);
10395 if (Mem1 && Mem2) {
10398 if (Mem1->getParent() != Mem2->getParent())
10402 if (Mem1->isInstance() && Mem2->isInstance() &&
10404 Mem1->getFunctionObjectParameterReferenceType(),
10405 Mem1->getFunctionObjectParameterReferenceType()))
10461 bool IsCand1ImplicitHD =
10463 bool IsCand2ImplicitHD =
10478 auto EmitThreshold =
10479 (S.
getLangOpts().CUDAIsDevice && IsCallerImplicitHD &&
10480 (IsCand1ImplicitHD || IsCand2ImplicitHD))
10483 auto Cand1Emittable = P1 > EmitThreshold;
10484 auto Cand2Emittable = P2 > EmitThreshold;
10485 if (Cand1Emittable && !Cand2Emittable)
10487 if (!Cand1Emittable && Cand2Emittable)
10498 unsigned StartArg = 0;
10505 return ICS.isStandard() &&
10517 assert(Cand2.
Conversions.size() == NumArgs &&
"Overload candidate mismatch");
10518 bool HasBetterConversion =
false;
10519 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10520 bool Cand1Bad = IsIllFormedConversion(Cand1.
Conversions[ArgIdx]);
10521 bool Cand2Bad = IsIllFormedConversion(Cand2.
Conversions[ArgIdx]);
10522 if (Cand1Bad != Cand2Bad) {
10525 HasBetterConversion =
true;
10529 if (HasBetterConversion)
10536 bool HasWorseConversion =
false;
10537 for (
unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10543 HasBetterConversion =
true;
10562 HasWorseConversion =
true;
10577 if (HasBetterConversion && !HasWorseConversion)
10588 isa<CXXConversionDecl>(Cand1.
Function) &&
10589 isa<CXXConversionDecl>(Cand2.
Function)) {
10617 isa<CXXConstructorDecl>(Cand1.
Function) !=
10618 isa<CXXConstructorDecl>(Cand2.
Function))
10619 return isa<CXXConstructorDecl>(Cand1.
Function);
10623 bool Cand1IsSpecialization = Cand1.
Function &&
10625 bool Cand2IsSpecialization = Cand2.
Function &&
10627 if (Cand1IsSpecialization != Cand2IsSpecialization)
10628 return Cand2IsSpecialization;
10634 if (Cand1IsSpecialization && Cand2IsSpecialization) {
10635 const auto *Obj1Context =
10637 const auto *Obj2Context =
10645 Obj1Context ?
QualType(Obj1Context->getTypeForDecl(), 0)
10647 Obj2Context ?
QualType(Obj2Context->getTypeForDecl(), 0)
10656 if (!Cand1IsSpecialization && !Cand2IsSpecialization &&
10668 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
10670 AtLeastAsConstrained1) ||
10672 AtLeastAsConstrained2))
10674 if (AtLeastAsConstrained1 != AtLeastAsConstrained2)
10675 return AtLeastAsConstrained1;
10676 }
else if (RC1 || RC2) {
10677 return RC1 !=
nullptr;
10685 bool Cand1IsInherited =
10687 bool Cand2IsInherited =
10689 if (Cand1IsInherited != Cand2IsInherited)
10690 return Cand2IsInherited;
10691 else if (Cand1IsInherited) {
10692 assert(Cand2IsInherited);
10695 if (Cand1Class->isDerivedFrom(Cand2Class))
10697 if (Cand2Class->isDerivedFrom(Cand1Class))
10714 auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.
Function);
10715 auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.
Function);
10716 if (Guide1 && Guide2) {
10718 if (Guide1->isImplicit() != Guide2->isImplicit())
10719 return Guide2->isImplicit();
10729 const auto *Constructor1 = Guide1->getCorrespondingConstructor();
10730 const auto *Constructor2 = Guide2->getCorrespondingConstructor();
10731 if (Constructor1 && Constructor2) {
10732 bool isC1Templated = Constructor1->getTemplatedKind() !=
10734 bool isC2Templated = Constructor2->getTemplatedKind() !=
10736 if (isC1Templated != isC2Templated)
10737 return isC2Templated;
10745 if (Cmp != Comparison::Equal)
10746 return Cmp == Comparison::Better;
10749 bool HasPS1 = Cand1.
Function !=
nullptr &&
10751 bool HasPS2 = Cand2.
Function !=
nullptr &&
10753 if (HasPS1 != HasPS2 && HasPS1)
10757 if (MV == Comparison::Better)
10759 if (MV == Comparison::Worse)
10774 const auto *CD1 = dyn_cast_or_null<CXXConstructorDecl>(Cand1.
Function);
10775 const auto *CD2 = dyn_cast_or_null<CXXConstructorDecl>(Cand2.
Function);
10777 LangAS AS1 = CD1->getMethodQualifiers().getAddressSpace();
10778 LangAS AS2 = CD2->getMethodQualifiers().getAddressSpace();
10799 auto *VA = dyn_cast_or_null<ValueDecl>(A);
10800 auto *VB = dyn_cast_or_null<ValueDecl>(B);
10806 if (!VA->getDeclContext()->getRedeclContext()->Equals(
10807 VB->getDeclContext()->getRedeclContext()) ||
10808 getOwningModule(VA) == getOwningModule(VB) ||
10809 VA->isExternallyVisible() || VB->isExternallyVisible())
10817 if (Context.
hasSameType(VA->getType(), VB->getType()))
10822 if (
auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
10823 if (
auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
10826 auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
10827 auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
10828 if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
10830 EnumB->getIntegerType()))
10833 return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
10843 assert(D &&
"Unknown declaration");
10844 Diag(Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
10846 Module *M = getOwningModule(D);
10850 for (
auto *E : Equiv) {
10851 Module *M = getOwningModule(E);
10852 Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
10861 static_cast<CNSInfo *
>(DeductionFailure.Data)
10862 ->Satisfaction.ContainsErrors;
10879 std::transform(
begin(),
end(), std::back_inserter(Candidates),
10895 bool ContainsSameSideCandidate =
10899 S.
CUDA().IdentifyPreference(Caller, Cand->
Function) ==
10902 if (ContainsSameSideCandidate) {
10909 llvm::erase_if(Candidates, IsWrongSideCandidate);
10915 for (
auto *Cand : Candidates) {
10916 Cand->
Best =
false;
10918 if (Best ==
end() ||
10938 PendingBest.push_back(&*Best);
10943 while (!PendingBest.empty()) {
10944 auto *Curr = PendingBest.pop_back_val();
10945 for (
auto *Cand : Candidates) {
10948 PendingBest.push_back(Cand);
10953 EquivalentCands.push_back(Cand->
Function);
10965 if (Best->Function && Best->Function->isDeleted())
10968 if (!EquivalentCands.empty())
10977enum OverloadCandidateKind {
10980 oc_reversed_binary_operator,
10982 oc_implicit_default_constructor,
10983 oc_implicit_copy_constructor,
10984 oc_implicit_move_constructor,
10985 oc_implicit_copy_assignment,
10986 oc_implicit_move_assignment,
10987 oc_implicit_equality_comparison,
10988 oc_inherited_constructor
10991enum OverloadCandidateSelect {
10994 ocs_described_template,
10997static std::pair<OverloadCandidateKind, OverloadCandidateSelect>
11001 std::string &Description) {
11010 OverloadCandidateSelect Select = [&]() {
11011 if (!Description.empty())
11012 return ocs_described_template;
11013 return isTemplate ? ocs_template : ocs_non_template;
11016 OverloadCandidateKind Kind = [&]() {
11018 return oc_implicit_equality_comparison;
11021 return oc_reversed_binary_operator;
11023 if (
const auto *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
11024 if (!Ctor->isImplicit()) {
11025 if (isa<ConstructorUsingShadowDecl>(Found))
11026 return oc_inherited_constructor;
11028 return oc_constructor;
11031 if (Ctor->isDefaultConstructor())
11032 return oc_implicit_default_constructor;
11034 if (Ctor->isMoveConstructor())
11035 return oc_implicit_move_constructor;
11037 assert(Ctor->isCopyConstructor() &&
11038 "unexpected sort of implicit constructor");
11039 return oc_implicit_copy_constructor;
11042 if (
const auto *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
11045 if (!Meth->isImplicit())
11048 if (Meth->isMoveAssignmentOperator())
11049 return oc_implicit_move_assignment;
11051 if (Meth->isCopyAssignmentOperator())
11052 return oc_implicit_copy_assignment;
11054 assert(isa<CXXConversionDecl>(Meth) &&
"expected conversion");
11058 return oc_function;
11061 return std::make_pair(Kind, Select);
11064void MaybeEmitInheritedConstructorNote(
Sema &S,
const Decl *FoundDecl) {
11067 if (
const auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
11069 diag::note_ovl_candidate_inherited_constructor)
11070 << Shadow->getNominatedBaseClass();
11079 if (EnableIf->getCond()->isValueDependent() ||
11080 !EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
11097 bool InOverloadResolution,
11101 if (InOverloadResolution)
11103 diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
11105 S.
Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
11116 if (InOverloadResolution) {
11119 TemplateArgString +=
" ";
11121 FunTmpl->getTemplateParameters(),
11126 diag::note_ovl_candidate_unsatisfied_constraints)
11127 << TemplateArgString;
11129 S.
Diag(Loc, diag::err_addrof_function_constraints_not_satisfied)
11138 return P->hasAttr<PassObjectSizeAttr>();
11145 unsigned ParamNo = std::distance(FD->
param_begin(), I) + 1;
11146 if (InOverloadResolution)
11148 diag::note_ovl_candidate_has_pass_object_size_params)
11151 S.
Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
11167 return ::checkAddressOfFunctionIsAvailable(*
this,
Function, Complain,
11175 const auto *ConvD = dyn_cast<CXXConversionDecl>(Fn);
11179 const auto *RD = cast<CXXRecordDecl>(Fn->
getParent());
11180 if (!RD->isLambda())
11190 return ConvToCC != CallOpCC;
11196 QualType DestType,
bool TakingAddress) {
11200 !Fn->
getAttr<TargetAttr>()->isDefaultVersion())
11203 !Fn->
getAttr<TargetVersionAttr>()->isDefaultVersion())
11208 std::string FnDesc;
11209 std::pair<OverloadCandidateKind, OverloadCandidateSelect> KSPair =
11210 ClassifyOverloadCandidate(*
this, Found, Fn, RewriteKind, FnDesc);
11212 << (
unsigned)KSPair.first << (
unsigned)KSPair.second
11215 HandleFunctionTypeMismatch(PD, Fn->
getType(), DestType);
11217 MaybeEmitInheritedConstructorNote(*
this, Found);
11235 FunctionDecl *FirstCand =
nullptr, *SecondCand =
nullptr;
11236 for (
auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
11240 if (
auto *Template = I->Function->getPrimaryTemplate())
11241 Template->getAssociatedConstraints(AC);
11243 I->Function->getAssociatedConstraints(AC);
11246 if (FirstCand ==
nullptr) {
11247 FirstCand = I->Function;
11249 }
else if (SecondCand ==
nullptr) {
11250 SecondCand = I->Function;
11263 SecondCand, SecondAC))
11272 bool TakingAddress) {
11282 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
11283 NoteOverloadCandidate(*I, FunTmpl->getTemplatedDecl(),
CRK_None, DestType,
11286 = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
11287 NoteOverloadCandidate(*I, Fun,
CRK_None, DestType, TakingAddress);
11299 S.
Diag(CaretLoc, PDiag)
11300 << Ambiguous.getFromType() << Ambiguous.getToType();
11301 unsigned CandsShown = 0;
11303 for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
11315 unsigned I,
bool TakingCandidateAddress) {
11317 assert(Conv.
isBad());
11318 assert(Cand->
Function &&
"for now, candidate must be a function");
11324 bool isObjectArgument =
false;
11325 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
11327 isObjectArgument =
true;
11332 std::string FnDesc;
11333 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11344 assert(FromExpr &&
"overload set argument came from implicit argument?");
11346 if (isa<UnaryOperator>(E))
11347 E = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
11351 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11352 << ToParamRange << ToTy << Name << I + 1;
11353 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11362 CToTy = RT->getPointeeType();
11367 CFromTy = FromPT->getPointeeType();
11368 CToTy = ToPT->getPointeeType();
11378 if (isObjectArgument)
11379 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_addrspace_this)
11380 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11384 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11387 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11393 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11396 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11402 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11405 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11410 assert(CVR &&
"expected qualifiers mismatch");
11412 if (isObjectArgument) {
11414 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11415 << FromTy << (CVR - 1);
11418 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11419 << ToParamRange << FromTy << (CVR - 1) << I + 1;
11421 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11427 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_value_category)
11428 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11429 << (
unsigned)isObjectArgument << I + 1
11432 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11438 if (FromExpr && isa<InitListExpr>(FromExpr)) {
11439 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_list_argument)
11440 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11441 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11446 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11458 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
11459 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11460 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11461 << (
unsigned)(Cand->
Fix.
Kind);
11463 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11468 unsigned BaseToDerivedConversion = 0;
11471 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11472 FromPtrTy->getPointeeType()) &&
11473 !FromPtrTy->getPointeeType()->isIncompleteType() &&
11474 !ToPtrTy->getPointeeType()->isIncompleteType() &&
11476 FromPtrTy->getPointeeType()))
11477 BaseToDerivedConversion = 1;
11485 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11486 FromPtrTy->getPointeeType()) &&
11487 FromIface->isSuperClassOf(ToIface))
11488 BaseToDerivedConversion = 2;
11490 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
11492 !ToRefTy->getPointeeType()->isIncompleteType() &&
11494 BaseToDerivedConversion = 3;
11498 if (BaseToDerivedConversion) {
11499 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv)
11500 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11501 << ToParamRange << (BaseToDerivedConversion - 1) << FromTy << ToTy
11503 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11507 if (isa<ObjCObjectPointerType>(CFromTy) &&
11508 isa<PointerType>(CToTy)) {
11513 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11514 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument
11516 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11521 if (TakingCandidateAddress &&
11527 FDiag << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
11528 << ToParamRange << FromTy << ToTy << (
unsigned)isObjectArgument << I + 1
11529 << (
unsigned)(Cand->
Fix.
Kind);
11540 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
11547 unsigned NumArgs) {
11560 if (NumArgs < MinParams) {
11577 unsigned NumFormalArgs) {
11578 assert(isa<FunctionDecl>(D) &&
11579 "The templated declaration should at least be a function"
11580 " when diagnosing bad template argument deduction due to too many"
11581 " or too few arguments");
11591 unsigned ParamCount = FnTy->getNumParams() - (HasExplicitObjectParam ? 1 : 0);
11592 unsigned mode, modeCount;
11593 if (NumFormalArgs < MinParams) {
11594 if (MinParams != ParamCount || FnTy->isVariadic() ||
11595 FnTy->isTemplateVariadic())
11599 modeCount = MinParams;
11601 if (MinParams != ParamCount)
11605 modeCount = ParamCount;
11608 std::string Description;
11609 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11610 ClassifyOverloadCandidate(S, Found, Fn,
CRK_None, Description);
11612 if (modeCount == 1 &&
11615 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11616 << Description << mode
11617 << Fn->
getParamDecl(HasExplicitObjectParam ? 1 : 0) << NumFormalArgs
11621 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second
11622 << Description << mode << modeCount << NumFormalArgs
11625 MaybeEmitInheritedConstructorNote(S, Found);
11630 unsigned NumFormalArgs) {
11638 llvm_unreachable(
"Unsupported: Getting the described template declaration"
11639 " for bad deduction diagnosis");
11646 bool TakingCandidateAddress) {
11652 switch (DeductionFailure.
getResult()) {
11655 "TemplateDeductionResult::Success while diagnosing bad deduction");
11657 llvm_unreachable(
"TemplateDeductionResult::NonDependentConversionFailure "
11658 "while diagnosing bad deduction");
11664 assert(ParamD &&
"no parameter found for incomplete deduction result");
11666 diag::note_ovl_candidate_incomplete_deduction)
11668 MaybeEmitInheritedConstructorNote(S, Found);
11673 assert(ParamD &&
"no parameter found for incomplete deduction result");
11675 diag::note_ovl_candidate_incomplete_deduction_pack)
11679 MaybeEmitInheritedConstructorNote(S, Found);
11684 assert(ParamD &&
"no parameter found for bad qualifiers deduction result");
11702 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_underqualified)
11703 << ParamD->
getDeclName() << Arg << NonCanonParam;
11704 MaybeEmitInheritedConstructorNote(S, Found);
11709 assert(ParamD &&
"no parameter found for inconsistent deduction result");
11711 if (isa<TemplateTypeParmDecl>(ParamD))
11713 else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
11723 diag::note_ovl_candidate_inconsistent_deduction_types)
11726 MaybeEmitInheritedConstructorNote(S, Found);
11746 diag::note_ovl_candidate_inconsistent_deduction)
11749 MaybeEmitInheritedConstructorNote(S, Found);
11754 assert(ParamD &&
"no parameter found for invalid explicit arguments");
11757 diag::note_ovl_candidate_explicit_arg_mismatch_named)
11762 index = TTP->getIndex();
11764 = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
11765 index = NTTP->getIndex();
11767 index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
11769 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
11772 MaybeEmitInheritedConstructorNote(S, Found);
11779 TemplateArgString =
" ";
11782 if (TemplateArgString.size() == 1)
11783 TemplateArgString.clear();
11785 diag::note_ovl_candidate_unsatisfied_constraints)
11786 << TemplateArgString;
11789 static_cast<CNSInfo*
>(DeductionFailure.
Data)->Satisfaction);
11799 diag::note_ovl_candidate_instantiation_depth);
11800 MaybeEmitInheritedConstructorNote(S, Found);
11808 TemplateArgString =
" ";
11811 if (TemplateArgString.size() == 1)
11812 TemplateArgString.clear();
11817 if (PDiag && PDiag->second.getDiagID() ==
11818 diag::err_typename_nested_not_found_enable_if) {
11821 S.
Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
11822 <<
"'enable_if'" << TemplateArgString;
11827 if (PDiag && PDiag->second.getDiagID() ==
11828 diag::err_typename_nested_not_found_requirement) {
11830 diag::note_ovl_candidate_disabled_by_requirement)
11831 << PDiag->second.getStringArg(0) << TemplateArgString;
11841 SFINAEArgString =
": ";
11843 PDiag->second.EmitToString(S.
getDiagnostics(), SFINAEArgString);
11847 diag::note_ovl_candidate_substitution_failure)
11848 << TemplateArgString << SFINAEArgString << R;
11849 MaybeEmitInheritedConstructorNote(S, Found);
11859 TemplateArgString =
" ";
11862 if (TemplateArgString.size() == 1)
11863 TemplateArgString.clear();
11866 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_deduced_mismatch)
11869 << TemplateArgString
11894 diag::note_ovl_candidate_non_deduced_mismatch_qualified)
11901 if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
11910 diag::note_ovl_candidate_non_deduced_mismatch)
11911 << FirstTA << SecondTA;
11917 S.
Diag(Templated->
getLocation(), diag::note_ovl_candidate_bad_deduction);
11918 MaybeEmitInheritedConstructorNote(S, Found);
11922 diag::note_cuda_ovl_candidate_target_mismatch);
11930 bool TakingCandidateAddress) {
11949 std::string FnDesc;
11950 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11951 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Callee,
11954 S.
Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
11955 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
11957 << llvm::to_underlying(CalleeTarget) << llvm::to_underlying(CallerTarget);
11962 if (Meth !=
nullptr && Meth->
isImplicit()) {
11966 switch (FnKindPair.first) {
11969 case oc_implicit_default_constructor:
11972 case oc_implicit_copy_constructor:
11975 case oc_implicit_move_constructor:
11978 case oc_implicit_copy_assignment:
11981 case oc_implicit_move_assignment:
11986 bool ConstRHS =
false;
11990 ConstRHS = RT->getPointeeType().isConstQualified();
12004 S.
Diag(Callee->getLocation(),
12005 diag::note_ovl_candidate_disabled_by_function_cond_attr)
12006 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
12011 assert(ES.
isExplicit() &&
"not an explicit candidate");
12015 case Decl::Kind::CXXConstructor:
12018 case Decl::Kind::CXXConversion:
12021 case Decl::Kind::CXXDeductionGuide:
12025 llvm_unreachable(
"invalid Decl");
12034 First = Pattern->getFirstDecl();
12037 diag::note_ovl_candidate_explicit)
12038 << Kind << (ES.
getExpr() ? 1 : 0)
12059 bool TakingCandidateAddress,
12075 std::string FnDesc;
12076 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12077 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12081 << (
unsigned)FnKindPair.first << (
unsigned)FnKindPair.second << FnDesc
12083 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12099 TakingCandidateAddress);
12102 S.
Diag(Fn->
getLocation(), diag::note_ovl_candidate_illegal_constructor)
12104 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12112 diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch)
12113 << QualsForPrinting;
12114 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12125 for (
unsigned N = Cand->
Conversions.size(); I != N; ++I)
12146 if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
12149 diag::note_ovl_candidate_inherited_constructor_slice)
12152 MaybeEmitInheritedConstructorNote(S, Cand->
FoundDecl);
12158 assert(!Available);
12166 std::string FnDesc;
12167 std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
12168 ClassifyOverloadCandidate(S, Cand->
FoundDecl, Fn,
12172 diag::note_ovl_candidate_constraints_not_satisfied)
12173 << (
unsigned)FnKindPair.first << (
unsigned)ocs_non_template
12191 bool isLValueReference =
false;
12192 bool isRValueReference =
false;
12193 bool isPointer =
false;
12197 isLValueReference =
true;
12201 isRValueReference =
true;
12217 diag::note_ovl_surrogate_constraints_not_satisfied)
12231 assert(Cand->
Conversions.size() <= 2 &&
"builtin operator is not binary");
12232 std::string TypeStr(
"operator");
12238 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12243 S.
Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12250 if (ICS.
isBad())
break;
12254 S, OpLoc, S.
PDiag(diag::note_ambiguous_type_conversion));
12271 llvm_unreachable(
"non-deduction failure while diagnosing bad deduction");
12301 llvm_unreachable(
"Unhandled deduction result");
12306struct CompareOverloadCandidatesForDisplay {
12312 CompareOverloadCandidatesForDisplay(
12315 : S(S), NumArgs(NArgs), CSK(CSK) {}
12325 if (NumArgs >
C->Function->getNumParams() && !
C->Function->isVariadic())
12327 if (NumArgs < C->
Function->getMinRequiredArguments())
12337 if (L == R)
return false;
12341 if (!R->
Viable)
return true;
12343 if (
int Ord = CompareConversions(*L, *R))
12363 if (LDist == RDist) {
12364 if (LFailureKind == RFailureKind)
12372 return LDist < RDist;
12390 numLFixes = (numLFixes == 0) ?
UINT_MAX : numLFixes;
12391 numRFixes = (numRFixes == 0) ?
UINT_MAX : numRFixes;
12392 if (numLFixes != numRFixes) {
12393 return numLFixes < numRFixes;
12397 if (
int Ord = CompareConversions(*L, *R))
12409 if (LRank != RRank)
12410 return LRank < RRank;
12436 struct ConversionSignals {
12437 unsigned KindRank = 0;
12441 ConversionSignals Sig;
12442 Sig.KindRank =
Seq.getKindRank();
12443 if (
Seq.isStandard())
12444 Sig.Rank =
Seq.Standard.getRank();
12445 else if (
Seq.isUserDefined())
12446 Sig.Rank =
Seq.UserDefined.After.getRank();
12452 static ConversionSignals ForObjectArgument() {
12468 for (
unsigned I = 0, N = L.
Conversions.size(); I != N; ++I) {
12470 ? ConversionSignals::ForObjectArgument()
12471 : ConversionSignals::ForSequence(L.Conversions[I]);
12473 ? ConversionSignals::ForObjectArgument()
12474 : ConversionSignals::ForSequence(R.Conversions[I]);
12475 if (std::tie(LS.KindRank, LS.Rank) != std::tie(RS.KindRank, RS.Rank))
12476 return std::tie(LS.KindRank, LS.Rank) < std::tie(RS.KindRank, RS.Rank)
12501 bool Unfixable =
false;
12509 assert(ConvIdx != ConvCount &&
"no bad conversion in candidate");
12510 if (Cand->
Conversions[ConvIdx].isInitialized() &&
12519 bool SuppressUserConversions =
false;
12521 unsigned ConvIdx = 0;
12522 unsigned ArgIdx = 0;
12537 if (isa<CXXMethodDecl>(Cand->
Function) &&
12550 assert(ConvCount <= 3);
12556 ConvIdx != ConvCount;
12558 assert(ArgIdx < Args.size() &&
"no argument for this arg conversion");
12559 if (Cand->
Conversions[ConvIdx].isInitialized()) {
12561 }
else if (
ParamIdx < ParamTypes.size()) {
12562 if (ParamTypes[
ParamIdx]->isDependentType())
12563 Cand->
Conversions[ConvIdx].setAsIdentityConversion(
12564 Args[ArgIdx]->getType());
12568 SuppressUserConversions,
12573 if (!Unfixable && Cand->
Conversions[ConvIdx].isBad())
12589 for (
iterator Cand =
begin(), LastCand =
end(); Cand != LastCand; ++Cand) {
12590 if (!Filter(*Cand))
12594 if (!Cand->Viable) {
12595 if (!Cand->Function && !Cand->IsSurrogate) {
12615 Cands.push_back(Cand);
12619 Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
12626 bool DeferHint =
false;
12630 auto WrongSidedCands =
12632 return (Cand.Viable ==
false &&
12635 Cand.Function->template hasAttr<CUDAHostAttr>() &&
12636 Cand.Function->template hasAttr<CUDADeviceAttr>());
12638 DeferHint = !WrongSidedCands.empty();
12656 bool NoteCands =
true;
12657 for (
const Expr *Arg : Args) {
12658 if (Arg->getType()->isWebAssemblyTableType())
12672 bool ReportedAmbiguousConversions =
false;
12675 unsigned CandsShown = 0;
12676 auto I = Cands.begin(), E = Cands.end();
12677 for (; I != E; ++I) {
12693 "Non-viable built-in candidates are not added to Cands.");
12700 if (!ReportedAmbiguousConversions) {
12702 ReportedAmbiguousConversions =
true;
12715 S.
Diag(OpLoc, diag::note_ovl_too_many_candidates,
12727struct CompareTemplateSpecCandidatesForDisplay {
12729 CompareTemplateSpecCandidatesForDisplay(
Sema &S) : S(S) {}
12763 bool ForTakingAddress) {
12765 DeductionFailure, 0, ForTakingAddress);
12768void TemplateSpecCandidateSet::destroyCandidates() {
12770 i->DeductionFailure.Destroy();
12775 destroyCandidates();
12776 Candidates.clear();
12789 Cands.reserve(
size());
12790 for (
iterator Cand =
begin(), LastCand =
end(); Cand != LastCand; ++Cand) {
12791 if (Cand->Specialization)
12792 Cands.push_back(Cand);
12797 llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S));
12804 unsigned CandsShown = 0;
12805 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
12811 if (CandsShown >= 4 && ShowOverloads ==
Ovl_Best)
12816 "Non-matching built-in candidates are not added to Cands.");
12821 S.
Diag(Loc, diag::note_ovl_too_many_candidates) <<
int(E - I);
12831 QualType Ret = PossiblyAFunctionType;
12834 Ret = ToTypePtr->getPointeeType();
12837 Ret = ToTypeRef->getPointeeType();
12840 Ret = MemTypePtr->getPointeeType();
12847 bool Complain =
true) {
12864class AddressOfFunctionResolver {
12874 bool TargetTypeIsNonStaticMemberFunction;
12875 bool FoundNonTemplateFunction;
12876 bool StaticMemberFunctionFromBoundPointer;
12877 bool HasComplained;
12886 AddressOfFunctionResolver(
Sema &S,
Expr *SourceExpr,
12887 const QualType &TargetType,
bool Complain)
12888 : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
12889 Complain(Complain), Context(S.getASTContext()),
12890 TargetTypeIsNonStaticMemberFunction(
12892 FoundNonTemplateFunction(
false),
12893 StaticMemberFunctionFromBoundPointer(
false),
12894 HasComplained(
false),
12897 FailedCandidates(OvlExpr->getNameLoc(),
true) {
12898 ExtractUnqualifiedFunctionTypeFromTargetType();
12902 if (!UME->isImplicitAccess() &&
12904 StaticMemberFunctionFromBoundPointer =
true;
12908 OvlExpr,
false, &dap)) {
12910 if (!Method->isStatic()) {
12914 TargetTypeIsNonStaticMemberFunction =
true;
12922 Matches.push_back(std::make_pair(dap, Fn));
12930 if (FindAllFunctionsThatMatchTargetTypeExactly()) {
12933 if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
12934 if (FoundNonTemplateFunction)
12935 EliminateAllTemplateMatches();
12937 EliminateAllExceptMostSpecializedTemplate();
12942 EliminateSuboptimalCudaMatches();
12945 bool hasComplained()
const {
return HasComplained; }
12948 bool candidateHasExactlyCorrectType(
const FunctionDecl *FD) {
12960 return candidateHasExactlyCorrectType(A) &&
12961 (!candidateHasExactlyCorrectType(B) ||
12967 bool eliminiateSuboptimalOverloadCandidates() {
12970 auto Best = Matches.begin();
12971 for (
auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
12972 if (isBetterCandidate(I->second, Best->second))
12976 auto IsBestOrInferiorToBest = [
this, BestFn](
12977 const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
12978 return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
12983 if (!llvm::all_of(Matches, IsBestOrInferiorToBest))
12985 Matches[0] = *Best;
12990 bool isTargetTypeAFunction()
const {
12999 void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
13010 bool CanConvertToFunctionPointer =
13011 Method->isStatic() || Method->isExplicitObjectMemberFunction();
13012 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13015 else if (TargetTypeIsNonStaticMemberFunction)
13027 FunctionTemplate, &OvlExplicitTemplateArgs, TargetFunctionType,
13029 Result != TemplateDeductionResult::Success) {
13047 Matches.push_back(std::make_pair(CurAccessFunPair,
Specialization));
13051 bool AddMatchingNonTemplateFunction(
NamedDecl* Fn,
13056 bool CanConvertToFunctionPointer =
13057 Method->isStatic() || Method->isExplicitObjectMemberFunction();
13058 if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
13061 else if (TargetTypeIsNonStaticMemberFunction)
13064 if (
FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
13071 if (FunDecl->isMultiVersion()) {
13072 const auto *TA = FunDecl->
getAttr<TargetAttr>();
13073 if (TA && !TA->isDefaultVersion())
13075 const auto *TVA = FunDecl->getAttr<TargetVersionAttr>();
13076 if (TVA && !TVA->isDefaultVersion())
13084 HasComplained |= Complain;
13093 candidateHasExactlyCorrectType(FunDecl)) {
13094 Matches.push_back(std::make_pair(
13095 CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
13096 FoundNonTemplateFunction =
true;
13104 bool FindAllFunctionsThatMatchTargetTypeExactly() {
13109 if (IsInvalidFormOfPointerToMemberFunction())
13125 = dyn_cast<FunctionTemplateDecl>(Fn)) {
13126 if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
13131 AddMatchingNonTemplateFunction(Fn, I.getPair()))
13134 assert(Ret || Matches.empty());
13138 void EliminateAllExceptMostSpecializedTemplate() {
13151 for (
unsigned I = 0, E = Matches.size(); I != E; ++I)
13152 MatchesCopy.
addDecl(Matches[I].second, Matches[I].first.getAccess());
13157 MatchesCopy.
begin(), MatchesCopy.
end(), FailedCandidates,
13159 S.
PDiag(diag::err_addr_ovl_ambiguous)
13160 << Matches[0].second->getDeclName(),
13161 S.
PDiag(diag::note_ovl_candidate)
13162 << (
unsigned)oc_function << (
unsigned)ocs_described_template,
13163 Complain, TargetFunctionType);
13165 if (Result != MatchesCopy.
end()) {
13167 Matches[0].first = Matches[Result - MatchesCopy.
begin()].first;
13168 Matches[0].second = cast<FunctionDecl>(*Result);
13171 HasComplained |= Complain;
13174 void EliminateAllTemplateMatches() {
13177 for (
unsigned I = 0, N = Matches.size(); I != N; ) {
13178 if (Matches[I].second->getPrimaryTemplate() ==
nullptr)
13181 Matches[I] = Matches[--N];
13187 void EliminateSuboptimalCudaMatches() {
13193 void ComplainNoMatchesFound()
const {
13194 assert(Matches.empty());
13196 << OvlExpr->
getName() << TargetFunctionType
13198 if (FailedCandidates.
empty())
13209 dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
13217 bool IsInvalidFormOfPointerToMemberFunction()
const {
13218 return TargetTypeIsNonStaticMemberFunction &&
13222 void ComplainIsInvalidFormOfPointerToMemberFunction()
const {
13230 bool IsStaticMemberFunctionFromBoundPointer()
const {
13231 return StaticMemberFunctionFromBoundPointer;
13234 void ComplainIsStaticMemberFunctionFromBoundPointer()
const {
13236 diag::err_invalid_form_pointer_member_function)
13240 void ComplainOfInvalidConversion()
const {
13242 << OvlExpr->
getName() << TargetType;
13245 void ComplainMultipleMatchesFound()
const {
13246 assert(Matches.size() > 1);
13253 bool hadMultipleCandidates()
const {
return (OvlExpr->
getNumDecls() > 1); }
13255 int getNumMatches()
const {
return Matches.size(); }
13258 if (Matches.size() != 1)
return nullptr;
13259 return Matches[0].second;
13263 if (Matches.size() != 1)
return nullptr;
13264 return &Matches[0].first;
13289 bool *pHadMultipleCandidates) {
13292 AddressOfFunctionResolver Resolver(*
this, AddressOfExpr, TargetType,
13294 int NumMatches = Resolver.getNumMatches();
13296 bool ShouldComplain = Complain && !Resolver.hasComplained();
13297 if (NumMatches == 0 && ShouldComplain) {
13298 if (Resolver.IsInvalidFormOfPointerToMemberFunction())
13299 Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
13301 Resolver.ComplainNoMatchesFound();
13303 else if (NumMatches > 1 && ShouldComplain)
13304 Resolver.ComplainMultipleMatchesFound();
13305 else if (NumMatches == 1) {
13306 Fn = Resolver.getMatchingFunctionDecl();
13309 ResolveExceptionSpec(AddressOfExpr->
getExprLoc(), FPT);
13310 FoundResult = *Resolver.getMatchingFunctionAccessPair();
13312 if (Resolver.IsStaticMemberFunctionFromBoundPointer())
13313 Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
13315 CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
13319 if (pHadMultipleCandidates)
13320 *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
13335 bool IsResultAmbiguous =
false;
13343 return static_cast<int>(
CUDA().IdentifyPreference(Caller, FD1)) -
13344 static_cast<int>(
CUDA().IdentifyPreference(Caller, FD2));
13355 FD2->getAssociatedConstraints(AC2);
13356 bool AtLeastAsConstrained1, AtLeastAsConstrained2;
13357 if (IsAtLeastAsConstrained(FD1, AC1, FD2, AC2, AtLeastAsConstrained1))
13358 return std::nullopt;
13359 if (IsAtLeastAsConstrained(FD2, AC2, FD1, AC1, AtLeastAsConstrained2))
13360 return std::nullopt;
13361 if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
13362 return std::nullopt;
13363 return AtLeastAsConstrained1;
13370 auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
13378 auto FoundBetter = [&]() {
13379 IsResultAmbiguous =
false;
13390 if (getLangOpts().CUDA) {
13391 int PreferenceByCUDA = CheckCUDAPreference(FD,
Result);
13393 if (PreferenceByCUDA != 0) {
13395 if (PreferenceByCUDA > 0)
13402 std::optional<bool> MoreConstrainedThanPrevious =
13403 CheckMoreConstrained(FD,
Result);
13404 if (!MoreConstrainedThanPrevious) {
13405 IsResultAmbiguous =
true;
13406 AmbiguousDecls.push_back(FD);
13409 if (!*MoreConstrainedThanPrevious)
13416 if (IsResultAmbiguous)
13427 if (getLangOpts().
CUDA && CheckCUDAPreference(Skipped,
Result) != 0)
13429 if (!CheckMoreConstrained(Skipped,
Result))
13445 ExprResult &SrcExpr,
bool DoFunctionPointerConversion) {
13450 FunctionDecl *Found = resolveAddressOfSingleOverloadCandidate(E, DAP);
13459 CheckAddressOfMemberAccess(E, DAP);
13460 ExprResult Res = FixOverloadedFunctionReference(E, DAP, Found);
13465 SrcExpr = DefaultFunctionArrayConversion(Fixed,
false);
13510 = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
13539 NoteAllOverloadCandidates(ovl);
13545 if (FoundResult) *FoundResult = I.getPair();
13564 ExprResult &SrcExpr,
bool doFunctionPointerConversion,
bool complain,
13566 unsigned DiagIDForComplaining) {
13573 if (
FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
13585 isa<CXXMethodDecl>(fn) &&
13586 cast<CXXMethodDecl>(fn)->isInstance()) {
13587 if (!complain)
return false;
13590 diag::err_bound_member_function)
13603 SingleFunctionExpression =
13604 FixOverloadedFunctionReference(SrcExpr.
get(), found, fn);
13607 if (doFunctionPointerConversion) {
13608 SingleFunctionExpression =
13609 DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.
get());
13610 if (SingleFunctionExpression.
isInvalid()) {
13617 if (!SingleFunctionExpression.
isUsable()) {
13619 Diag(OpRangeForComplaining.
getBegin(), DiagIDForComplaining)
13621 << DestTypeForComplaining
13622 << OpRangeForComplaining
13624 NoteAllOverloadCandidates(SrcExpr.
get());
13633 SrcExpr = SingleFunctionExpression;
13643 bool PartialOverloading,
13645 NamedDecl *Callee = FoundDecl.getDecl();
13646 if (isa<UsingShadowDecl>(Callee))
13647 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
13650 if (ExplicitTemplateArgs) {
13651 assert(!KnownValid &&
"Explicit template arguments?");
13660 PartialOverloading);
13665 = dyn_cast<FunctionTemplateDecl>(Callee)) {
13667 ExplicitTemplateArgs, Args, CandidateSet,
13669 PartialOverloading);
13673 assert(!KnownValid &&
"unhandled case in overloaded call candidate");
13681 bool PartialOverloading) {
13704 assert(!(*I)->getDeclContext()->isRecord());
13705 assert(isa<UsingShadowDecl>(*I) ||
13706 !(*I)->getDeclContext()->isFunctionOrMethod());
13707 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
13717 ExplicitTemplateArgs = &TABuffer;
13723 CandidateSet, PartialOverloading,
13728 Args, ExplicitTemplateArgs,
13729 CandidateSet, PartialOverloading);
13739 CandidateSet,
false,
false);
13745 switch (Name.getCXXOverloadedOperator()) {
13746 case OO_New:
case OO_Array_New:
13747 case OO_Delete:
case OO_Array_Delete:
13770 if (DC->isTransparentContext())
13786 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC)) {
13791 if (FoundInClass) {
13792 *FoundInClass = RD;
13795 R.
addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
13812 AssociatedNamespaces,
13813 AssociatedClasses);
13817 for (Sema::AssociatedNamespaceSet::iterator
13818 it = AssociatedNamespaces.begin(),
13819 end = AssociatedNamespaces.end(); it !=
end; ++it) {
13821 if (
Std &&
Std->Encloses(*it))
13831 SuggestedNamespaces.insert(*it);
13835 SemaRef.
Diag(R.
getNameLoc(), diag::err_not_found_by_two_phase_lookup)
13837 if (SuggestedNamespaces.empty()) {
13838 SemaRef.
Diag(Best->Function->getLocation(),
13839 diag::note_not_found_by_two_phase_lookup)
13841 }
else if (SuggestedNamespaces.size() == 1) {
13842 SemaRef.
Diag(Best->Function->getLocation(),
13843 diag::note_not_found_by_two_phase_lookup)
13849 SemaRef.
Diag(Best->Function->getLocation(),
13850 diag::note_not_found_by_two_phase_lookup)
13882class BuildRecoveryCallExprRAII {
13887 BuildRecoveryCallExprRAII(
Sema &S) : SemaRef(S), SatStack(S) {
13909 bool EmptyLookup,
bool AllowTypoCorrection) {
13917 BuildRecoveryCallExprRAII RCE(SemaRef);
13927 ExplicitTemplateArgs = &TABuffer;
13935 ExplicitTemplateArgs, Args, &FoundInClass)) {
13937 }
else if (EmptyLookup) {
13942 ExplicitTemplateArgs !=
nullptr,
13943 dyn_cast<MemberExpr>(Fn));
13945 AllowTypoCorrection
13951 }
else if (FoundInClass && SemaRef.
getLangOpts().MSVCCompat) {
13966 assert(!R.
empty() &&
"lookup results empty despite recovery");
13977 if ((*R.
begin())->isCXXClassMember())
13979 ExplicitTemplateArgs, S);
13980 else if (ExplicitTemplateArgs || TemplateKWLoc.
isValid())
13982 ExplicitTemplateArgs);
14009 assert(!ULE->
getQualifier() &&
"qualified name with ADL");
14016 (F = dyn_cast<FunctionDecl>(*ULE->
decls_begin())) &&
14018 llvm_unreachable(
"performing ADL for builtin");
14021 assert(getLangOpts().
CPlusPlus &&
"ADL enabled in C");
14025 UnbridgedCastsSet UnbridgedCasts;
14033 AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
14035 if (getLangOpts().MSVCCompat &&
14036 CurContext->isDependentContext() && !isSFINAEContext() &&
14037 (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
14040 if (CandidateSet->
empty() ||
14049 RParenLoc, CurFPFeatureOverrides());
14056 if (CandidateSet->
empty())
14059 UnbridgedCasts.restore();
14066 std::optional<QualType>
Result;
14069 if (!Candidate.Function)
14071 if (Candidate.Function->isInvalidDecl())
14073 QualType T = Candidate.Function->getReturnType();
14086 if (Best && *Best != CS.
end())
14087 ConsiderCandidate(**Best);
14090 for (
const auto &
C : CS)
14092 ConsiderCandidate(
C);
14095 for (
const auto &
C : CS)
14096 ConsiderCandidate(
C);
14101 if (
Value.isNull() ||
Value->isUndeducedType())
14118 bool AllowTypoCorrection) {
14119 switch (OverloadResult) {
14130 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14131 false, (*Best)->IsADLCandidate);
14139 CandidateSet->
empty(),
14140 AllowTypoCorrection);
14147 for (
const Expr *Arg : Args) {
14148 if (!Arg->getType()->isFunctionType())
14150 if (
auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
14151 auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
14154 Arg->getExprLoc()))
14162 SemaRef.
PDiag(diag::err_ovl_no_viable_function_in_call)
14171 SemaRef.
PDiag(diag::err_ovl_ambiguous_call)
14180 *CandidateSet, FDecl, Args);
14189 Res.
get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
14190 false, (*Best)->IsADLCandidate);
14196 SubExprs.append(Args.begin(), Args.end());
14203 for (
auto I = CS.
begin(), E = CS.
end(); I != E; ++I) {
14224 bool AllowTypoCorrection,
14225 bool CalleesAddressIsTaken) {
14230 if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
14236 if (CalleesAddressIsTaken)
14250 if (
const auto *TP =
14254 VK_PRValue, RParenLoc, CurFPFeatureOverrides());
14260 ExecConfig, &CandidateSet, &Best,
14261 OverloadResult, AllowTypoCorrection);
14270 PerformADL, Fns.
begin(), Fns.
end(),
14276 bool HadMultipleCandidates) {
14281 Exp = InitializeExplicitObjectArgument(*
this, E, Method);
14283 Exp = PerformImplicitObjectArgumentInitialization(E,
nullptr,
14284 FoundDecl, Method);
14293 auto *CE = dyn_cast<CastExpr>(SubE);
14294 if (CE && CE->getCastKind() == CK_NoOp)
14295 SubE = CE->getSubExpr();
14297 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
14298 SubE = BE->getSubExpr();
14299 if (isa<LambdaExpr>(SubE)) {
14305 PushExpressionEvaluationContext(
14306 ExpressionEvaluationContext::PotentiallyEvaluated);
14307 ExprResult BlockExp = BuildBlockForLambdaConversion(
14309 PopExpressionEvaluationContext();
14327 Expr *ObjectParam = Exp.
get();
14330 CurFPFeatureOverrides());
14340 Exp.
get()->getEndLoc(),
14341 CurFPFeatureOverrides());
14344 if (CheckFunctionCall(Method, CE,
14369 Expr *Input,
bool PerformADL) {
14371 assert(Op !=
OO_None &&
"Invalid opcode for overloaded unary operator");
14379 Expr *Args[2] = { Input,
nullptr };
14380 unsigned NumArgs = 1;
14385 if (Opc == UO_PostInc || Opc == UO_PostDec) {
14399 if (Opc == UO_PreDec || Opc == UO_PreInc || Opc == UO_Deref)
14405 CurFPFeatureOverrides());
14414 CurFPFeatureOverrides());
14421 AddNonMemberOperatorCandidates(Fns, ArgsArray, CandidateSet);
14424 AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
14428 AddArgumentDependentLookupCandidates(OpName, OpLoc, ArgsArray,
14434 AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
14436 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
14451 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14452 CheckMemberOperatorAccess(OpLoc, Input,
nullptr, Best->FoundDecl);
14455 if (Method->isExplicitObjectMemberFunction())
14456 InputInit = InitializeExplicitObjectArgument(*
this, Input, Method);
14458 InputInit = PerformImplicitObjectArgumentInitialization(
14459 Input,
nullptr, Best->FoundDecl, Method);
14462 Base = Input = InputInit.
get();
14473 Input = InputInit.
get();
14478 Base, HadMultipleCandidates,
14490 Context, Op, FnExpr.
get(), ArgsArray, ResultTy, VK, OpLoc,
14491 CurFPFeatureOverrides(), Best->IsADLCandidate);
14493 if (CheckCallReturnType(FnDecl->
getReturnType(), OpLoc, TheCall, FnDecl))
14496 if (CheckFunctionCall(FnDecl, TheCall,
14499 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FnDecl);
14504 ExprResult InputRes = PerformImplicitConversion(
14505 Input, Best->BuiltinParamTypes[0], Best->Conversions[0], AA_Passing,
14509 Input = InputRes.
get();
14529 PDiag(diag::err_ovl_ambiguous_oper_unary)
14546 << (Msg !=
nullptr)
14547 << (Msg ? Msg->
getString() : StringRef())
14558 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
14575 AddNonMemberOperatorCandidates(Fns, Args, CandidateSet);
14578 AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
14580 AddMemberOperatorCandidates(Op, OpLoc, {Args[1], Args[0]}, CandidateSet,
14585 AddMemberOperatorCandidates(ExtraOp, OpLoc, Args, CandidateSet);
14587 AddMemberOperatorCandidates(ExtraOp, OpLoc, {Args[1], Args[0]},
14595 if (Op != OO_Equal && PerformADL) {
14597 AddArgumentDependentLookupCandidates(OpName, OpLoc, Args,
14603 AddArgumentDependentLookupCandidates(ExtraOpName, OpLoc, Args,
14622 AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
14651 Expr *RHS,
bool PerformADL,
14652 bool AllowRewrittenCandidates,
14654 Expr *Args[2] = { LHS, RHS };
14658 AllowRewrittenCandidates =
false;
14664 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
14689 CurFPFeatureOverrides());
14694 if (Opc == BO_PtrMemD) {
14695 auto CheckPlaceholder = [&](
Expr *&Arg) {
14704 if (CheckPlaceholder(Args[0]) || CheckPlaceholder(Args[1]))
14706 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14725 if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
14726 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14731 Op, OpLoc, AllowRewrittenCandidates));
14733 CandidateSet.
exclude(DefaultedFn);
14734 LookupOverloadedBinOp(CandidateSet, Op, Fns, Args, PerformADL);
14736 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
14745 bool IsReversed = Best->isReversed();
14747 std::swap(Args[0], Args[1]);
14764 if (Best->RewriteKind && ChosenOp == OO_EqualEqual &&
14768 Diag(OpLoc, IsExtension ? diag::ext_ovl_rewrite_equalequal_not_bool
14769 : diag::err_ovl_rewrite_equalequal_not_bool)
14777 if (AllowRewrittenCandidates && !IsReversed &&
14785 if (Cand.Viable && Cand.Function && Cand.isReversed() &&
14787 for (
unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
14789 *
this, OpLoc, Cand.Conversions[ArgIdx],
14790 Best->Conversions[ArgIdx]) ==
14792 AmbiguousWith.push_back(Cand.Function);
14799 if (!AmbiguousWith.empty()) {
14800 bool AmbiguousWithSelf =
14801 AmbiguousWith.size() == 1 &&
14803 Diag(OpLoc, diag::ext_ovl_ambiguous_oper_binary_reversed)
14805 << Args[0]->
getType() << Args[1]->
getType() << AmbiguousWithSelf
14807 if (AmbiguousWithSelf) {
14809 diag::note_ovl_ambiguous_oper_binary_reversed_self);
14814 if (
auto *MD = dyn_cast<CXXMethodDecl>(FnDecl))
14815 if (Op == OverloadedOperatorKind::OO_EqualEqual &&
14817 !MD->hasCXXExplicitFunctionObjectParameter() &&
14819 MD->getFunctionObjectParameterType(),
14820 MD->getParamDecl(0)->getType().getNonReferenceType()) &&
14822 MD->getFunctionObjectParameterType(),
14825 MD->getFunctionObjectParameterType(),
14828 diag::note_ovl_ambiguous_eqeq_reversed_self_non_const);
14831 diag::note_ovl_ambiguous_oper_binary_selected_candidate);
14832 for (
auto *F : AmbiguousWith)
14833 Diag(F->getLocation(),
14834 diag::note_ovl_ambiguous_oper_binary_reversed_candidate);
14842 if (Op == OO_Equal)
14843 diagnoseNullableToNonnullConversion(Args[0]->getType(),
14844 Args[1]->getType(), OpLoc);
14847 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14849 CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
14853 if (Method->isExplicitObjectMemberFunction()) {
14854 Arg0 = InitializeExplicitObjectArgument(*
this, Args[0], FnDecl);
14857 Arg0 = PerformImplicitObjectArgumentInitialization(
14858 Args[0],
nullptr, Best->FoundDecl, Method);
14860 Arg1 = PerformCopyInitialization(
14871 ExprResult Arg0 = PerformCopyInitialization(
14879 PerformCopyInitialization(
14891 Best->FoundDecl,
Base,
14892 HadMultipleCandidates, OpLoc);
14903 const Expr *ImplicitThis =
nullptr;
14908 Context, ChosenOp, FnExpr.
get(), Args, ResultTy, VK, OpLoc,
14909 CurFPFeatureOverrides(), Best->IsADLCandidate);
14911 if (
const auto *Method = dyn_cast<CXXMethodDecl>(FnDecl);
14912 Method && Method->isImplicitObjectMemberFunction()) {
14914 ImplicitThis = ArgsArray[0];
14915 ArgsArray = ArgsArray.slice(1);
14918 if (CheckCallReturnType(FnDecl->
getReturnType(), OpLoc, TheCall,
14923 if (Op == OO_Equal)
14924 DiagnoseSelfMove(Args[0], Args[1], OpLoc);
14926 if (ImplicitThis) {
14929 cast<CXXMethodDecl>(FnDecl)->getFunctionObjectParameterType());
14931 CheckArgAlignment(OpLoc, FnDecl,
"'this'", ThisType,
14935 checkCall(FnDecl,
nullptr, ImplicitThis, ArgsArray,
14937 VariadicDoesNotApply);
14939 ExprResult R = MaybeBindToTemporary(TheCall);
14943 R = CheckForImmediateInvocation(R, FnDecl);
14950 (Op == OO_Spaceship && IsReversed)) {
14951 if (Op == OO_ExclaimEqual) {
14952 assert(ChosenOp == OO_EqualEqual &&
"unexpected operator name");
14953 R = CreateBuiltinUnaryOp(OpLoc, UO_LNot, R.
get());
14955 assert(ChosenOp == OO_Spaceship &&
"unexpected operator name");
14957 Expr *ZeroLiteral =
14963 pushCodeSynthesisContext(Ctx);
14965 R = CreateOverloadedBinOp(
14966 OpLoc, Opc, Fns, IsReversed ? ZeroLiteral : R.
get(),
14967 IsReversed ? R.
get() : ZeroLiteral,
true,
14970 popCodeSynthesisContext();
14975 assert(ChosenOp == Op &&
"unexpected operator name");
14979 if (Best->RewriteKind !=
CRK_None)
14987 ExprResult ArgsRes0 = PerformImplicitConversion(
14988 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
14992 Args[0] = ArgsRes0.
get();
14994 ExprResult ArgsRes1 = PerformImplicitConversion(
14995 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
14999 Args[1] = ArgsRes1.
get();
15009 if (Opc == BO_Comma)
15014 if (DefaultedFn && Opc == BO_Cmp) {
15015 ExprResult E = BuildSynthesizedThreeWayComparison(OpLoc, Fns, Args[0],
15016 Args[1], DefaultedFn);
15031 Opc >= BO_Assign && Opc <= BO_OrAssign) {
15032 Diag(OpLoc, diag::err_ovl_no_viable_oper)
15035 if (Args[0]->getType()->isIncompleteType()) {
15036 Diag(OpLoc, diag::note_assign_lhs_incomplete)
15050 Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
15052 assert(
Result.isInvalid() &&
15053 "C++ binary operator overloading is missing candidates!");
15062 << Args[0]->getType()
15063 << Args[1]->getType()
15064 << Args[0]->getSourceRange()
15065 << Args[1]->getSourceRange()),
15071 if (isImplicitlyDeleted(Best->Function)) {
15075 Diag(OpLoc, diag::err_ovl_deleted_special_oper)
15080 Diag(OpLoc, diag::err_ovl_deleted_comparison)
15081 << Args[0]->
getType() << DeletedFD;
15086 NoteDeletedFunction(DeletedFD);
15094 PDiag(diag::err_ovl_deleted_oper)
15096 .getCXXOverloadedOperator())
15097 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef())
15098 << Args[0]->getSourceRange() << Args[1]->getSourceRange()),
15106 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
15122 "cannot use prvalue expressions more than once");
15123 Expr *OrigLHS = LHS;
15124 Expr *OrigRHS = RHS;
15128 LHS =
new (Context)
15131 RHS =
new (Context)
15135 ExprResult Eq = CreateOverloadedBinOp(OpLoc, BO_EQ, Fns, LHS, RHS,
true,
true,
15137 if (
Eq.isInvalid())
15140 ExprResult Less = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, LHS, RHS,
true,
15141 true, DefaultedFn);
15142 if (
Less.isInvalid())
15147 Greater = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, RHS, LHS,
true,
true,
15154 struct Comparison {
15169 for (; I >= 0; --I) {
15171 auto *VI = Info->lookupValueInfo(Comparisons[I].
Result);
15182 Result = ActOnConditionalOp(OpLoc, OpLoc, Comparisons[I].Cmp.get(),
15194 Context, OrigLHS, OrigRHS, BO_Cmp,
Result.get()->getType(),
15195 Result.get()->getValueKind(),
Result.get()->getObjectKind(), OpLoc,
15196 CurFPFeatureOverrides());
15197 Expr *SemanticForm[] = {LHS, RHS,
Result.get()};
15207 unsigned NumArgsSlots =
15208 MethodArgs.size() + std::max<unsigned>(Args.size(), NumParams);
15211 MethodArgs.reserve(MethodArgs.size() + NumArgsSlots);
15212 bool IsError =
false;
15215 for (
unsigned i = 0; i != NumParams; i++) {
15217 if (i < Args.size()) {
15235 MethodArgs.push_back(Arg);
15245 Args.push_back(
Base);
15246 for (
auto *e : ArgExpr) {
15255 ArgExpr.back()->getEndLoc());
15273 CurFPFeatureOverrides());
15277 UnbridgedCastsSet UnbridgedCasts;
15287 AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
15290 if (Args.size() == 2)
15291 AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
15293 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15306 CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, Best->FoundDecl);
15315 InitializeExplicitObjectArgument(*
this, Args[0], Method);
15318 Args[0] = Res.
get();
15321 ExprResult Arg0 = PerformImplicitObjectArgumentInitialization(
15322 Args[0],
nullptr, Best->FoundDecl, Method);
15326 MethodArgs.push_back(Arg0.
get());
15330 *
this, MethodArgs, Method, ArgExpr, LLoc);
15338 *
this, FnDecl, Best->FoundDecl,
Base, HadMultipleCandidates,
15349 Context, OO_Subscript, FnExpr.
get(), MethodArgs, ResultTy, VK, RLoc,
15350 CurFPFeatureOverrides());
15352 if (CheckCallReturnType(FnDecl->
getReturnType(), LLoc, TheCall, FnDecl))
15355 if (CheckFunctionCall(Method, TheCall,
15359 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
15365 ExprResult ArgsRes0 = PerformImplicitConversion(
15366 Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
15370 Args[0] = ArgsRes0.
get();
15372 ExprResult ArgsRes1 = PerformImplicitConversion(
15373 Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
15377 Args[1] = ArgsRes1.
get();
15385 CandidateSet.
empty()
15386 ? (PDiag(diag::err_ovl_no_oper)
15387 << Args[0]->getType() << 0
15388 << Args[0]->getSourceRange() << Range)
15389 : (PDiag(diag::err_ovl_no_viable_subscript)
15390 << Args[0]->getType() << Args[0]->getSourceRange() << Range);
15397 if (Args.size() == 2) {
15400 LLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
15401 <<
"[]" << Args[0]->getType() << Args[1]->getType()
15402 << Args[0]->getSourceRange() << Range),
15407 PDiag(diag::err_ovl_ambiguous_subscript_call)
15408 << Args[0]->getType()
15409 << Args[0]->getSourceRange() << Range),
15418 PDiag(diag::err_ovl_deleted_oper)
15419 <<
"[]" << (Msg !=
nullptr)
15420 << (Msg ? Msg->
getString() : StringRef())
15421 << Args[0]->getSourceRange() << Range),
15428 return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
15442 Expr *ExecConfig,
bool IsExecConfig,
15443 bool AllowRecovery) {
15452 if (
BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
15454 assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
15467 QualType objectType = op->getLHS()->getType();
15468 if (op->getOpcode() == BO_PtrMemI)
15472 Qualifiers difference = objectQuals - funcQuals;
15476 std::string qualsString = difference.
getAsString();
15477 Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
15480 << (qualsString.find(
' ') == std::string::npos ? 1 : 2);
15484 Context, MemExprE, Args, resultType, valueKind, RParenLoc,
15487 if (CheckCallReturnType(proto->
getReturnType(), op->getRHS()->getBeginLoc(),
15491 if (ConvertArgumentsForCall(call, op,
nullptr, proto, Args, RParenLoc))
15494 if (CheckOtherCall(call, proto))
15497 return MaybeBindToTemporary(call);
15504 if (!AllowRecovery)
15506 std::vector<Expr *> SubExprs = {MemExprE};
15507 llvm::append_range(SubExprs, Args);
15508 return CreateRecoveryExpr(MemExprE->
getBeginLoc(), RParenLoc, SubExprs,
15511 if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
15513 RParenLoc, CurFPFeatureOverrides());
15515 UnbridgedCastsSet UnbridgedCasts;
15521 bool HadMultipleCandidates =
false;
15524 if (isa<MemberExpr>(NakedMemExpr)) {
15525 MemExpr = cast<MemberExpr>(NakedMemExpr);
15529 UnbridgedCasts.restore();
15547 TemplateArgs = &TemplateArgsBuffer;
15551 E = UnresExpr->
decls_end(); I != E; ++I) {
15553 QualType ExplicitObjectType = ObjectType;
15557 if (isa<UsingShadowDecl>(
Func))
15558 Func = cast<UsingShadowDecl>(
Func)->getTargetDecl();
15560 bool HasExplicitParameter =
false;
15561 if (
const auto *M = dyn_cast<FunctionDecl>(
Func);
15562 M && M->hasCXXExplicitFunctionObjectParameter())
15563 HasExplicitParameter =
true;
15564 else if (
const auto *M = dyn_cast<FunctionTemplateDecl>(
Func);
15566 M->getTemplatedDecl()->hasCXXExplicitFunctionObjectParameter())
15567 HasExplicitParameter =
true;
15569 if (HasExplicitParameter)
15573 if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(
Func)) {
15574 AddOverloadCandidate(cast<CXXConstructorDecl>(
Func), I.getPair(), Args,
15577 }
else if ((Method = dyn_cast<CXXMethodDecl>(
Func))) {
15583 AddMethodCandidate(Method, I.getPair(), ActingDC, ExplicitObjectType,
15584 ObjectClassification, Args, CandidateSet,
15587 AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(
Func),
15588 I.getPair(), ActingDC, TemplateArgs,
15589 ExplicitObjectType, ObjectClassification,
15590 Args, CandidateSet,
15595 HadMultipleCandidates = (CandidateSet.
size() > 1);
15599 UnbridgedCasts.restore();
15602 bool Succeeded =
false;
15606 Method = cast<CXXMethodDecl>(Best->Function);
15607 FoundDecl = Best->FoundDecl;
15608 CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
15609 if (DiagnoseUseOfOverloadedDecl(Best->FoundDecl, UnresExpr->
getNameLoc()))
15617 if (Method != FoundDecl.getDecl() &&
15618 DiagnoseUseOfOverloadedDecl(Method, UnresExpr->
getNameLoc()))
15627 PDiag(diag::err_ovl_no_viable_member_function_in_call)
15634 PDiag(diag::err_ovl_ambiguous_member_call)
15639 DiagnoseUseOfDeletedFunction(
15641 CandidateSet, Best->Function, Args,
true);
15649 FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
15652 MemExprE = Res.
get();
15657 return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args, RParenLoc,
15658 ExecConfig, IsExecConfig);
15668 assert(Method &&
"Member call to something that isn't a method?");
15679 HadMultipleCandidates, MemExpr->
getExprLoc());
15685 CurFPFeatureOverrides(), Proto->getNumParams());
15690 ExprResult ObjectArg = PerformImplicitObjectArgumentInitialization(
15691 MemExpr->
getBase(), Qualifier, FoundDecl, Method);
15696 RParenLoc, CurFPFeatureOverrides(),
15697 Proto->getNumParams());
15703 return BuildRecoveryExpr(ResultType);
15706 if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
15708 return BuildRecoveryExpr(ResultType);
15710 DiagnoseSentinelCalls(Method, LParenLoc, Args);
15712 if (CheckFunctionCall(Method, TheCall, Proto))
15718 if (
auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
15719 if (
const EnableIfAttr *
Attr =
15720 CheckEnableIf(Method, LParenLoc, Args,
true)) {
15721 Diag(MemE->getMemberLoc(),
15722 diag::err_ovl_no_viable_member_function_in_call)
15725 diag::note_ovl_candidate_disabled_by_function_cond_attr)
15726 <<
Attr->getCond()->getSourceRange() <<
Attr->getMessage();
15731 if (isa<CXXConstructorDecl, CXXDestructorDecl>(CurContext) &&
15732 TheCall->getDirectCallee()->isPureVirtual()) {
15738 diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
15739 << MD->
getDeclName() << isa<CXXDestructorDecl>(CurContext)
15743 if (getLangOpts().AppleKext)
15749 if (
auto *DD = dyn_cast<CXXDestructorDecl>(TheCall->getDirectCallee())) {
15751 bool CallCanBeVirtual = !MemExpr->
hasQualifier() || getLangOpts().AppleKext;
15752 CheckVirtualDtorCall(DD, MemExpr->
getBeginLoc(),
false,
15753 CallCanBeVirtual,
true,
15757 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
15758 TheCall->getDirectCallee());
15774 UnbridgedCastsSet UnbridgedCasts;
15778 assert(Object.get()->getType()->isRecordType() &&
15779 "Requires object type argument");
15792 if (RequireCompleteType(LParenLoc, Object.get()->getType(),
15793 diag::err_incomplete_object_call, Object.get()))
15797 LookupResult R(*
this, OpName, LParenLoc, LookupOrdinaryName);
15798 LookupQualifiedName(R,
Record->getDecl());
15799 R.suppressAccessDiagnostics();
15802 Oper != OperEnd; ++Oper) {
15803 AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
15804 Object.get()->Classify(Context), Args, CandidateSet,
15816 bool IgnoreSurrogateFunctions =
false;
15817 if (CandidateSet.
size() == 1 &&
Record->getAsCXXRecordDecl()->isLambda()) {
15819 if (!Candidate.
Viable &&
15821 IgnoreSurrogateFunctions =
true;
15841 const auto &Conversions =
15842 cast<CXXRecordDecl>(
Record->getDecl())->getVisibleConversionFunctions();
15843 for (
auto I = Conversions.begin(), E = Conversions.end();
15844 !IgnoreSurrogateFunctions && I != E; ++I) {
15847 if (isa<UsingShadowDecl>(D))
15848 D = cast<UsingShadowDecl>(D)->getTargetDecl();
15852 if (isa<FunctionTemplateDecl>(D))
15865 AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
15866 Object.get(), Args, CandidateSet);
15871 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
15884 CandidateSet.
empty()
15885 ? (PDiag(diag::err_ovl_no_oper)
15886 << Object.get()->getType() << 1
15887 << Object.get()->getSourceRange())
15888 : (PDiag(diag::err_ovl_no_viable_object_call)
15889 << Object.get()->getType() << Object.get()->getSourceRange());
15896 if (!R.isAmbiguous())
15899 PDiag(diag::err_ovl_ambiguous_object_call)
15900 << Object.get()->getType()
15901 << Object.get()->getSourceRange()),
15912 PDiag(diag::err_ovl_deleted_object_call)
15913 << Object.get()->getType() << (Msg !=
nullptr)
15914 << (Msg ? Msg->
getString() : StringRef())
15915 << Object.get()->getSourceRange()),
15921 if (Best == CandidateSet.
end())
15924 UnbridgedCasts.restore();
15926 if (Best->Function ==
nullptr) {
15930 = cast<CXXConversionDecl>(
15931 Best->Conversions[0].UserDefined.ConversionFunction);
15933 CheckMemberOperatorAccess(LParenLoc, Object.get(),
nullptr,
15935 if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
15937 assert(Conv == Best->FoundDecl.getDecl() &&
15938 "Found Decl & conversion-to-functionptr should be same, right?!");
15945 ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
15946 Conv, HadMultipleCandidates);
15947 if (
Call.isInvalid())
15951 Context,
Call.get()->getType(), CK_UserDefinedConversion,
Call.get(),
15952 nullptr,
VK_PRValue, CurFPFeatureOverrides());
15954 return BuildCallExpr(S,
Call.get(), LParenLoc, Args, RParenLoc);
15957 CheckMemberOperatorAccess(LParenLoc, Object.get(),
nullptr, Best->FoundDecl);
15962 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
15975 Obj, HadMultipleCandidates,
15982 MethodArgs.reserve(NumParams + 1);
15984 bool IsError =
false;
15990 DiagnoseInvalidExplicitObjectParameterInLambda(Method);
15993 ExprResult ObjRes = PerformImplicitObjectArgumentInitialization(
15994 Object.get(),
nullptr, Best->FoundDecl, Method);
15999 MethodArgs.push_back(Object.get());
16003 *
this, MethodArgs, Method, Args, LParenLoc);
16006 if (Proto->isVariadic()) {
16008 for (
unsigned i = NumParams, e = Args.size(); i < e; i++) {
16009 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
16012 MethodArgs.push_back(Arg.
get());
16019 DiagnoseSentinelCalls(Method, LParenLoc, Args);
16027 Context, OO_Call, NewFn.
get(), MethodArgs, ResultTy, VK, RParenLoc,
16028 CurFPFeatureOverrides());
16030 if (CheckCallReturnType(Method->
getReturnType(), LParenLoc, TheCall, Method))
16033 if (CheckFunctionCall(Method, TheCall, Proto))
16036 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
16044 bool *NoArrowOperatorFound) {
16045 assert(
Base->getType()->isRecordType() &&
16046 "left-hand side must have class type");
16063 if (RequireCompleteType(Loc,
Base->getType(),
16064 diag::err_typecheck_incomplete_tag,
Base))
16067 LookupResult R(*
this, OpName, OpLoc, LookupOrdinaryName);
16072 Oper != OperEnd; ++Oper) {
16073 AddMethodCandidate(Oper.getPair(),
Base->getType(),
Base->Classify(Context),
16074 std::nullopt, CandidateSet,
16078 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16089 if (CandidateSet.
empty()) {
16091 if (NoArrowOperatorFound) {
16094 *NoArrowOperatorFound =
true;
16097 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
16098 << BaseType <<
Base->getSourceRange();
16100 Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
16104 Diag(OpLoc, diag::err_ovl_no_viable_oper)
16105 <<
"operator->" <<
Base->getSourceRange();
16113 <<
"->" <<
Base->getType()
16114 <<
Base->getSourceRange()),
16122 <<
"->" << (Msg !=
nullptr)
16123 << (Msg ? Msg->
getString() : StringRef())
16124 <<
Base->getSourceRange()),
16130 CheckMemberOperatorAccess(OpLoc,
Base,
nullptr, Best->FoundDecl);
16133 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
16136 ExprResult R = InitializeExplicitObjectArgument(*
this,
Base, Method);
16142 Base,
nullptr, Best->FoundDecl, Method);
16150 Base, HadMultipleCandidates, OpLoc);
16160 ResultTy, VK, OpLoc, CurFPFeatureOverrides());
16162 if (CheckCallReturnType(Method->
getReturnType(), OpLoc, TheCall, Method))
16165 if (CheckFunctionCall(Method, TheCall,
16169 return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
16183 AddNonMemberOperatorCandidates(R.
asUnresolvedSet(), Args, CandidateSet,
16186 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
16199 PDiag(diag::err_ovl_no_viable_function_in_call)
16214 nullptr, HadMultipleCandidates,
16223 for (
unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
16224 ExprResult InputInit = PerformCopyInitialization(
16229 ConvArgs[ArgIdx] = InputInit.
get();
16238 LitEndLoc, UDSuffixLoc, CurFPFeatureOverrides());
16240 if (CheckCallReturnType(FD->
getReturnType(), UDSuffixLoc, UDL, FD))
16243 if (CheckFunctionCall(FD, UDL,
nullptr))
16246 return CheckForImmediateInvocation(MaybeBindToTemporary(UDL), FD);
16263 Scope *S =
nullptr;
16266 if (!MemberLookup.
empty()) {
16268 BuildMemberReferenceExpr(Range, Range->getType(), Loc,
16276 return FRS_DiagnosticIssued;
16279 BuildCallExpr(S, MemberRef.
get(), Loc, std::nullopt, Loc,
nullptr);
16282 return FRS_DiagnosticIssued;
16285 ExprResult FnR = CreateUnresolvedLookupExpr(
nullptr,
16289 return FRS_DiagnosticIssued;
16292 bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc,
16294 if (CandidateSet->
empty() || CandidateSetError) {
16296 return FRS_NoViableFunction;
16304 return FRS_NoViableFunction;
16307 Loc,
nullptr, CandidateSet, &Best,
16312 return FRS_DiagnosticIssued;
16315 return FRS_Success;
16326 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
16328 FixOverloadedFunctionReference(PE->getSubExpr(), Found, Fn);
16331 if (SubExpr.
get() == PE->getSubExpr())
16334 return new (Context)
16335 ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.
get());
16340 FixOverloadedFunctionReference(ICE->getSubExpr(), Found, Fn);
16343 assert(Context.
hasSameType(ICE->getSubExpr()->getType(),
16345 "Implicit cast type cannot be determined from overload");
16346 assert(ICE->path_empty() &&
"fixing up hierarchy conversion?");
16347 if (SubExpr.
get() == ICE->getSubExpr())
16352 CurFPFeatureOverrides());
16355 if (
auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
16356 if (!GSE->isResultDependent()) {
16358 FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
16361 if (SubExpr.
get() == GSE->getResultExpr())
16368 unsigned ResultIdx = GSE->getResultIndex();
16369 AssocExprs[ResultIdx] = SubExpr.
get();
16371 if (GSE->isExprPredicate())
16373 Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
16374 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16375 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16378 Context, GSE->getGenericLoc(), GSE->getControllingType(),
16379 GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16380 GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16389 assert(UnOp->getOpcode() == UO_AddrOf &&
16390 "Can only take the address of an overloaded function");
16392 if (Method->isStatic()) {
16400 FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
16403 if (SubExpr.
get() == UnOp->getSubExpr())
16406 if (CheckUseOfCXXMethodAsAddressOfOperand(UnOp->getBeginLoc(),
16407 SubExpr.
get(), Method))
16410 assert(isa<DeclRefExpr>(SubExpr.
get()) &&
16411 "fixed to something other than a decl ref");
16412 assert(cast<DeclRefExpr>(SubExpr.
get())->getQualifier() &&
16413 "fixed to a member ref with no nested name qualifier");
16424 (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
16428 UnOp->getOperatorLoc(),
false,
16429 CurFPFeatureOverrides());
16433 FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
16436 if (SubExpr.
get() == UnOp->getSubExpr())
16439 return CreateBuiltinUnaryOp(UnOp->getOperatorLoc(), UO_AddrOf,
16446 if (ULE->hasExplicitTemplateArgs()) {
16447 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
16448 TemplateArgs = &TemplateArgsBuffer;
16463 Fn,
Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
16464 Found.
getDecl(), ULE->getTemplateKeywordLoc(), TemplateArgs);
16472 if (MemExpr->hasExplicitTemplateArgs()) {
16473 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
16474 TemplateArgs = &TemplateArgsBuffer;
16481 if (MemExpr->isImplicitAccess()) {
16482 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16485 MemExpr->getQualifierLoc(), Found.
getDecl(),
16486 MemExpr->getTemplateKeywordLoc(), TemplateArgs);
16491 if (MemExpr->getQualifier())
16492 Loc = MemExpr->getQualifierLoc().getBeginLoc();
16494 BuildCXXThisExpr(Loc, MemExpr->getBaseType(),
true);
16497 Base = MemExpr->getBase();
16501 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16509 return BuildMemberExpr(
16510 Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
16511 MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
16512 true, MemExpr->getMemberNameInfo(),
16516 llvm_unreachable(
"Invalid reference to overloaded function");
16522 return FixOverloadedFunctionReference(E.
get(), Found, Fn);
16527 if (!PartialOverloading || !
Function)
16531 if (
const auto *Proto =
16532 dyn_cast<FunctionProtoType>(
Function->getFunctionType()))
16533 if (Proto->isTemplateVariadic())
16535 if (
auto *Pattern =
Function->getTemplateInstantiationPattern())
16536 if (
const auto *Proto =
16537 dyn_cast<FunctionProtoType>(Pattern->getFunctionType()))
16538 if (Proto->isTemplateVariadic())
16551 << IsMember << Name << (Msg !=
nullptr)
16552 << (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 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...
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
bool resolveAndFixAddressOfSingleOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
bool anyAltivecTypes(QualType srcType, QualType destType)
bool isLaxVectorConversion(QualType srcType, QualType destType)
Is this a legal conversion between two types, one of which is known to be a vector type?
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.
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
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
DeclarationName getMemberName() const
Retrieve the name of the member that this expression refers to.
QualType getBaseType() const
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getMemberLoc() const
Retrieve the location of the name of the member that this expression refers to.
A set of unresolved declarations.
void addDecl(NamedDecl *D)
The iterator over UnresolvedSets.
A set of unresolved declarations.
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
static UserDefinedLiteral * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation LitEndLoc, SourceLocation SuffixLoc, FPOptionsOverride FPFeatures)
Represents a GCC generic vector type.
Provides information about an attempted template argument deduction, whose success or failure was des...
TemplateArgumentList * takeSugared()
Take ownership of the deduced template argument lists.
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
bool AggregateDeductionCandidateHasMismatchedArity
TemplateArgument FirstArg
The first template argument to which the template argument deduction failure refers.
ConstraintSatisfaction AssociatedConstraintsSatisfaction
The constraint satisfaction details resulting from the associated constraints satisfaction tests.
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
unsigned CallArgIndex
The index of the function argument that caused a deduction failure.
specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are o...
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
@ NUM_OVERLOADED_OPERATORS
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ ovl_fail_final_conversion_not_exact
This conversion function template specialization candidate is not viable because the final conversion...
@ ovl_fail_enable_if
This candidate function was not viable because an enable_if attribute disabled it.
@ ovl_fail_illegal_constructor
This conversion candidate was not considered because it is an illegal instantiation of a constructor ...
@ ovl_fail_bad_final_conversion
This conversion candidate is not viable because its result type is not implicitly convertible to the ...
@ ovl_fail_module_mismatched
This candidate was not viable because it has internal linkage and is from a different module unit tha...
@ ovl_fail_too_few_arguments
@ ovl_fail_addr_not_available
This candidate was not viable because its address could not be taken.
@ ovl_fail_too_many_arguments
@ ovl_non_default_multiversion_function
This candidate was not viable because it is a non-default multiversioned function.
@ ovl_fail_constraints_not_satisfied
This candidate was not viable because its associated constraints were not satisfied.
@ ovl_fail_bad_conversion
@ ovl_fail_bad_target
(CUDA) This candidate was not viable because the callee was not accessible from the caller's target (...
@ ovl_fail_inhctor_slice
This inherited constructor is not viable because it would slice the argument.
@ ovl_fail_object_addrspace_mismatch
This constructor/conversion candidate fail due to an address space mismatch between the object being ...
@ ovl_fail_explicit
This candidate constructor or conversion function is explicit but the context doesn't permit explicit...
@ ovl_fail_trivial_conversion
This conversion candidate was not considered because it duplicates the work of a trivial or derived-t...
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
ImplicitConversionRank
ImplicitConversionRank - The rank of an implicit conversion kind.
@ ICR_Conversion
Conversion.
@ ICR_Writeback_Conversion
ObjC ARC writeback conversion.
@ ICR_C_Conversion
Conversion only allowed in the C standard (e.g. void* to char*).
@ ICR_OCL_Scalar_Widening
OpenCL Scalar Widening.
@ ICR_Complex_Real_Conversion
Complex <-> Real conversion.
@ ICR_Promotion
Promotion.
@ ICR_Exact_Match
Exact Match.
@ ICR_C_Conversion_Extension
Conversion not allowed by the C standard, but that we accept as an extension anyway.
OverloadCandidateDisplayKind
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_ViableCandidates
Requests that only viable candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
@ OK_Ordinary
An ordinary object is located at an address in memory.
OverloadCandidateParamOrder
The parameter ordering that will be used for the candidate.
OverloadsShown
Specifies which overload candidates to display when overload resolution fails.
@ Ovl_Best
Show just the "best" overload candidates.
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
OverloadCandidateRewriteKind
The kinds of rewrite we perform on overload candidates.
@ CRK_Reversed
Candidate is a rewritten candidate with a reversed order of parameters.
@ CRK_None
Candidate is not a rewritten candidate.
@ CRK_DifferentOperator
Candidate is a rewritten candidate with a different operator name.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ Result
The result type of a method or function.
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter's...
@ ICK_Complex_Conversion
Complex conversions (C99 6.3.1.6)
@ ICK_Floating_Promotion
Floating point promotions (C++ [conv.fpprom])
@ ICK_Boolean_Conversion
Boolean conversions (C++ [conv.bool])
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Fixed_Point_Conversion
Fixed point type conversions according to N1169.
@ ICK_Vector_Conversion
Vector conversions.
@ ICK_Block_Pointer_Conversion
Block Pointer conversions.
@ ICK_Pointer_Member
Pointer-to-member conversions (C++ [conv.mem])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_HLSL_Array_RValue
HLSL non-decaying array rvalue cast.
@ ICK_SVE_Vector_Conversion
Arm SVE Vector conversions.
@ ICK_HLSL_Vector_Truncation
HLSL vector truncation.
@ ICK_Incompatible_Pointer_Conversion
C-only conversion between pointers with incompatible types.
@ ICK_Array_To_Pointer
Array-to-pointer conversion (C++ [conv.array])
@ ICK_RVV_Vector_Conversion
RISC-V RVV Vector conversions.
@ ICK_Complex_Promotion
Complex promotions (Clang extension)
@ ICK_Num_Conversion_Kinds
The number of conversion kinds.
@ ICK_Function_Conversion
Function pointer conversion (C++17 [conv.fctptr])
@ ICK_Vector_Splat
A vector splat from an arithmetic type.
@ ICK_Zero_Queue_Conversion
Zero constant to queue.
@ ICK_Identity
Identity conversion (no conversion)
@ ICK_Derived_To_Base
Derived-to-base (C++ [over.best.ics])
@ ICK_Lvalue_To_Rvalue
Lvalue-to-rvalue conversion (C++ [conv.lval])
@ ICK_Qualification
Qualification conversions (C++ [conv.qual])
@ ICK_Pointer_Conversion
Pointer conversions (C++ [conv.ptr])
@ ICK_TransparentUnionConversion
Transparent Union Conversions.
@ ICK_Integral_Promotion
Integral promotions (C++ [conv.prom])
@ ICK_Floating_Conversion
Floating point conversions (C++ [conv.double].
@ ICK_Compatible_Conversion
Conversions between compatible types in C99.
@ ICK_C_Only_Conversion
Conversions allowed in C, but not C++.
@ ICK_Writeback_Conversion
Objective-C ARC writeback conversion.
@ ICK_Zero_Event_Conversion
Zero constant to event (OpenCL1.2 6.12.10)
@ ICK_Complex_Real
Complex-real conversions (C99 6.3.1.7)
@ ICK_Function_To_Pointer
Function-to-pointer (C++ [conv.array])
ActionResult< Expr * > ExprResult
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
CXXSpecialMemberKind
Kinds of C++ special members.
OverloadedOperatorKind getRewrittenOverloadedOperator(OverloadedOperatorKind Kind)
Get the other overloaded operator that the given operator can be rewritten into, if any such operator...
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
bool isBetterOverloadCandidate(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2, SourceLocation Loc, OverloadCandidateSet::CandidateSetKind Kind)
isBetterOverloadCandidate - Determines whether the first overload candidate is a better candidate tha...
const FunctionProtoType * T
bool shouldEnforceArgLimit(bool PartialOverloading, FunctionDecl *Function)
NarrowingKind
NarrowingKind - The kind of narrowing conversion being performed by a standard conversion sequence ac...
@ NK_Not_Narrowing
Not a narrowing conversion.
@ NK_Constant_Narrowing
A narrowing conversion, because a constant expression got narrowed.
@ NK_Dependent_Narrowing
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
@ NK_Type_Narrowing
A narrowing conversion by virtue of the source and destination types.
@ NK_Variable_Narrowing
A narrowing conversion, because a non-constant-expression variable might have got narrowed.
@ TPOC_Conversion
Partial ordering of function templates for a call to a conversion function.
@ TPOC_Call
Partial ordering of function templates for a function call.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ MiscellaneousDeductionFailure
Deduction failed; that's all we know.
@ NonDependentConversionFailure
Checking non-dependent argument conversions failed.
@ ConstraintsNotSatisfied
The deduced arguments did not satisfy the constraints associated with the template.
@ Underqualified
Template argument deduction failed due to inconsistent cv-qualifiers on a template parameter type tha...
@ InstantiationDepth
Template argument deduction exceeded the maximum template instantiation depth (which has already been...
@ InvalidExplicitArguments
The explicitly-specified template arguments were not valid template arguments for the given template.
@ CUDATargetMismatch
CUDA Target attributes do not match.
@ TooFewArguments
When performing template argument deduction for a function template, there were too few call argument...
@ Incomplete
Template argument deduction did not deduce a value for every template parameter.
@ Invalid
The declaration was invalid; do nothing.
@ Success
Template argument deduction was successful.
@ SubstitutionFailure
Substitution of the deduced template argument values resulted in an error.
@ IncompletePack
Template argument deduction did not deduce a value for every expansion of an expanded template parame...
@ DeducedMismatch
After substituting deduced template arguments, a dependent parameter type did not match the correspon...
@ Inconsistent
Template argument deduction produced inconsistent deduced values for the given template parameter.
@ TooManyArguments
When performing template argument deduction for a function template, there were too many call argumen...
@ AlreadyDiagnosed
Some error which was already diagnosed.
@ DeducedMismatchNested
After substituting deduced template arguments, an element of a dependent parameter type did not match...
@ NonDeducedMismatch
A non-depnedent component of the parameter did not match the corresponding component of the argument.
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.