Lines Matching refs:ToType
83 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
90 QualType &ToType,
95 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
249 QualType ToType = getToType(1);
258 if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
317 QualType ToType = getToType(1);
322 if (auto *ET = ToType->getAs<EnumType>())
323 ToType = ET->getDecl()->getIntegerType();
343 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
346 ToType->isRealFloatingType()) {
359 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
385 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
386 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
387 // FromType is larger than ToType.
401 Ctx.getFloatTypeSemantics(ToType),
423 assert(ToType->isIntegralOrUnscopedEnumerationType());
426 const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
427 const unsigned ToWidth = Ctx.getIntWidth(ToType);
432 // Not all values of FromType can be represented in ToType.
1314 /// Tries a user-defined conversion from From to ToType.
1319 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1331 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1338 switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1356 = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1366 ICS.Standard.setAllToTypes(ToType);
1378 ICS.Ambiguous.setToType(ToType);
1387 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1395 /// from the given expression (Expr) to the given type (ToType). This
1422 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1430 if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1437 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1449 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1450 (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1451 S.IsDerivedFrom(From->getBeginLoc(), FromType, ToType))) {
1455 ICS.Standard.setAllToTypes(ToType);
1464 if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1470 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1477 Sema::TryImplicitConversion(Expr *From, QualType ToType,
1483 return ::TryImplicitConversion(*this, From, ToType, SuppressUserConversions,
1490 /// expression From to the type ToType. Returns the
1495 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1498 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1502 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1513 CheckObjCBridgeRelatedConversions(From->getBeginLoc(), ToType,
1515 ICS = ::TryImplicitConversion(*this, From, ToType,
1522 return PerformImplicitConversion(From, ToType, ICS, Action);
1525 /// Determine whether the conversion from FromType to ToType is a valid
1528 bool Sema::IsFunctionConversion(QualType FromType, QualType ToType,
1530 if (Context.hasSameUnqualifiedType(FromType, ToType))
1540 CanQualType CanTo = Context.getCanonicalType(ToType);
1618 ResultTy = ToType;
1622 /// Determine whether the conversion from FromType to ToType is a valid
1628 QualType ToType, ImplicitConversionKind &ICK) {
1631 if (!ToType->isVectorType() && !FromType->isVectorType())
1635 if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1639 if (ToType->isExtVectorType()) {
1659 if (ToType->isVectorType() && FromType->isVectorType()) {
1660 if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1661 (S.isLaxVectorConversion(FromType, ToType) &&
1662 !ToType->hasAttr(attr::ArmMveStrictPolymorphism))) {
1671 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1678 /// expression From to the type ToType. Standard conversion sequences
1684 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1700 (FromType->isRecordType() || ToType->isRecordType()))
1710 = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1717 // we can sometimes resolve &foo<int> regardless of ToType, so check
1720 S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1724 S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1726 if (!ToType->isBooleanType())
1790 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1831 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1835 } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1838 FromType = ToType.getUnqualifiedType();
1839 } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1842 FromType = ToType.getUnqualifiedType();
1843 } else if (S.IsComplexPromotion(FromType, ToType)) {
1846 FromType = ToType.getUnqualifiedType();
1847 } else if (ToType->isBooleanType() &&
1856 ToType->isIntegralType(S.Context)) {
1859 FromType = ToType.getUnqualifiedType();
1860 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1863 FromType = ToType.getUnqualifiedType();
1864 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1865 (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1868 FromType = ToType.getUnqualifiedType();
1869 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1875 if (FromType == S.Context.BFloat16Ty || ToType == S.Context.BFloat16Ty)
1878 &S.Context.getFloatTypeSemantics(ToType)) {
1880 ToType == S.Context.LongDoubleTy) ||
1882 ToType == S.Context.Float128Ty));
1890 FromType = ToType.getUnqualifiedType();
1892 ToType->isIntegralType(S.Context)) ||
1894 ToType->isRealFloatingType())) {
1896 if (FromType->isBFloat16Type() || ToType->isBFloat16Type())
1901 FromType = ToType.getUnqualifiedType();
1902 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1905 S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1907 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1913 } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1917 } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1919 FromType = ToType.getUnqualifiedType();
1921 S.Context.typesAreCompatible(ToType, FromType)) {
1924 FromType = ToType.getUnqualifiedType();
1925 } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1929 FromType = ToType;
1930 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1935 } else if (ToType->isEventT() &&
1939 FromType = ToType;
1940 } else if (ToType->isQueueT() &&
1944 FromType = ToType;
1945 } else if (ToType->isSamplerT() &&
1948 FromType = ToType;
1958 if (S.IsFunctionConversion(FromType, ToType, FromType)) {
1962 } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
1966 FromType = ToType;
1977 QualType CanonTo = S.Context.getCanonicalType(ToType);
1981 FromType = ToType;
1997 S.CheckSingleAssignmentConstraints(ToType, ER,
2022 SCS.setToType(1, ToType);
2029 SCS.setToType(2, ToType);
2035 QualType &ToType,
2040 const RecordType *UT = ToType->getAsUnionType();
2049 ToType = it->getType();
2058 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
2060 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
2061 const BuiltinType *To = ToType->getAs<BuiltinType>();
2078 Context.getTypeSize(FromType) < Context.getTypeSize(ToType))) {
2115 return Context.hasSameUnqualifiedType(Underlying, ToType) ||
2116 IsIntegralPromotion(nullptr, Underlying, ToType);
2120 if (ToType->isIntegerType() &&
2123 ToType, FromEnumType->getDecl()->getPromotionType());
2144 ToType->isIntegerType()) {
2165 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
2190 ToSize = Context.getTypeSize(ToType);
2219 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
2221 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
2223 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
2255 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
2260 const ComplexType *ToComplex = ToType->getAs<ComplexType>();
2272 /// same type qualifiers as FromPtr has on its pointee type. ToType,
2273 /// if non-empty, will be a pointer to ToType that may or may not have
2278 QualType ToPointee, QualType ToType,
2286 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
2287 return ToType.getUnqualifiedType();
2299 // ToType is exactly what we need. Return it.
2300 if (!ToType.isNull())
2301 return ToType.getUnqualifiedType();
2305 if (isa<ObjCObjectPointerType>(ToType))
2314 if (isa<ObjCObjectPointerType>(ToType))
2335 /// can be converted to the type ToType via a pointer conversion (C++
2337 /// might differ from ToType in its cv-qualifiers at some level) into
2349 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2354 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2359 if (ToType->isObjCObjectPointerType() &&
2361 ConvertedType = ToType;
2366 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2367 ToType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
2368 ConvertedType = ToType;
2373 if (ToType->isBlockPointerType() &&
2375 ConvertedType = ToType;
2381 if (ToType->isNullPtrType() &&
2383 ConvertedType = ToType;
2387 const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2393 ConvertedType = ToType;
2405 ToType, Context);
2426 ToType, Context,
2436 ToType, Context);
2446 ToType, Context);
2469 ToType, Context);
2477 ToType, Context);
2501 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2512 ToType->getAs<ObjCObjectPointerType>();
2533 ToType, Context);
2545 ToType, Context);
2552 if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2555 ToType->getAs<BlockPointerType>()) {
2559 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2568 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2663 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2677 /// \param ToType The type we're converting to.
2681 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2684 Context.hasSameUnqualifiedType(FromType, ToType))
2689 if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2739 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2743 ToType->getAs<BlockPointerType>())
2828 ConvertedType = ToType;
2858 QualType FromType, QualType ToType) {
2860 if (FromType.isNull() || ToType.isNull()) {
2866 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2868 *ToMember = ToType->castAs<MemberPointerType>();
2875 ToType = ToMember->getPointeeType();
2880 if (ToType->isPointerType())
2881 ToType = ToType->getPointeeType();
2885 ToType = ToType.getNonReferenceType();
2895 if (Context.hasSameType(FromType, ToType)) {
2901 *ToFunction = tryGetFunctionProtoType(ToType);
2978 /// expression From to the type ToType. This routine checks for
2983 bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2999 << ToType << From->getSourceRange());
3002 << ToType << From->getSourceRange();
3004 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
3038 ToType->getAs<ObjCObjectPointerType>()) {
3051 } else if (ToType->isBlockPointerType()) {
3066 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
3068 /// ToType in its cv-qualifiers at some level) into ConvertedType.
3070 QualType ToType,
3073 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
3081 ConvertedType = ToType;
3106 /// expression From to the type ToType. This routine checks for ambiguous or
3111 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
3126 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
3187 /// FromType and \p ToType is permissible, given knowledge about whether every
3189 static bool isQualificationConversionStep(QualType FromType, QualType ToType,
3194 Qualifiers ToQuals = ToType.getQualifiers();
3197 if (ToType.getUnqualifiedType()->isVoidType())
3252 /// an rvalue of type FromType to ToType is a qualification conversion
3259 Sema::IsQualificationConversion(QualType FromType, QualType ToType,
3262 ToType = Context.getCanonicalType(ToType);
3265 // If FromType and ToType are the same type, this is not a
3267 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
3275 while (Context.UnwrapSimilarTypes(FromType, ToType)) {
3277 FromType, ToType, CStyle, !UnwrappedAnyPointer,
3283 // We are left with FromType and ToType being the pointee types
3284 // after unwrapping the original FromType and ToType the same number
3286 // ToType have the same unqualified type (since we checked
3288 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
3296 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
3300 const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
3332 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
3349 S.Context, Info.Constructor, ToType);
3380 User.After.setAllToTypes(ToType);
3395 /// ToType. If such a conversion exists, User will contain the
3408 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
3422 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3431 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3433 S.IsDerivedFrom(From->getBeginLoc(), From->getType(), ToType)))
3436 if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3447 S, From, ToType, ToRecordDecl, User, CandidateSet,
3479 S.Context, Info.Constructor, ToType);
3491 // From->ToType conversion via an static cast (c-style, etc).
3528 ConvTemplate, FoundDecl, ActingContext, From, ToType,
3532 S.AddConversionCandidate(Conv, FoundDecl, ActingContext, From, ToType,
3572 User.After.setAllToTypes(ToType);
3614 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3619 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3632 << From->getType() << ToType << From->getSourceRange();
3634 if (!RequireCompleteType(From->getBeginLoc(), ToType,
3638 << false << From->getType() << From->getSourceRange() << ToType;
4926 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4932 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4935 TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
4944 Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4948 if (!S.isCompleteType(From->getBeginLoc(), ToType))
4962 if (ToType->isRecordType()) {
4964 if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
4965 S.IsDerivedFrom(From->getBeginLoc(), InitType, ToType))
4966 return TryCopyInitialization(S, From->getInit(0), ToType,
4973 if (ToType->isArrayType()) {
4975 InitializedEntity::InitializeParameter(S.Context, ToType,
4980 Result.Standard.setFromType(ToType);
4981 Result.Standard.setAllToTypes(ToType);
5004 if (ToType->isArrayType())
5005 X = S.Context.getAsArrayType(ToType)->getElementType();
5007 toStdInitializerList = S.isStdInitializerList(ToType, &X);
5032 Result.Standard.setFromType(ToType);
5033 Result.Standard.setAllToTypes(ToType);
5047 if (ToType->isRecordType() && !ToType->isAggregateType()) {
5049 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
5061 if (ToType->isAggregateType()) {
5066 InitializedEntity::InitializeParameter(S.Context, ToType,
5077 Result.UserDefined.After.setFromType(ToType);
5078 Result.UserDefined.After.setAllToTypes(ToType);
5087 if (ToType->isReferenceType()) {
5092 QualType T1 = ToType->castAs<ReferenceType>()->getPointeeType();
5107 Init, ToType, false, Found))
5116 return TryReferenceInit(S, Init, ToType, /*FIXME*/ From->getBeginLoc(),
5133 if (ToType->isRValueReferenceType() ||
5138 SCS.IsLvalueReference = ToType->isLValueReferenceType();
5145 From, ToType);
5152 if (!ToType->isRecordType()) {
5158 Result = TryCopyInitialization(S, From->getInit(0), ToType,
5167 Result.Standard.setFromType(ToType);
5168 Result.Standard.setAllToTypes(ToType);
5180 /// ToType from the expression From. Return the implicit conversion
5186 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
5192 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
5195 if (ToType->isReferenceType())
5196 return TryReferenceInit(S, From, ToType,
5200 return TryImplicitConversion(S, From, ToType,
5847 QualType ToType = Conversion->getConversionType().getNonReferenceType();
5852 Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5878 collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
5897 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
5901 ToType, CandidateSet,
5983 QualType ToType;
6013 if (ToType.isNull())
6014 ToType = CurToType.getUnqualifiedType();
6016 (CurToType.getUnqualifiedType() != ToType))
6035 if (ToType.isNull()) {
6052 collectViableConversionCandidates(*this, From, ToType, ViableConversions,
7110 /// \param ToType The type we are converting to.
7117 QualType ConvType, QualType ToType,
7119 QualType ToNonRefType = ToType.getNonReferenceType();
7146 /// and ToType is the type that we're eventually trying to convert to
7151 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
7171 !Context.hasSameUnqualifiedType(Conversion->getConversionType(), ToType))
7181 !isAllowableExplicitConversion(*this, ConvType, ToType,
7197 Candidate.FinalConversion.setAllToTypes(ToType);
7248 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
7258 // convert to (ToType), we need to synthesize a call to the
7290 TryCopyInitialization(*this, TheTemporaryCall, ToType,
7315 if (ToType->isRValueReferenceType() &&
7355 CXXRecordDecl *ActingDC, Expr *From, QualType ToType,
7379 = DeduceTemplateArguments(FunctionTemplate, ToType,
7397 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
11823 // [ToType] [Return]
12091 /// expression with overloaded function type and @p ToType is the type