35 #include "llvm/ADT/DenseSet.h"
36 #include "llvm/ADT/STLExtras.h"
37 #include "llvm/ADT/SmallPtrSet.h"
38 #include "llvm/ADT/SmallString.h"
39 #include "llvm/Support/Casting.h"
44 using namespace clang;
51 return P->hasAttr<PassObjectSizeAttr>();
72 if (HadMultipleCandidates)
83 CK_FunctionToPointerDecay);
87 bool InOverloadResolution,
90 bool AllowObjCWritebackConversion);
94 bool InOverloadResolution,
102 bool AllowObjCConversionOnExplicit);
165 "Function-to-pointer",
166 "Function pointer conversion",
168 "Integral promotion",
169 "Floating point promotion",
171 "Integral conversion",
172 "Floating conversion",
173 "Complex conversion",
174 "Floating-integral conversion",
175 "Pointer conversion",
176 "Pointer-to-member conversion",
177 "Boolean conversion",
178 "Compatible-types conversion",
179 "Derived-to-base conversion",
181 "SVE Vector conversion",
183 "Complex-real conversion",
184 "Block Pointer conversion",
185 "Transparent Union Conversion",
186 "Writeback conversion",
187 "OpenCL Zero Event Conversion",
188 "C specific type conversion",
189 "Incompatible pointer conversion"
200 DeprecatedStringLiteralToCharPtr =
false;
201 QualificationIncludesObjCLifetime =
false;
202 ReferenceBinding =
false;
203 DirectBinding =
false;
204 IsLvalueReference =
true;
205 BindsToFunctionLvalue =
false;
206 BindsToRvalue =
false;
207 BindsImplicitObjectArgumentWithoutRefQualifier =
false;
208 ObjCLifetimeConversionBinding =
false;
209 CopyConstructor =
nullptr;
236 (getFromType()->isPointerType() ||
237 getFromType()->isMemberPointerType() ||
238 getFromType()->isObjCObjectPointerType() ||
239 getFromType()->isBlockPointerType() ||
272 const Expr *Converted) {
275 if (
auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
282 while (
auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
283 switch (ICE->getCastKind()) {
285 case CK_IntegralCast:
286 case CK_IntegralToBoolean:
287 case CK_IntegralToFloating:
288 case CK_BooleanToSignedIntegral:
289 case CK_FloatingToIntegral:
290 case CK_FloatingToBoolean:
291 case CK_FloatingCast:
292 Converted = ICE->getSubExpr();
316 QualType &ConstantType,
bool IgnoreFloatToIntegralConversion)
const {
317 assert(Ctx.
getLangOpts().CPlusPlus &&
"narrowing check outside C++");
328 ToType = ET->getDecl()->getIntegerType();
334 goto FloatingIntegralConversion;
336 goto IntegralConversion;
347 FloatingIntegralConversion:
352 if (IgnoreFloatToIntegralConversion)
355 assert(
Initializer &&
"Unknown conversion expression");
361 if (std::optional<llvm::APSInt> IntConstantValue =
365 Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
366 llvm::APFloat::rmNearestTiesToEven);
370 Result.convertToInteger(ConvertedValue,
371 llvm::APFloat::rmTowardZero, &ignored);
373 if (*IntConstantValue != ConvertedValue) {
374 ConstantValue =
APValue(*IntConstantValue);
399 if (
Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
401 assert(ConstantValue.
isFloat());
405 llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
407 llvm::APFloat::rmNearestTiesToEven, &ignored);
410 if (ConvertStatus & llvm::APFloat::opOverflow) {
426 IntegralConversion: {
430 const unsigned FromWidth = Ctx.
getIntWidth(FromType);
434 if (FromWidth > ToWidth ||
435 (FromWidth == ToWidth && FromSigned != ToSigned) ||
436 (FromSigned && !ToSigned)) {
444 std::optional<llvm::APSInt> OptInitializerValue;
445 if (!(OptInitializerValue =
Initializer->getIntegerConstantExpr(Ctx))) {
450 bool Narrowing =
false;
451 if (FromWidth < ToWidth) {
454 if (InitializerValue.isSigned() && InitializerValue.isNegative())
459 InitializerValue = InitializerValue.extend(
460 InitializerValue.getBitWidth() + 1);
463 ConvertedValue = ConvertedValue.trunc(ToWidth);
464 ConvertedValue.setIsSigned(ToSigned);
465 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
466 ConvertedValue.setIsSigned(InitializerValue.isSigned());
468 if (ConvertedValue != InitializerValue)
473 ConstantValue =
APValue(InitializerValue);
489 raw_ostream &OS = llvm::errs();
490 bool PrintedSomething =
false;
493 PrintedSomething =
true;
497 if (PrintedSomething) {
502 if (CopyConstructor) {
503 OS <<
" (by copy constructor)";
504 }
else if (DirectBinding) {
505 OS <<
" (direct reference binding)";
506 }
else if (ReferenceBinding) {
507 OS <<
" (reference binding)";
509 PrintedSomething =
true;
513 if (PrintedSomething) {
517 PrintedSomething =
true;
520 if (!PrintedSomething) {
521 OS <<
"No conversions required";
528 raw_ostream &OS = llvm::errs();
529 if (Before.First || Before.Second || Before.Third) {
533 if (ConversionFunction)
534 OS <<
'\'' << *ConversionFunction <<
'\'';
536 OS <<
"aggregate initialization";
546 raw_ostream &OS = llvm::errs();
547 if (hasInitializerListContainerType())
548 OS <<
"Worst list element conversion: ";
549 switch (ConversionKind) {
550 case StandardConversion:
551 OS <<
"Standard conversion: ";
554 case UserDefinedConversion:
555 OS <<
"User-defined conversion: ";
558 case EllipsisConversion:
559 OS <<
"Ellipsis conversion";
561 case AmbiguousConversion:
562 OS <<
"Ambiguous conversion";
565 OS <<
"Bad conversion";
577 conversions().~ConversionSet();
590 struct DFIArguments {
596 struct DFIParamWithArguments : DFIArguments {
601 struct DFIDeducedMismatchArgs : DFIArguments {
603 unsigned CallArgIndex;
620 Result.Result =
static_cast<unsigned>(TDK);
621 Result.HasDiagnostic =
false;
629 Result.Data =
nullptr;
634 Result.Data = Info.
Param.getOpaqueValue();
640 auto *Saved =
new (Context) DFIDeducedMismatchArgs;
651 DFIArguments *Saved =
new (Context) DFIArguments;
663 DFIParamWithArguments *Saved =
new (Context) DFIParamWithArguments;
664 Saved->Param = Info.
Param;
677 Result.HasDiagnostic =
true;
682 CNSInfo *Saved =
new (Context) CNSInfo;
692 llvm_unreachable(
"not a deduction failure");
725 Diag->~PartialDiagnosticAt();
726 HasDiagnostic =
false;
734 Diag->~PartialDiagnosticAt();
735 HasDiagnostic =
false;
770 return TemplateParameter::getFromOpaqueValue(Data);
775 return static_cast<DFIParamWithArguments*
>(Data)->Param;
805 return static_cast<DFIDeducedMismatchArgs*
>(Data)->TemplateArgs;
811 return static_cast<CNSInfo*
>(Data)->TemplateArgs;
843 return &
static_cast<DFIArguments*
>(Data)->FirstArg;
875 return &
static_cast<DFIArguments*
>(Data)->SecondArg;
890 return static_cast<DFIDeducedMismatchArgs*
>(Data)->CallArgIndex;
903 for (
unsigned I = 0; I <
X->getNumParams(); ++I)
907 if (
auto *FTX =
X->getDescribedFunctionTemplate()) {
912 FTY->getTemplateParameters()))
921 OverloadedOperatorKind::OO_EqualEqual);
933 OverloadedOperatorKind::OO_ExclaimEqual);
934 if (isa<CXXMethodDecl>(EqFD)) {
941 Sema::LookupNameKind::LookupMemberName);
951 Sema::LookupNameKind::LookupOperatorName);
956 auto *FD = Op->getAsFunction();
957 if(
auto* UD = dyn_cast<UsingShadowDecl>(Op))
958 FD = UD->getUnderlyingDecl()->getAsFunction();
961 cast<Decl>(Op->getDeclContext())))
969 if (!AllowRewrittenCandidates)
971 return Op == OO_EqualEqual || Op == OO_Spaceship;
977 if (!allowsReversed(Op))
979 if (Op == OverloadedOperatorKind::OO_EqualEqual) {
980 assert(OriginalArgs.size() == 2);
982 S, OpLoc, OriginalArgs[1], FD))
993 void OverloadCandidateSet::destroyCandidates() {
994 for (
iterator i = begin(), e = end(); i != e; ++i) {
995 for (
auto &C : i->Conversions)
996 C.~ImplicitConversionSequence();
998 i->DeductionFailure.Destroy();
1003 destroyCandidates();
1004 SlabAllocator.Reset();
1005 NumInlineBytesUsed = 0;
1012 class UnbridgedCastsSet {
1022 Entry entry = { &E, E };
1023 Entries.push_back(entry);
1029 i = Entries.begin(), e = Entries.end(); i != e; ++i)
1030 *i->Addr = i->Saved;
1044 UnbridgedCastsSet *unbridgedCasts =
nullptr) {
1048 if (placeholder->getKind() == BuiltinType::Overload)
return false;
1052 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
1054 unbridgedCasts->save(S, E);
1074 UnbridgedCastsSet &unbridged) {
1075 for (
unsigned i = 0, e = Args.size(); i != e; ++i)
1117 NamedDecl *&Match,
bool NewIsUsingDecl) {
1122 bool OldIsUsingDecl =
false;
1123 if (isa<UsingShadowDecl>(OldD)) {
1124 OldIsUsingDecl =
true;
1128 if (NewIsUsingDecl)
continue;
1130 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
1135 if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
1143 bool UseMemberUsingDeclRules =
1144 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
1148 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
1149 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
1150 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
1154 if (!isa<FunctionTemplateDecl>(OldD) &&
1155 !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)))
1293 bool SameTemplateParameterList = TemplateParameterListsAreEqual(
1301 bool ConstraintsInTemplateHead =
1312 if (UseMemberUsingDeclRules && ConstraintsInTemplateHead &&
1313 !SameTemplateParameterList)
1315 if (!UseMemberUsingDeclRules &&
1316 (!SameTemplateParameterList || !SameReturnType))
1320 if (ConsiderRequiresClauses) {
1323 if ((NewRC !=
nullptr) != (OldRC !=
nullptr))
1326 if (NewRC && !AreConstraintExpressionsEqual(Old, OldRC, New, NewRC))
1340 if (OldMethod && NewMethod &&
1343 if (!UseMemberUsingDeclRules &&
1367 !isa<CXXConstructorDecl>(NewMethod))
1370 OldQuals.removeRestrict();
1371 NewQuals.removeRestrict();
1372 if (OldQuals != NewQuals)
1390 NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1391 if (NewI == NewE || OldI == OldE)
1393 llvm::FoldingSetNodeID NewID, OldID;
1394 NewI->getCond()->Profile(NewID, Context,
true);
1395 OldI->getCond()->Profile(OldID, Context,
true);
1400 if (getLangOpts().
CUDA && ConsiderCudaAttrs) {
1403 if (!isa<CXXDestructorDecl>(New)) {
1405 OldTarget = IdentifyCUDATarget(Old);
1406 if (NewTarget != CFT_InvalidTarget) {
1407 assert((OldTarget != CFT_InvalidTarget) &&
1408 "Unexpected invalid target.");
1412 if (NewTarget != OldTarget)
1428 bool SuppressUserConversions,
1430 bool InOverloadResolution,
1432 bool AllowObjCWritebackConversion,
1433 bool AllowObjCConversionOnExplicit) {
1436 if (SuppressUserConversions) {
1447 Conversions, AllowExplicit,
1448 AllowObjCConversionOnExplicit)) {
1465 if (Constructor->isCopyConstructor() &&
1466 (FromCanon == ToCanon ||
1477 if (ToCanon != FromCanon)
1488 Cand != Conversions.
end(); ++Cand)
1531 bool SuppressUserConversions,
1533 bool InOverloadResolution,
1535 bool AllowObjCWritebackConversion,
1536 bool AllowObjCConversionOnExplicit) {
1539 ICS.
Standard, CStyle, AllowObjCWritebackConversion)){
1579 AllowExplicit, InOverloadResolution, CStyle,
1580 AllowObjCWritebackConversion,
1581 AllowObjCConversionOnExplicit);
1586 bool SuppressUserConversions,
1588 bool InOverloadResolution,
1590 bool AllowObjCWritebackConversion) {
1592 AllowExplicit, InOverloadResolution, CStyle,
1593 AllowObjCWritebackConversion,
1604 bool AllowExplicit) {
1609 bool AllowObjCWritebackConversion
1610 = getLangOpts().ObjCAutoRefCount &&
1611 (Action == AA_Passing || Action == AA_Sending);
1612 if (getLangOpts().ObjC)
1613 CheckObjCBridgeRelatedConversions(From->
getBeginLoc(), ToType,
1616 *
this, From, ToType,
1620 false, AllowObjCWritebackConversion,
1622 return PerformImplicitConversion(From, ToType, ICS, Action);
1643 if (TyClass != CanFrom->getTypeClass())
return false;
1644 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1645 if (TyClass == Type::Pointer) {
1648 }
else if (TyClass == Type::BlockPointer) {
1651 }
else if (TyClass == Type::MemberPointer) {
1655 if (ToMPT->getClass() != FromMPT->
getClass())
1657 CanTo = ToMPT->getPointeeType();
1663 TyClass = CanTo->getTypeClass();
1664 if (TyClass != CanFrom->getTypeClass())
return false;
1665 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1669 const auto *FromFn = cast<FunctionType>(CanFrom);
1672 const auto *ToFn = cast<FunctionType>(CanTo);
1675 bool Changed =
false;
1684 if (
const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1685 const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1686 if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1687 FromFn = cast<FunctionType>(
1698 bool CanUseToFPT, CanUseFromFPT;
1700 CanUseFromFPT, NewParamInfos) &&
1701 CanUseToFPT && !CanUseFromFPT) {
1704 NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1706 FromFPT->getParamTypes(), ExtInfo);
1715 assert(
QualType(FromFn, 0).isCanonical());
1716 if (
QualType(FromFn, 0) != CanTo)
return false;
1729 bool InOverloadResolution,
bool CStyle) {
1770 !ToType->
hasAttr(attr::ArmMveStrictPolymorphism))) {
1774 !InOverloadResolution && !CStyle) {
1776 << FromType << ToType;
1787 bool InOverloadResolution,
1800 bool InOverloadResolution,
1803 bool AllowObjCWritebackConversion) {
1850 if (Method && !Method->
isStatic()) {
1852 "Non-unary operator on non-static member address");
1853 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode()
1855 "Non-address-of operator on non-static member address");
1856 const Type *ClassType
1860 assert(cast<UnaryOperator>(From->
IgnoreParens())->getOpcode() ==
1862 "Non-address-of operator for overloaded function expression");
1882 FromType = Atomic->getValueType();
1917 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
1937 bool IncompatibleObjC =
false;
1988 const llvm::fltSemantics &FromSem =
1991 if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
1992 &ToSem == &llvm::APFloat::IEEEquad()) ||
1993 (&FromSem == &llvm::APFloat::IEEEquad() &&
1994 &ToSem == &llvm::APFloat::PPCDoubleDouble()))
2013 }
else if (AllowObjCWritebackConversion &&
2017 FromType, IncompatibleObjC)) {
2023 InOverloadResolution, FromType)) {
2027 InOverloadResolution, CStyle)) {
2036 InOverloadResolution,
2067 bool ObjCLifetimeConversion;
2073 ObjCLifetimeConversion)) {
2092 CanonFrom = CanonTo;
2097 if (CanonFrom == CanonTo)
2102 if (S.
getLangOpts().CPlusPlus || !InOverloadResolution)
2146 bool InOverloadResolution,
2156 for (
const auto *it : UD->
fields()) {
2159 ToType = it->getType();
2189 return To->
getKind() == BuiltinType::Int;
2192 return To->
getKind() == BuiltinType::UInt;
2216 if (FromEnumType->getDecl()->isScoped())
2223 if (FromEnumType->getDecl()->isFixed()) {
2224 QualType Underlying = FromEnumType->getDecl()->getIntegerType();
2226 IsIntegralPromotion(
nullptr, Underlying, ToType);
2233 ToType, FromEnumType->getDecl()->getPromotionType());
2267 for (
int Idx = 0; Idx < 6; ++Idx) {
2269 if (FromSize < ToSize ||
2270 (FromSize == ToSize &&
2271 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2296 std::optional<llvm::APSInt> BitWidth;
2299 MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
2300 llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
2304 if (*BitWidth < ToSize ||
2306 return To->
getKind() == BuiltinType::Int;
2312 return To->
getKind() == BuiltinType::UInt;
2338 ToBuiltin->getKind() == BuiltinType::Double)
2346 FromBuiltin->getKind() == BuiltinType::Double) &&
2347 (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2348 ToBuiltin->getKind() == BuiltinType::Float128 ||
2349 ToBuiltin->getKind() == BuiltinType::Ibm128))
2353 if (!getLangOpts().NativeHalfType &&
2354 FromBuiltin->getKind() == BuiltinType::Half &&
2392 bool StripObjCLifetime =
false) {
2395 "Invalid similarly-qualified pointer type");
2406 if (StripObjCLifetime)
2417 if (isa<ObjCObjectPointerType>(ToType))
2426 if (isa<ObjCObjectPointerType>(ToType))
2432 bool InOverloadResolution,
2438 return !InOverloadResolution;
2462 bool InOverloadResolution,
2464 bool &IncompatibleObjC) {
2465 IncompatibleObjC =
false;
2466 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2473 ConvertedType = ToType;
2480 ConvertedType = ToType;
2487 ConvertedType = ToType;
2495 ConvertedType = ToType;
2505 ConvertedType = ToType;
2513 !getLangOpts().ObjCAutoRefCount) {
2543 if (getLangOpts().MSVCCompat && FromPointeeType->
isFunctionType() &&
2577 IsDerivedFrom(From->
getBeginLoc(), FromPointeeType, ToPointeeType)) {
2614 bool &IncompatibleObjC) {
2615 if (!getLangOpts().ObjC)
2627 if (ToObjCPtr && FromObjCPtr) {
2638 if (getLangOpts().CPlusPlus && LHS && RHS &&
2640 FromObjCPtr->getPointeeType()))
2645 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2653 IncompatibleObjC =
true;
2657 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2669 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2697 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2698 IncompatibleObjC)) {
2700 IncompatibleObjC =
true;
2702 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2709 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2710 IncompatibleObjC)) {
2713 ConvertedType =
AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2725 if (FromFunctionType && ToFunctionType) {
2734 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
2735 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic() ||
2736 FromFunctionType->
getMethodQuals() != ToFunctionType->getMethodQuals())
2739 bool HasObjCConversion =
false;
2743 }
else if (isObjCPointerConversion(FromFunctionType->
getReturnType(),
2744 ToFunctionType->getReturnType(),
2745 ConvertedType, IncompatibleObjC)) {
2747 HasObjCConversion =
true;
2754 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
2755 ArgIdx != NumArgs; ++ArgIdx) {
2757 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2761 }
else if (isObjCPointerConversion(FromArgType, ToArgType,
2762 ConvertedType, IncompatibleObjC)) {
2764 HasObjCConversion =
true;
2771 if (HasObjCConversion) {
2775 IncompatibleObjC =
true;
2794 if (!getLangOpts().ObjCAutoRefCount ||
2836 bool IncompatibleObjC;
2838 FromPointee = ToPointee;
2839 else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2874 if (!FromFunctionType || !ToFunctionType)
2877 if (Context.
hasSameType(FromPointeeType, ToPointeeType))
2882 if (FromFunctionType->
getNumParams() != ToFunctionType->getNumParams() ||
2883 FromFunctionType->
isVariadic() != ToFunctionType->isVariadic())
2888 if (FromEInfo != ToEInfo)
2891 bool IncompatibleObjC =
false;
2893 ToFunctionType->getReturnType())) {
2897 QualType LHS = ToFunctionType->getReturnType();
2898 if ((!getLangOpts().CPlusPlus || !RHS->
isRecordType()) &&
2904 }
else if (isObjCPointerConversion(RHS, LHS,
2905 ConvertedType, IncompatibleObjC)) {
2906 if (IncompatibleObjC)
2915 for (
unsigned ArgIdx = 0, NumArgs = FromFunctionType->
getNumParams();
2916 ArgIdx != NumArgs; ++ArgIdx) {
2917 IncompatibleObjC =
false;
2919 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2920 if (Context.
hasSameType(FromArgType, ToArgType)) {
2922 }
else if (isObjCPointerConversion(ToArgType, FromArgType,
2923 ConvertedType, IncompatibleObjC)) {
2924 if (IncompatibleObjC)
2933 bool CanUseToFPT, CanUseFromFPT;
2935 CanUseToFPT, CanUseFromFPT,
2939 ConvertedType = ToType;
2980 if (!Context.
hasSameType(FromMember->getClass(), ToMember->getClass())) {
2982 <<
QualType(FromMember->getClass(), 0);
3015 if (!FromFunction || !ToFunction) {
3020 if (FromFunction->
getNumParams() != ToFunction->getNumParams()) {
3028 if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
3030 << ToFunction->getParamType(ArgPos)
3037 ToFunction->getReturnType())) {
3043 if (FromFunction->
getMethodQuals() != ToFunction->getMethodQuals()) {
3053 cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
3072 unsigned *ArgPos,
bool Reversed) {
3074 "Can't compare parameters of functions with different number of "
3103 bool IgnoreBaseAccess,
3106 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
3110 if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->
isAnyPointerType() &&
3114 DiagRuntimeBehavior(From->
getExprLoc(), From,
3115 PDiag(diag::warn_impcast_bool_to_null_pointer)
3117 else if (!isUnevaluatedContext())
3126 if (FromPointeeType->
isRecordType() && ToPointeeType->isRecordType() &&
3130 unsigned InaccessibleID = 0;
3131 unsigned AmbiguousID = 0;
3133 InaccessibleID = diag::err_upcast_to_inaccessible_base;
3134 AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
3136 if (CheckDerivedToBaseConversion(
3137 FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
3139 &BasePath, IgnoreBaseAccess))
3143 Kind = CK_DerivedToBase;
3146 if (Diagnose && !IsCStyleOrFunctionalCast &&
3147 FromPointeeType->
isFunctionType() && ToPointeeType->isVoidType()) {
3148 assert(getLangOpts().MSVCCompat &&
3149 "this should only be possible with MSVCCompat!");
3161 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
3164 Kind = CK_BlockPointerToObjCPointerCast;
3166 Kind = CK_CPointerToObjCPointerCast;
3170 Kind = CK_AnyPointerToBlockPointerCast;
3176 Kind = CK_NullToPointer;
3188 bool InOverloadResolution,
3198 ConvertedType = ToType;
3213 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass)) {
3231 bool IgnoreBaseAccess) {
3238 "Expr must be null pointer constant!");
3239 Kind = CK_NullToMemberPointer;
3244 assert(ToPtrType &&
"No member pointer cast has a target type "
3245 "that is not a member pointer.");
3251 assert(FromClass->
isRecordType() &&
"Pointer into non-class.");
3252 assert(ToClass->
isRecordType() &&
"Pointer into non-class.");
3256 bool DerivationOkay =
3257 IsDerivedFrom(From->
getBeginLoc(), ToClass, FromClass, Paths);
3258 assert(DerivationOkay &&
3259 "Should not have been called if derivation isn't OK.");
3260 (void)DerivationOkay;
3263 getUnqualifiedType())) {
3264 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3266 << 0 << FromClass << ToClass << PathDisplayStr << From->
getSourceRange();
3270 if (
const RecordType *VBase = Paths.getDetectedVirtual()) {
3272 << FromClass << ToClass <<
QualType(VBase, 0)
3277 if (!IgnoreBaseAccess)
3278 CheckBaseClassAccess(From->
getExprLoc(), FromClass, ToClass,
3280 diag::err_downcast_from_inaccessible_base);
3284 Kind = CK_BaseToDerivedMemberPointer;
3307 bool CStyle,
bool IsTopLevel,
3308 bool &PreviousToQualsIncludeConst,
3309 bool &ObjCLifetimeConversion) {
3321 ObjCLifetimeConversion =
true;
3357 !PreviousToQualsIncludeConst)
3375 PreviousToQualsIncludeConst =
3376 PreviousToQualsIncludeConst && ToQuals.
hasConst();
3389 bool CStyle,
bool &ObjCLifetimeConversion) {
3392 ObjCLifetimeConversion =
false;
3402 bool PreviousToQualsIncludeConst =
true;
3403 bool UnwrappedAnyPointer =
false;
3406 FromType, ToType, CStyle, !UnwrappedAnyPointer,
3407 PreviousToQualsIncludeConst, ObjCLifetimeConversion))
3409 UnwrappedAnyPointer =
true;
3426 bool InOverloadResolution,
3435 InOverloadResolution, InnerSCS,
3452 if (CtorType->getNumParams() > 0) {
3453 QualType FirstArg = CtorType->getParamType(0);
3465 bool AllowExplicit) {
3472 bool Usable = !Info.Constructor->isInvalidDecl() &&
3475 bool SuppressUserConversions =
false;
3476 if (Info.ConstructorTmpl)
3479 CandidateSet, SuppressUserConversions,
3484 CandidateSet, SuppressUserConversions,
3485 false, AllowExplicit);
3489 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3492 switch (
auto Result =
3498 QualType ThisType = Constructor->getThisType();
3516 llvm_unreachable(
"Invalid OverloadResult!");
3538 bool AllowObjCConversionOnExplicit) {
3539 assert(AllowExplicit != AllowedExplicit::None ||
3540 !AllowObjCConversionOnExplicit);
3544 bool ConstructorsOnly =
false;
3560 ConstructorsOnly =
true;
3565 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3567 Expr **Args = &From;
3568 unsigned NumArgs = 1;
3569 bool ListInitializing =
false;
3570 if (
InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3573 S, From, ToType, ToRecordDecl, User, CandidateSet,
3583 Args = InitList->getInits();
3584 NumArgs = InitList->getNumInits();
3585 ListInitializing =
true;
3593 bool Usable = !Info.Constructor->isInvalidDecl();
3594 if (!ListInitializing)
3595 Usable = Usable && Info.Constructor->isConvertingConstructor(
3598 bool SuppressUserConversions = !ConstructorsOnly;
3606 if (SuppressUserConversions && ListInitializing) {
3607 SuppressUserConversions =
3608 NumArgs == 1 && isa<InitListExpr>(Args[0]) &&
3612 if (Info.ConstructorTmpl)
3614 Info.ConstructorTmpl, Info.FoundDecl,
3616 CandidateSet, SuppressUserConversions,
3624 SuppressUserConversions,
3633 if (ConstructorsOnly || isa<InitListExpr>(From)) {
3636 }
else if (
const RecordType *FromRecordType =
3639 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3641 const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3642 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3646 if (isa<UsingShadowDecl>(D))
3647 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3651 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3654 Conv = cast<CXXConversionDecl>(D);
3658 ConvTemplate, FoundDecl, ActingContext, From, ToType,
3659 CandidateSet, AllowObjCConversionOnExplicit,
3660 AllowExplicit != AllowedExplicit::None);
3663 CandidateSet, AllowObjCConversionOnExplicit,
3664 AllowExplicit != AllowedExplicit::None);
3669 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
3672 switch (
auto Result =
3678 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3685 QualType ThisType = Constructor->getThisType();
3686 if (isa<InitListExpr>(From)) {
3690 if (Best->Conversions[0].isEllipsis())
3693 User.
Before = Best->Conversions[0].Standard;
3706 = dyn_cast<CXXConversionDecl>(Best->Function)) {
3713 User.
Before = Best->Conversions[0].Standard;
3728 User.
After = Best->FinalConversion;
3731 llvm_unreachable(
"Not a constructor or conversion function?");
3740 llvm_unreachable(
"Invalid OverloadResult!");
3765 diag::err_typecheck_nonviable_condition_incomplete,
3772 *
this, From, Cands);
3798 if (!Conv1 || !Conv2)
3813 if (Block1 != Block2)
3826 if (Conv1FuncRet && Conv2FuncRet &&
3837 CallOpProto->isVariadic(),
false);
3839 CallOpProto->isVariadic(),
true);
3841 CallingConv PrefOrder[] = {DefaultFree, DefaultMember, CallOpCC};
3936 if (!ICS1.
isBad()) {
3937 bool StdInit1 =
false, StdInit2 =
false;
3944 if (StdInit1 != StdInit2)
3955 CAT2->getElementType())) {
3957 if (CAT1->getSize() != CAT2->getSize())
3959 return CAT1->getSize().ult(CAT2->getSize())
4088 if (!Enum->isFixed())
4091 QualType UnderlyingType = Enum->getIntegerType();
4124 else if (Rank2 < Rank1)
4159 bool SCS1ConvertsToVoid
4161 bool SCS2ConvertsToVoid
4163 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
4168 }
else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
4174 }
else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
4203 if (FromObjCPtr1 && FromObjCPtr2) {
4208 if (AssignLeft != AssignRight) {
4243 if (UnqualT1 == UnqualT2) {
4255 if (isa<ArrayType>(T1) && T1Quals)
4257 if (isa<ArrayType>(T2) && T2Quals)
4305 if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
4306 return SCS1IsCompatibleVectorConversion
4313 bool SCS1IsCompatibleSVEVectorConversion =
4315 bool SCS2IsCompatibleSVEVectorConversion =
4318 if (SCS1IsCompatibleSVEVectorConversion !=
4319 SCS2IsCompatibleSVEVectorConversion)
4320 return SCS1IsCompatibleSVEVectorConversion
4361 if (UnqualT1 == UnqualT2)
4379 bool ObjCLifetimeConversion;
4389 if (CanPick1 != CanPick2)
4443 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4451 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4468 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4475 bool FromAssignRight
4484 if (ToPtr1->isObjCIdType() &&
4485 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4487 if (ToPtr2->isObjCIdType() &&
4488 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4493 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4495 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4500 if (ToPtr1->isObjCClassType() &&
4501 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4503 if (ToPtr2->isObjCClassType() &&
4504 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4509 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4511 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4517 (ToAssignLeft != ToAssignRight)) {
4528 }
else if (IsSecondSame)
4537 (FromAssignLeft != FromAssignRight))
4551 const Type *FromPointeeType1 = FromMemPointer1->getClass();
4552 const Type *ToPointeeType1 = ToMemPointer1->
getClass();
4553 const Type *FromPointeeType2 = FromMemPointer2->
getClass();
4554 const Type *ToPointeeType2 = ToMemPointer2->
getClass();
4560 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4567 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4625 "T1 must be the pointee type of the reference type");
4626 assert(!OrigT2->
isReferenceType() &&
"T2 cannot be a reference type");
4650 if (UnqualT1 == UnqualT2) {
4654 Conv |= ReferenceConversions::DerivedToBase;
4661 Conv |= ReferenceConversions::Function;
4665 bool ConvertedReferent = Conv != 0;
4669 bool PreviousToQualsIncludeConst =
true;
4670 bool TopLevel =
true;
4676 Conv |= ReferenceConversions::Qualification;
4682 Conv |= ReferenceConversions::NestedQualification;
4690 bool ObjCLifetimeConversion =
false;
4692 PreviousToQualsIncludeConst,
4693 ObjCLifetimeConversion))
4699 if (ObjCLifetimeConversion)
4700 Conv |= ReferenceConversions::ObjCLifetime;
4719 bool AllowExplicit) {
4720 assert(T2->
isRecordType() &&
"Can only find conversions of record types.");
4725 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4726 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4729 if (isa<UsingShadowDecl>(D))
4730 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4733 = dyn_cast<FunctionTemplateDecl>(D);
4738 Conv = cast<CXXConversionDecl>(D);
4750 if (!ConvTemplate &&
4774 ConvTemplate, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4775 false, AllowExplicit);
4778 Conv, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4779 false, AllowExplicit);
4782 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4797 if (!Best->FinalConversion.DirectBinding)
4809 "Expected a direct reference binding!");
4815 Cand != CandidateSet.
end(); ++Cand)
4827 llvm_unreachable(
"Invalid OverloadResult!");
4835 bool SuppressUserConversions,
4836 bool AllowExplicit) {
4837 assert(DeclType->
isReferenceType() &&
"Reference init needs a reference");
4864 auto SetAsReferenceBinding = [&](
bool BindsDirectly) {
4869 ICS.
Standard.
Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
4878 Sema::ReferenceConversions::NestedQualification)
4892 (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
4915 SetAsReferenceBinding(
true);
4964 SetAsReferenceBinding(S.
getLangOpts().CPlusPlus11 ||
5039 Init->Classify(S.
Context).isLValue()) {
5055 AllowedExplicit::None,
5080 if (isRValRef && LValRefType) {
5098 bool SuppressUserConversions,
5099 bool InOverloadResolution,
5100 bool AllowObjCWritebackConversion,
5101 bool AllowExplicit =
false);
5107 bool SuppressUserConversions,
5108 bool InOverloadResolution,
5109 bool AllowObjCWritebackConversion) {
5122 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
5124 InitTy = IAT->getElementType();
5144 SuppressUserConversions,
5145 InOverloadResolution,
5146 AllowObjCWritebackConversion);
5154 Result.setStandard();
5155 Result.Standard.setAsIdentityConversion();
5156 Result.Standard.setFromType(ToType);
5157 Result.Standard.setAllToTypes(ToType);
5182 bool IsUnbounded =
false;
5186 if (CT->getSize().ult(e)) {
5190 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5193 if (CT->getSize().ugt(e)) {
5199 S, &EmptyList, InitTy, SuppressUserConversions,
5200 InOverloadResolution, AllowObjCWritebackConversion);
5201 if (DfltElt.
isBad()) {
5205 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5210 assert(isa<IncompleteArrayType>(AT) &&
"Expected incomplete array");
5216 Result.setInitializerListContainerType(ContTy, IsUnbounded);
5225 Result.setStandard();
5226 Result.Standard.setAsIdentityConversion();
5227 Result.Standard.setFromType(InitTy);
5228 Result.Standard.setAllToTypes(InitTy);
5229 for (
unsigned i = 0; i < e; ++i) {
5232 S, Init, InitTy, SuppressUserConversions, InOverloadResolution,
5233 AllowObjCWritebackConversion);