36#include "llvm/ADT/DenseSet.h"
37#include "llvm/ADT/STLExtras.h"
38#include "llvm/ADT/SmallPtrSet.h"
39#include "llvm/ADT/SmallString.h"
40#include "llvm/Support/Casting.h"
52 return P->hasAttr<PassObjectSizeAttr>();
73 if (HadMultipleCandidates)
84 CK_FunctionToPointerDecay);
88 bool InOverloadResolution,
91 bool AllowObjCWritebackConversion);
95 bool InOverloadResolution,
103 bool AllowObjCConversionOnExplicit);
161 return Rank[(
int)Kind];
167 static const char*
const Name[] = {
171 "Function-to-pointer",
172 "Function pointer conversion",
174 "Integral promotion",
175 "Floating point promotion",
177 "Integral conversion",
178 "Floating conversion",
179 "Complex conversion",
180 "Floating-integral conversion",
181 "Pointer conversion",
182 "Pointer-to-member conversion",
183 "Boolean conversion",
184 "Compatible-types conversion",
185 "Derived-to-base conversion",
187 "SVE Vector conversion",
188 "RVV Vector conversion",
190 "Complex-real conversion",
191 "Block Pointer conversion",
192 "Transparent Union Conversion",
193 "Writeback conversion",
194 "OpenCL Zero Event Conversion",
195 "OpenCL Zero Queue Conversion",
196 "C specific type conversion",
197 "Incompatible pointer conversion"
281 const Expr *Converted) {
284 if (
auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
291 while (
auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
292 switch (ICE->getCastKind()) {
294 case CK_IntegralCast:
295 case CK_IntegralToBoolean:
296 case CK_IntegralToFloating:
297 case CK_BooleanToSignedIntegral:
298 case CK_FloatingToIntegral:
299 case CK_FloatingToBoolean:
300 case CK_FloatingCast:
301 Converted = ICE->getSubExpr();
325 QualType &ConstantType,
bool IgnoreFloatToIntegralConversion)
const {
326 assert(Ctx.
getLangOpts().CPlusPlus &&
"narrowing check outside C++");
337 ToType = ET->getDecl()->getIntegerType();
343 goto FloatingIntegralConversion;
345 goto IntegralConversion;
356 FloatingIntegralConversion:
361 if (IgnoreFloatToIntegralConversion)
364 assert(
Initializer &&
"Unknown conversion expression");
370 if (std::optional<llvm::APSInt> IntConstantValue =
374 Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
375 llvm::APFloat::rmNearestTiesToEven);
377 llvm::APSInt ConvertedValue = *IntConstantValue;
379 Result.convertToInteger(ConvertedValue,
380 llvm::APFloat::rmTowardZero, &ignored);
382 if (*IntConstantValue != ConvertedValue) {
383 ConstantValue =
APValue(*IntConstantValue);
408 if (
Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
410 assert(ConstantValue.
isFloat());
411 llvm::APFloat FloatVal = ConstantValue.
getFloat();
414 llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
416 llvm::APFloat::rmNearestTiesToEven, &ignored);
419 if (ConvertStatus & llvm::APFloat::opOverflow) {
435 IntegralConversion: {
439 const unsigned FromWidth = Ctx.
getIntWidth(FromType);
443 if (FromWidth > ToWidth ||
444 (FromWidth == ToWidth && FromSigned != ToSigned) ||
445 (FromSigned && !ToSigned)) {
453 std::optional<llvm::APSInt> OptInitializerValue;
454 if (!(OptInitializerValue =
Initializer->getIntegerConstantExpr(Ctx))) {
458 llvm::APSInt &InitializerValue = *OptInitializerValue;
459 bool Narrowing =
false;
460 if (FromWidth < ToWidth) {
463 if (InitializerValue.isSigned() && InitializerValue.isNegative())
468 InitializerValue = InitializerValue.extend(
469 InitializerValue.getBitWidth() + 1);
471 llvm::APSInt ConvertedValue = InitializerValue;
472 ConvertedValue = ConvertedValue.trunc(ToWidth);
473 ConvertedValue.setIsSigned(ToSigned);
474 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
475 ConvertedValue.setIsSigned(InitializerValue.isSigned());
477 if (ConvertedValue != InitializerValue)
482 ConstantValue =
APValue(InitializerValue);
498 raw_ostream &OS = llvm::errs();
499 bool PrintedSomething =
false;
502 PrintedSomething =
true;
506 if (PrintedSomething) {
512 OS <<
" (by copy constructor)";
514 OS <<
" (direct reference binding)";
516 OS <<
" (reference binding)";
518 PrintedSomething =
true;
522 if (PrintedSomething) {
526 PrintedSomething =
true;
529 if (!PrintedSomething) {
530 OS <<
"No conversions required";
537 raw_ostream &OS = llvm::errs();
545 OS <<
"aggregate initialization";
555 raw_ostream &OS = llvm::errs();
557 OS <<
"Worst list element conversion: ";
558 switch (ConversionKind) {
560 OS <<
"Standard conversion: ";
564 OS <<
"User-defined conversion: ";
568 OS <<
"Ellipsis conversion";
571 OS <<
"Ambiguous conversion";
574 OS <<
"Bad conversion";
599 struct DFIArguments {
605 struct DFIParamWithArguments : DFIArguments {
610 struct DFIDeducedMismatchArgs : DFIArguments {
612 unsigned CallArgIndex;
629 Result.Result =
static_cast<unsigned>(TDK);
630 Result.HasDiagnostic =
false;
649 auto *Saved =
new (Context) DFIDeducedMismatchArgs;
660 DFIArguments *Saved =
new (Context) DFIArguments;
672 DFIParamWithArguments *Saved =
new (Context) DFIParamWithArguments;
673 Saved->Param = Info.
Param;
686 Result.HasDiagnostic =
true;
691 CNSInfo *Saved =
new (Context) CNSInfo;
701 llvm_unreachable(
"not a deduction failure");
734 Diag->~PartialDiagnosticAt();
743 Diag->~PartialDiagnosticAt();
779 return TemplateParameter::getFromOpaqueValue(
Data);
784 return static_cast<DFIParamWithArguments*
>(
Data)->Param;
814 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->TemplateArgs;
820 return static_cast<CNSInfo*
>(
Data)->TemplateArgs;
852 return &
static_cast<DFIArguments*
>(
Data)->FirstArg;
884 return &
static_cast<DFIArguments*
>(
Data)->SecondArg;
899 return static_cast<DFIDeducedMismatchArgs*
>(
Data)->CallArgIndex;
912 for (
unsigned I = 0; I <
X->getNumParams(); ++I)
916 if (
auto *FTX =
X->getDescribedFunctionTemplate()) {
921 FTY->getTemplateParameters()))
930 OverloadedOperatorKind::OO_EqualEqual);
942 OverloadedOperatorKind::OO_ExclaimEqual);
943 if (isa<CXXMethodDecl>(EqFD)) {
965 auto *FD = Op->getAsFunction();
966 if(
auto* UD = dyn_cast<UsingShadowDecl>(Op))
967 FD = UD->getUnderlyingDecl()->getAsFunction();
970 cast<Decl>(Op->getDeclContext())))
980 return Op == OO_EqualEqual || Op == OO_Spaceship;
986 if (!allowsReversed(Op))
988 if (Op == OverloadedOperatorKind::OO_EqualEqual) {
989 assert(OriginalArgs.size() == 2);
991 S, OpLoc, OriginalArgs[1], FD))
1002void OverloadCandidateSet::destroyCandidates() {
1004 for (
auto &
C : i->Conversions)
1005 C.~ImplicitConversionSequence();
1007 i->DeductionFailure.Destroy();
1012 destroyCandidates();
1013 SlabAllocator.Reset();
1014 NumInlineBytesUsed = 0;
1021 class UnbridgedCastsSet {
1031 Entry entry = { &E, E };
1032 Entries.push_back(entry);
1038 i = Entries.begin(), e = Entries.end(); i != e; ++i)
1039 *i->Addr = i->Saved;
1053 UnbridgedCastsSet *unbridgedCasts =
nullptr) {
1057 if (placeholder->getKind() == BuiltinType::Overload)
return false;
1061 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
1063 unbridgedCasts->save(S, E);
1083 UnbridgedCastsSet &unbridged) {
1084 for (
unsigned i = 0, e = Args.size(); i != e; ++i)
1126 NamedDecl *&Match,
bool NewIsUsingDecl) {
1131 bool OldIsUsingDecl =
false;
1132 if (isa<UsingShadowDecl>(OldD)) {
1133 OldIsUsingDecl =
true;
1137 if (NewIsUsingDecl)
continue;
1139 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
1144 if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
1152 bool UseMemberUsingDeclRules =
1153 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
1157 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
1158 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
1159 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
1163 if (!isa<FunctionTemplateDecl>(OldD) &&
1164 !shouldLinkPossiblyHiddenDecl(*I, New))
1173 if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
1175 return Ovl_NonFunction;
1177 }
else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1181 }
else if (isa<TagDecl>(OldD)) {
1183 }
else if (
auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1190 if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1192 return Ovl_NonFunction;
1199 return Ovl_NonFunction;
1224 if (CheckFunctionTemplateSpecialization(New,
nullptr, TemplateSpecResult,
1227 return Ovl_Overload;
1234 return Ovl_Overload;
1238 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs,
1239 bool ConsiderRequiresClauses) {
1254 if ((OldTemplate ==
nullptr) != (NewTemplate ==
nullptr))
1267 if (isa<FunctionNoProtoType>(OldQType.
getTypePtr()) ||
1268 isa<FunctionNoProtoType>(NewQType.
getTypePtr()))
1277 if (OldQType != NewQType &&
1280 !FunctionParamTypesAreEqual(OldType, NewType)))
1299 bool SameTemplateParameterList = TemplateParameterListsAreEqual(
1307 bool ConstraintsInTemplateHead =
1318 if (UseMemberUsingDeclRules && ConstraintsInTemplateHead &&
1319 !SameTemplateParameterList)
1321 if (!UseMemberUsingDeclRules &&
1322 (!SameTemplateParameterList || !SameReturnType))
1326 if (ConsiderRequiresClauses) {
1329 if ((NewRC !=
nullptr) != (OldRC !=
nullptr))
1332 if (NewRC && !AreConstraintExpressionsEqual(Old, OldRC, New, NewRC))
1346 if (OldMethod && NewMethod &&
1349 if (!UseMemberUsingDeclRules &&
1373 !isa<CXXConstructorDecl>(NewMethod))
1376 OldQuals.removeRestrict();
1377 NewQuals.removeRestrict();
1378 if (OldQuals != NewQuals)
1396 NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1397 if (NewI == NewE || OldI == OldE)
1399 llvm::FoldingSetNodeID NewID, OldID;
1400 NewI->getCond()->Profile(NewID, Context,
true);
1401 OldI->getCond()->Profile(OldID, Context,
true);
1406 if (getLangOpts().
CUDA && ConsiderCudaAttrs) {
1409 if (!isa<CXXDestructorDecl>(New)) {
1411 OldTarget = IdentifyCUDATarget(Old);
1412 if (NewTarget != CFT_InvalidTarget) {
1413 assert((OldTarget != CFT_InvalidTarget) &&
1414 "Unexpected invalid target.");
1418 if (NewTarget != OldTarget)
1434 bool SuppressUserConversions,
1436 bool InOverloadResolution,
1438 bool AllowObjCWritebackConversion,
1439 bool AllowObjCConversionOnExplicit) {
1442 if (SuppressUserConversions) {
1453 Conversions, AllowExplicit,
1454 AllowObjCConversionOnExplicit)) {
1471 if (Constructor->isCopyConstructor() &&
1472 (FromCanon == ToCanon ||
1483 if (ToCanon != FromCanon)
1494 Cand != Conversions.
end(); ++Cand)
1537 bool SuppressUserConversions,
1539 bool InOverloadResolution,
1541 bool AllowObjCWritebackConversion,
1542 bool AllowObjCConversionOnExplicit) {
1545 ICS.
Standard, CStyle, AllowObjCWritebackConversion)){
1585 AllowExplicit, InOverloadResolution, CStyle,
1586 AllowObjCWritebackConversion,
1587 AllowObjCConversionOnExplicit);
1592 bool SuppressUserConversions,
1594 bool InOverloadResolution,
1596 bool AllowObjCWritebackConversion) {
1597 return ::TryImplicitConversion(*
this, From, ToType, SuppressUserConversions,
1598 AllowExplicit, InOverloadResolution, CStyle,
1599 AllowObjCWritebackConversion,
1610 bool AllowExplicit) {
1615 bool AllowObjCWritebackConversion
1616 = getLangOpts().ObjCAutoRefCount &&
1617 (Action == AA_Passing || Action == AA_Sending);
1618 if (getLangOpts().ObjC)
1619 CheckObjCBridgeRelatedConversions(From->
getBeginLoc(), ToType,
1622 *
this, From, ToType,
1624 AllowExplicit ? AllowedExplicit::All : AllowedExplicit::None,
1626 false, AllowObjCWritebackConversion,
1628 return PerformImplicitConversion(From, ToType, ICS, Action);
1649 if (TyClass != CanFrom->getTypeClass())
return false;
1650 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1651 if (TyClass == Type::Pointer) {
1654 }
else if (TyClass == Type::BlockPointer) {
1657 }
else if (TyClass == Type::MemberPointer) {
1661 if (ToMPT->getClass() != FromMPT->
getClass())
1663 CanTo = ToMPT->getPointeeType();
1669 TyClass = CanTo->getTypeClass();
1670 if (TyClass != CanFrom->getTypeClass())
return false;
1671 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1675 const auto *FromFn = cast<FunctionType>(CanFrom);
1678 const auto *ToFn = cast<FunctionType>(CanTo);
1681 bool Changed =
false;
1690 if (
const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1691 const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1692 if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1693 FromFn = cast<FunctionType>(
1704 bool CanUseToFPT, CanUseFromFPT;
1706 CanUseFromFPT, NewParamInfos) &&
1707 CanUseToFPT && !CanUseFromFPT) {
1710 NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1712 FromFPT->getParamTypes(), ExtInfo);
1721 assert(
QualType(FromFn, 0).isCanonical());
1722 if (
QualType(FromFn, 0) != CanTo)
return false;
1735 bool InOverloadResolution,
bool CStyle) {
1785 !ToType->
hasAttr(attr::ArmMveStrictPolymorphism))) {
1790 !InOverloadResolution && !CStyle) {
1792 << FromType << ToType;
1803 bool InOverloadResolution,
1816 bool InOverloadResolution,
1819 bool AllowObjCWritebackConversion) {
1866 if (Method && !Method->
isStatic()) {
1868 "Non-unary operator on non-static member address");
1869 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode()
1871 "Non-address-of operator on non-static member address");
1872 const Type *ClassType
1876 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode() ==
1878 "Non-address-of operator for overloaded function expression");
1898 FromType = Atomic->getValueType();
1933 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
1953 bool IncompatibleObjC =
false;
2007 const llvm::fltSemantics &FromSem =
2010 if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
2011 &ToSem == &llvm::APFloat::IEEEquad()) ||
2012 (&FromSem == &llvm::APFloat::IEEEquad() &&
2013 &ToSem == &llvm::APFloat::PPCDoubleDouble()))
2029 }
else if (AllowObjCWritebackConversion &&
2033 FromType, IncompatibleObjC)) {
2039 InOverloadResolution, FromType)) {
2043 InOverloadResolution, CStyle)) {
2052 InOverloadResolution,
2083 bool ObjCLifetimeConversion;
2089 ObjCLifetimeConversion)) {
2108 CanonFrom = CanonTo;
2113 if (CanonFrom == CanonTo)
2118 if (S.
getLangOpts().CPlusPlus || !InOverloadResolution)
2162 bool InOverloadResolution,
2172 for (
const auto *it : UD->
fields()) {
2175 ToType = it->getType();
2205 return To->
getKind() == BuiltinType::Int;
2208 return To->
getKind() == BuiltinType::UInt;
2232 if (FromEnumType->getDecl()->isScoped())
2239 if (FromEnumType->getDecl()->isFixed()) {
2240 QualType Underlying = FromEnumType->getDecl()->getIntegerType();
2242 IsIntegralPromotion(
nullptr, Underlying, ToType);
2249 ToType, FromEnumType->getDecl()->getPromotionType());
2274 uint64_t FromSize = Context.
getTypeSize(FromType);
2283 for (
int Idx = 0; Idx < 6; ++Idx) {
2284 uint64_t ToSize = Context.
getTypeSize(PromoteTypes[Idx]);
2285 if (FromSize < ToSize ||
2286 (FromSize == ToSize &&
2287 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2312 std::optional<llvm::APSInt> BitWidth;
2315 MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
2316 llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
2320 if (*BitWidth < ToSize ||
2322 return To->
getKind() == BuiltinType::Int;
2328 return To->
getKind() == BuiltinType::UInt;
2353 if (FromBuiltin->getKind() == BuiltinType::Float &&
2354 ToBuiltin->getKind() == BuiltinType::Double)
2361 (FromBuiltin->getKind() == BuiltinType::Float ||
2362 FromBuiltin->getKind() == BuiltinType::Double) &&
2363 (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2364 ToBuiltin->getKind() == BuiltinType::Float128 ||
2365 ToBuiltin->getKind() == BuiltinType::Ibm128))
2369 if (!getLangOpts().NativeHalfType &&
2370 FromBuiltin->getKind() == BuiltinType::Half &&
2371 ToBuiltin->getKind() == BuiltinType::Float)
2408 bool StripObjCLifetime =
false) {
2411 "Invalid similarly-qualified pointer type");
2422 if (StripObjCLifetime)
2433 if (isa<ObjCObjectPointerType>(ToType))
2442 if (isa<ObjCObjectPointerType>(ToType))
2448 bool InOverloadResolution,
2454 return !InOverloadResolution;
2478 bool InOverloadResolution,
2480 bool &IncompatibleObjC) {
2481 IncompatibleObjC =
false;
2482 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2489 ConvertedType = ToType;
2496 ConvertedType = ToType;
2503 ConvertedType = ToType;
2511 ConvertedType = ToType;
2521 ConvertedType = ToType;
2529 !getLangOpts().ObjCAutoRefCount) {
2559 if (getLangOpts().MSVCCompat && FromPointeeType->
isFunctionType() &&
2593 IsDerivedFrom(From->
getBeginLoc(), FromPointeeType, ToPointeeType)) {
2630 bool &IncompatibleObjC) {
2631 if (!getLangOpts().
ObjC)
2643 if (ToObjCPtr && FromObjCPtr) {
2654 if (getLangOpts().CPlusPlus && LHS && RHS &&
2656 FromObjCPtr->getPointeeType()))
2661 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2669 IncompatibleObjC =
true;
2673 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2685 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2713 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2714 IncompatibleObjC)) {
2716 IncompatibleObjC =
true;
2718 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2725 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2726 IncompatibleObjC)) {
2729 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2741 if (FromFunctionType && ToFunctionType) {
2750 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
2751 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic() ||
2752 FromFunctionType->
getMethodQuals() != ToFunctionType->getMethodQuals())
2755 bool HasObjCConversion =
false;
2759 }
else if (isObjCPointerConversion(FromFunctionType->
getReturnType(),
2760 ToFunctionType->getReturnType(),
2761 ConvertedType, IncompatibleObjC)) {
2763 HasObjCConversion =
true;
2770 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
2771 ArgIdx != NumArgs; ++ArgIdx) {
2773 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2777 }
else if (isObjCPointerConversion(FromArgType, ToArgType,
2778 ConvertedType, IncompatibleObjC)) {
2780 HasObjCConversion =
true;
2787 if (HasObjCConversion) {
2791 IncompatibleObjC =
true;
2810 if (!getLangOpts().ObjCAutoRefCount ||
2852 bool IncompatibleObjC;
2854 FromPointee = ToPointee;
2855 else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2890 if (!FromFunctionType || !ToFunctionType)
2893 if (Context.
hasSameType(FromPointeeType, ToPointeeType))
2898 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
2899 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic())
2904 if (FromEInfo != ToEInfo)
2907 bool IncompatibleObjC =
false;
2909 ToFunctionType->getReturnType())) {
2913 QualType LHS = ToFunctionType->getReturnType();
2914 if ((!getLangOpts().CPlusPlus || !RHS->
isRecordType()) &&
2920 }
else if (isObjCPointerConversion(RHS, LHS,
2921 ConvertedType, IncompatibleObjC)) {
2922 if (IncompatibleObjC)
2931 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
2932 ArgIdx != NumArgs; ++ArgIdx) {
2933 IncompatibleObjC =
false;
2935 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2936 if (Context.
hasSameType(FromArgType, ToArgType)) {
2938 }
else if (isObjCPointerConversion(ToArgType, FromArgType,
2939 ConvertedType, IncompatibleObjC)) {
2940 if (IncompatibleObjC)
2949 bool CanUseToFPT, CanUseFromFPT;
2951 CanUseToFPT, CanUseFromFPT,
2955 ConvertedType = ToType;
2996 if (!Context.
hasSameType(FromMember->getClass(), ToMember->getClass())) {
2998 <<
QualType(FromMember->getClass(), 0);
3031 if (!FromFunction || !ToFunction) {
3036 if (FromFunction->
getNumParams() != ToFunction->getNumParams()) {
3044 if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
3046 << ToFunction->getParamType(ArgPos)
3053 ToFunction->getReturnType())) {
3059 if (FromFunction->
getMethodQuals() != ToFunction->getMethodQuals()) {
3069 cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
3090 "Can't compare parameters of functions with different number of "
3119 bool IgnoreBaseAccess,
3122 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
3126 if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->
isAnyPointerType() &&
3130 DiagRuntimeBehavior(From->
getExprLoc(), From,
3131 PDiag(diag::warn_impcast_bool_to_null_pointer)
3133 else if (!isUnevaluatedContext())
3142 if (FromPointeeType->
isRecordType() && ToPointeeType->isRecordType() &&
3146 unsigned InaccessibleID = 0;
3147 unsigned AmbiguousID = 0;
3149 InaccessibleID = diag::err_upcast_to_inaccessible_base;
3150 AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
3152 if (CheckDerivedToBaseConversion(
3153 FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
3155 &BasePath, IgnoreBaseAccess))
3159 Kind = CK_DerivedToBase;
3162 if (Diagnose && !IsCStyleOrFunctionalCast &&
3163 FromPointeeType->
isFunctionType() && ToPointeeType->isVoidType()) {
3164 assert(getLangOpts().MSVCCompat &&
3165 "this should only be possible with MSVCCompat!");
3177 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
3180 Kind = CK_BlockPointerToObjCPointerCast;
3182 Kind = CK_CPointerToObjCPointerCast;
3186 Kind = CK_AnyPointerToBlockPointerCast;
3192 Kind = CK_NullToPointer;
3204 bool InOverloadResolution,
3214 ConvertedType = ToType;
3229 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass)) {
3247 bool IgnoreBaseAccess) {
3254 "Expr must be null pointer constant!");
3255 Kind = CK_NullToMemberPointer;
3260 assert(ToPtrType &&
"No member pointer cast has a target type "
3261 "that is not a member pointer.");
3267 assert(FromClass->
isRecordType() &&
"Pointer into non-class.");
3268 assert(ToClass->
isRecordType() &&
"Pointer into non-class.");
3272 bool DerivationOkay =
3273 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass, Paths);
3274 assert(DerivationOkay &&
3275 "Should not have been called if derivation isn't OK.");
3276 (void)DerivationOkay;
3279 getUnqualifiedType())) {
3280 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3282 << 0 << FromClass << ToClass << PathDisplayStr << From->
getSourceRange();
3286 if (
const RecordType *VBase = Paths.getDetectedVirtual()) {
3288 << FromClass << ToClass <<
QualType(VBase, 0)
3293 if (!IgnoreBaseAccess)
3294 CheckBaseClassAccess(From->
getExprLoc(), FromClass, ToClass,
3296 diag::err_downcast_from_inaccessible_base);
3300 Kind = CK_BaseToDerivedMemberPointer;
3323 bool CStyle,
bool IsTopLevel,
3324 bool &PreviousToQualsIncludeConst,
3325 bool &ObjCLifetimeConversion) {
3337 ObjCLifetimeConversion =
true;
3373 !PreviousToQualsIncludeConst)
3391 PreviousToQualsIncludeConst =
3392 PreviousToQualsIncludeConst && ToQuals.
hasConst();
3405 bool CStyle,
bool &ObjCLifetimeConversion) {
3408 ObjCLifetimeConversion =
false;
3418 bool PreviousToQualsIncludeConst =
true;
3419 bool UnwrappedAnyPointer =
false;
3422 FromType, ToType, CStyle, !UnwrappedAnyPointer,
3423 PreviousToQualsIncludeConst, ObjCLifetimeConversion))
3425 UnwrappedAnyPointer =
true;
3442 bool InOverloadResolution,
3451 InOverloadResolution, InnerSCS,
3468 if (CtorType->getNumParams() > 0) {
3469 QualType FirstArg = CtorType->getParamType(0);
3481 bool AllowExplicit) {
3488 bool Usable = !Info.Constructor->isInvalidDecl() &&
3491 bool SuppressUserConversions =
false;
3492 if (Info.ConstructorTmpl)
3495 CandidateSet, SuppressUserConversions,
3500 CandidateSet, SuppressUserConversions,
3501 false, AllowExplicit);
3505 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3514 QualType ThisType = Constructor->getThisType();
3532 llvm_unreachable(
"Invalid OverloadResult!");
3554 bool AllowObjCConversionOnExplicit) {
3555 assert(AllowExplicit != AllowedExplicit::None ||
3556 !AllowObjCConversionOnExplicit);
3560 bool ConstructorsOnly =
false;
3576 ConstructorsOnly =
true;
3581 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3583 Expr **Args = &From;
3584 unsigned NumArgs = 1;
3585 bool ListInitializing =
false;
3586 if (
InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3589 S, From, ToType, ToRecordDecl, User, CandidateSet,
3590 AllowExplicit == AllowedExplicit::All);
3599 Args = InitList->getInits();
3600 NumArgs = InitList->getNumInits();
3601 ListInitializing =
true;
3609 bool Usable = !Info.Constructor->isInvalidDecl();
3610 if (!ListInitializing)
3611 Usable = Usable && Info.Constructor->isConvertingConstructor(
3614 bool SuppressUserConversions = !ConstructorsOnly;
3622 if (SuppressUserConversions && ListInitializing) {
3623 SuppressUserConversions =
3624 NumArgs == 1 && isa<InitListExpr>(Args[0]) &&
3628 if (Info.ConstructorTmpl)
3630 Info.ConstructorTmpl, Info.FoundDecl,
3632 CandidateSet, SuppressUserConversions,
3634 AllowExplicit == AllowedExplicit::All);
3640 SuppressUserConversions,
3642 AllowExplicit == AllowedExplicit::All);
3649 if (ConstructorsOnly || isa<InitListExpr>(From)) {
3652 }
else if (
const RecordType *FromRecordType =
3655 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3657 const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3658 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3662 if (isa<UsingShadowDecl>(D))
3663 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3667 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3670 Conv = cast<CXXConversionDecl>(D);
3674 ConvTemplate, FoundDecl, ActingContext, From, ToType,
3675 CandidateSet, AllowObjCConversionOnExplicit,
3676 AllowExplicit != AllowedExplicit::None);
3679 CandidateSet, AllowObjCConversionOnExplicit,
3680 AllowExplicit != AllowedExplicit::None);
3685 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3694 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3701 QualType ThisType = Constructor->getThisType();
3702 if (isa<InitListExpr>(From)) {
3706 if (Best->Conversions[0].isEllipsis())
3709 User.
Before = Best->Conversions[0].Standard;
3722 = dyn_cast<CXXConversionDecl>(Best->Function)) {
3729 User.
Before = Best->Conversions[0].Standard;
3744 User.
After = Best->FinalConversion;
3747 llvm_unreachable(
"Not a constructor or conversion function?");
3756 llvm_unreachable(
"Invalid OverloadResult!");
3766 CandidateSet, AllowedExplicit::None,
false);
3780 if (!RequireCompleteType(From->
getBeginLoc(), ToType,
3781 diag::err_typecheck_nonviable_condition_incomplete,
3788 *
this, From, Cands);
3814 if (!Conv1 || !Conv2)
3829 if (Block1 != Block2)
3842 if (Conv1FuncRet && Conv2FuncRet &&
3853 CallOpProto->isVariadic(),
false);
3855 CallOpProto->isVariadic(),
true);
3857 CallingConv PrefOrder[] = {DefaultFree, DefaultMember, CallOpCC};
3952 if (!ICS1.
isBad()) {
3953 bool StdInit1 =
false, StdInit2 =
false;
3960 if (StdInit1 != StdInit2)
3971 CAT2->getElementType())) {
3973 if (CAT1->getSize() != CAT2->getSize())
3975 return CAT1->getSize().ult(CAT2->getSize())
4097 return FixedEnumPromotion::None;
4101 return FixedEnumPromotion::None;
4104 if (!
Enum->isFixed())
4105 return FixedEnumPromotion::None;
4109 return FixedEnumPromotion::ToUnderlyingType;
4111 return FixedEnumPromotion::ToPromotedUnderlyingType;
4140 else if (Rank2 < Rank1)
4163 if (FEP1 != FixedEnumPromotion::None && FEP2 != FixedEnumPromotion::None &&
4165 return FEP1 == FixedEnumPromotion::ToUnderlyingType
4175 bool SCS1ConvertsToVoid
4177 bool SCS2ConvertsToVoid
4179 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
4184 }
else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
4190 }
else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
4219 if (FromObjCPtr1 && FromObjCPtr2) {
4224 if (AssignLeft != AssignRight) {
4259 if (UnqualT1 == UnqualT2) {
4271 if (isa<ArrayType>(T1) && T1Quals)
4273 if (isa<ArrayType>(T2) && T2Quals)
4321 if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
4322 return SCS1IsCompatibleVectorConversion
4329 bool SCS1IsCompatibleSVEVectorConversion =
4331 bool SCS2IsCompatibleSVEVectorConversion =
4334 if (SCS1IsCompatibleSVEVectorConversion !=
4335 SCS2IsCompatibleSVEVectorConversion)
4336 return SCS1IsCompatibleSVEVectorConversion
4343 bool SCS1IsCompatibleRVVVectorConversion =
4345 bool SCS2IsCompatibleRVVVectorConversion =
4348 if (SCS1IsCompatibleRVVVectorConversion !=
4349 SCS2IsCompatibleRVVVectorConversion)
4350 return SCS1IsCompatibleRVVVectorConversion
4391 if (UnqualT1 == UnqualT2)
4409 bool ObjCLifetimeConversion;
4419 if (CanPick1 != CanPick2)
4473 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4481 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4498 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4505 bool FromAssignRight
4514 if (ToPtr1->isObjCIdType() &&
4515 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4517 if (ToPtr2->isObjCIdType() &&
4518 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4523 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4525 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4530 if (ToPtr1->isObjCClassType() &&
4531 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4533 if (ToPtr2->isObjCClassType() &&
4534 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4539 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4541 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4547 (ToAssignLeft != ToAssignRight)) {
4558 }
else if (IsSecondSame)
4567 (FromAssignLeft != FromAssignRight))
4581 const Type *FromPointeeType1 = FromMemPointer1->getClass();
4582 const Type *ToPointeeType1 = ToMemPointer1->
getClass();
4583 const Type *FromPointeeType2 = FromMemPointer2->
getClass();
4584 const Type *ToPointeeType2 = ToMemPointer2->
getClass();
4590 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4597 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4655 "T1 must be the pointee type of the reference type");
4656 assert(!OrigT2->
isReferenceType() &&
"T2 cannot be a reference type");
4680 if (UnqualT1 == UnqualT2) {
4682 }
else if (isCompleteType(Loc, OrigT2) &&
4683 IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4684 Conv |= ReferenceConversions::DerivedToBase;
4688 Conv |= ReferenceConversions::ObjC;
4690 IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2)) {
4691 Conv |= ReferenceConversions::Function;
4693 return Ref_Compatible;
4695 bool ConvertedReferent = Conv != 0;
4699 bool PreviousToQualsIncludeConst =
true;
4700 bool TopLevel =
true;
4706 Conv |= ReferenceConversions::Qualification;
4712 Conv |= ReferenceConversions::NestedQualification;
4720 bool ObjCLifetimeConversion =
false;
4722 PreviousToQualsIncludeConst,
4723 ObjCLifetimeConversion))
4729 if (ObjCLifetimeConversion)
4730 Conv |= ReferenceConversions::ObjCLifetime;
4749 bool AllowExplicit) {
4750 assert(T2->
isRecordType() &&
"Can only find conversions of record types.");
4755 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4756 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4759 if (isa<UsingShadowDecl>(D))
4760 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4763 = dyn_cast<FunctionTemplateDecl>(D);
4768 Conv = cast<CXXConversionDecl>(D);
4780 if (!ConvTemplate &&
4804 ConvTemplate, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4805 false, AllowExplicit);
4808 Conv, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4809 false, AllowExplicit);
4812 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4827 if (!Best->FinalConversion.DirectBinding)
4839 "Expected a direct reference binding!");
4845 Cand != CandidateSet.
end(); ++Cand)
4857 llvm_unreachable(
"Invalid OverloadResult!");
4865 bool SuppressUserConversions,
4866 bool AllowExplicit) {
4867 assert(DeclType->
isReferenceType() &&
"Reference init needs a reference");