Lines Matching refs:ToType
71 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
78 QualType &ToType,
83 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
230 QualType ToType = getToType(1);
239 if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
287 QualType ToType = getToType(1);
307 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
309 } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
315 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
341 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
342 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
343 // FromType is larger than ToType.
352 Ctx.getFloatTypeSemantics(ToType),
374 assert(ToType->isIntegralOrUnscopedEnumerationType());
377 const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
378 const unsigned ToWidth = Ctx.getIntWidth(ToType);
383 // Not all values of FromType can be represented in ToType.
1083 /// \brief Tries a user-defined conversion from From to ToType.
1088 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1100 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1107 switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1126 = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1134 ICS.Standard.setAllToTypes(ToType);
1145 ICS.Ambiguous.setToType(ToType);
1154 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1162 /// from the given expression (Expr) to the given type (ToType). This
1189 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1197 if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1204 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1216 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1217 (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1218 S.IsDerivedFrom(FromType, ToType))) {
1222 ICS.Standard.setAllToTypes(ToType);
1231 if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1237 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1244 Sema::TryImplicitConversion(Expr *From, QualType ToType,
1250 return ::TryImplicitConversion(*this, From, ToType,
1258 /// expression From to the type ToType. Returns the
1263 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1266 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1270 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1282 ToType, From->getType(), From);
1283 ICS = ::TryImplicitConversion(*this, From, ToType,
1290 return PerformImplicitConversion(From, ToType, ICS, Action);
1293 /// \brief Determine whether the conversion from FromType to ToType is a valid
1295 bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType,
1297 if (Context.hasSameUnqualifiedType(FromType, ToType))
1305 CanQualType CanTo = Context.getCanonicalType(ToType);
1337 ResultTy = ToType;
1341 /// \brief Determine whether the conversion from FromType to ToType is a valid
1347 QualType ToType, ImplicitConversionKind &ICK) {
1350 if (!ToType->isVectorType() && !FromType->isVectorType())
1354 if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1358 if (ToType->isExtVectorType()) {
1375 if (ToType->isVectorType() && FromType->isVectorType()) {
1376 if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1377 S.isLaxVectorConversion(FromType, ToType)) {
1386 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1393 /// expression From to the type ToType. Standard conversion sequences
1399 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1414 if (FromType->isRecordType() || ToType->isRecordType()) {
1428 = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1435 // we can sometimes resolve &foo<int> regardless of ToType, so check
1438 S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1442 S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1444 if (!ToType->isBooleanType())
1506 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1542 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1546 } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1549 FromType = ToType.getUnqualifiedType();
1550 } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1553 FromType = ToType.getUnqualifiedType();
1554 } else if (S.IsComplexPromotion(FromType, ToType)) {
1557 FromType = ToType.getUnqualifiedType();
1558 } else if (ToType->isBooleanType() &&
1568 ToType->isIntegralType(S.Context)) {
1571 FromType = ToType.getUnqualifiedType();
1572 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1575 FromType = ToType.getUnqualifiedType();
1576 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1577 (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1580 FromType = ToType.getUnqualifiedType();
1581 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1584 FromType = ToType.getUnqualifiedType();
1586 ToType->isIntegralType(S.Context)) ||
1588 ToType->isRealFloatingType())) {
1591 FromType = ToType.getUnqualifiedType();
1592 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1595 S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1597 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1603 } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1607 } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1609 FromType = ToType.getUnqualifiedType();
1611 S.Context.typesAreCompatible(ToType, FromType)) {
1614 FromType = ToType.getUnqualifiedType();
1615 } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) {
1618 } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1622 FromType = ToType;
1623 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1628 } else if (ToType->isEventT() &&
1632 FromType = ToType;
1643 if (S.IsQualificationConversion(FromType, ToType, CStyle,
1647 FromType = ToType;
1649 CanonTo = S.Context.getCanonicalType(ToType);
1659 CanonTo = S.Context.getCanonicalType(ToType);
1663 FromType = ToType;
1679 QualType &ToType,
1684 const RecordType *UT = ToType->getAsUnionType();
1693 ToType = it->getType();
1702 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1704 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1705 const BuiltinType *To = ToType->getAs<BuiltinType>();
1723 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
1760 return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1761 IsIntegralPromotion(nullptr, Underlying, ToType);
1765 if (ToType->isIntegerType() &&
1768 ToType, FromEnumType->getDecl()->getPromotionType());
1781 ToType->isIntegerType()) {
1802 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
1822 ToSize = Context.getTypeSize(ToType);
1851 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
1853 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
1855 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
1886 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
1891 const ComplexType *ToComplex = ToType->getAs<ComplexType>();
1903 /// same type qualifiers as FromPtr has on its pointee type. ToType,
1904 /// if non-empty, will be a pointer to ToType that may or may not have
1909 QualType ToPointee, QualType ToType,
1917 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
1918 return ToType.getUnqualifiedType();
1930 // ToType is exactly what we need. Return it.
1931 if (!ToType.isNull())
1932 return ToType.getUnqualifiedType();
1936 if (isa<ObjCObjectPointerType>(ToType))
1945 if (isa<ObjCObjectPointerType>(ToType))
1966 /// can be converted to the type ToType via a pointer conversion (C++
1968 /// might differ from ToType in its cv-qualifiers at some level) into
1980 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
1985 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
1990 if (ToType->isObjCObjectPointerType() &&
1992 ConvertedType = ToType;
1997 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
1998 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
1999 ConvertedType = ToType;
2004 if (ToType->isBlockPointerType() &&
2006 ConvertedType = ToType;
2012 if (ToType->isNullPtrType() &&
2014 ConvertedType = ToType;
2018 const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2024 ConvertedType = ToType;
2036 ToType, Context);
2057 ToType, Context,
2067 ToType, Context);
2077 ToType, Context);
2101 ToType, Context);
2109 ToType, Context);
2133 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2144 ToType->getAs<ObjCObjectPointerType>();
2159 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2165 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType,
2167 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2181 ToType, Context);
2193 ToType, Context);
2200 if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2203 ToType->getAs<BlockPointerType>()) {
2207 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2216 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2311 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2325 /// \param ToType The type we're converting to.
2329 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2332 Context.hasSameUnqualifiedType(FromType, ToType))
2337 if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2387 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2391 ToType->getAs<BlockPointerType>())
2473 ConvertedType = ToType;
2490 QualType FromType, QualType ToType) {
2492 if (FromType.isNull() || ToType.isNull()) {
2498 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2500 *ToMember = ToType->getAs<MemberPointerType>();
2507 ToType = ToMember->getPointeeType();
2512 if (ToType->isPointerType())
2513 ToType = ToType->getPointeeType();
2517 ToType = ToType.getNonReferenceType();
2527 if (Context.hasSameType(FromType, ToType)) {
2533 *ToFunction = ToType->getAs<FunctionProtoType>();
2597 /// expression From to the type ToType. This routine checks for
2602 bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2617 << ToType << From->getSourceRange());
2620 << ToType << From->getSourceRange();
2622 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2642 ToType->getAs<ObjCObjectPointerType>()) {
2655 } else if (ToType->isBlockPointerType()) {
2670 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2672 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2674 QualType ToType,
2677 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2685 ConvertedType = ToType;
2711 /// expression From to the type ToType. This routine checks for ambiguous or
2716 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
2731 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2788 /// an rvalue of type FromType to ToType is a qualification conversion
2795 Sema::IsQualificationConversion(QualType FromType, QualType ToType,
2798 ToType = Context.getCanonicalType(ToType);
2801 // If FromType and ToType are the same type, this is not a
2803 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
2811 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
2821 Qualifiers ToQuals = ToType.getQualifiers();
2863 // We are left with FromType and ToType being the pointee types
2864 // after unwrapping the original FromType and ToType the same number
2866 // ToType have the same unqualified type (since we checked
2868 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
2876 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
2880 ToType->getAs<AtomicType>();
2913 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
2941 isFirstArgumentCompatibleWithType(S.Context, Constructor, ToType);
2972 User.After.setAllToTypes(ToType);
2987 /// ToType. If such a conversion exists, User will contain the
3000 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
3012 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3021 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3023 S.IsDerivedFrom(From->getType(), ToType)))
3026 S.RequireCompleteType(From->getExprLoc(), ToType, 0);
3028 // during template instantiation, but ToType may be complete enough now
3030 if (ToType->isIncompleteType()) {
3041 S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3083 S.Context, Constructor, ToType);
3093 // From->ToType conversion via an static cast (c-style, etc).
3129 ActingContext, From, ToType,
3134 From, ToType, CandidateSet,
3174 User.After.setAllToTypes(ToType);
3216 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3221 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3225 << From->getType() << ToType << From->getSourceRange();
3227 if (!RequireCompleteType(From->getLocStart(), ToType,
3231 << From->getType() << From->getSourceRange() << ToType;
4438 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4444 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4447 TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
4456 Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4460 if (S.RequireCompleteType(From->getLocStart(), ToType, 0))
4474 if (ToType->isRecordType()) {
4476 if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
4477 S.IsDerivedFrom(InitType, ToType))
4478 return TryCopyInitialization(S, From->getInit(0), ToType,
4485 if (ToType->isArrayType()) {
4487 InitializedEntity::InitializeParameter(S.Context, ToType,
4492 Result.Standard.setFromType(ToType);
4493 Result.Standard.setAllToTypes(ToType);
4516 if (ToType->isArrayType())
4517 X = S.Context.getAsArrayType(ToType)->getElementType();
4519 toStdInitializerList = S.isStdInitializerList(ToType, &X);
4544 Result.Standard.setFromType(ToType);
4545 Result.Standard.setAllToTypes(ToType);
4559 if (ToType->isRecordType() && !ToType->isAggregateType()) {
4561 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4573 if (ToType->isAggregateType()) {
4578 InitializedEntity::InitializeParameter(S.Context, ToType,
4588 Result.UserDefined.After.setFromType(ToType);
4589 Result.UserDefined.After.setAllToTypes(ToType);
4598 if (ToType->isReferenceType()) {
4603 QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4618 Init, ToType, false, Found))
4631 return TryReferenceInit(S, Init, ToType, /*FIXME*/From->getLocStart(),
4648 if (ToType->isRValueReferenceType() ||
4653 SCS.IsLvalueReference = ToType->isLValueReferenceType();
4660 From, ToType);
4667 if (!ToType->isRecordType()) {
4673 Result = TryCopyInitialization(S, From->getInit(0), ToType,
4682 Result.Standard.setFromType(ToType);
4683 Result.Standard.setAllToTypes(ToType);
4695 /// ToType from the expression From. Return the implicit conversion
4701 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4707 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
4710 if (ToType->isReferenceType())
4711 ToType,
4716 return TryImplicitConversion(S, From, ToType,
5278 QualType ToType = Conversion->getConversionType().getNonReferenceType();
5283 Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5309 collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
5328 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
5332 ToType, CandidateSet,
5412 QualType ToType;
5442 if (ToType.isNull())
5443 ToType = CurToType.getUnqualifiedType();
5445 (CurToType.getUnqualifiedType() != ToType))
5464 if (ToType.isNull()) {
5481 collectViableConversionCandidates(*this, From, ToType, ViableConversions,
6209 /// \param ToType The type we are converting to.
6216 QualType ConvType, QualType ToType,
6218 QualType ToNonRefType = ToType.getNonReferenceType();
6245 /// and ToType is the type that we're eventually trying to convert to
6252 Expr *From, QualType ToType,
6273 !isAllowableExplicitConversion(*this, ConvType, ToType,
6288 Candidate.FinalConversion.setAllToTypes(ToType);
6321 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
6330 // convert to (ToType), we need to synthesize a call to the
6359 TryCopyInitialization(*this, &Call, ToType,
6384 if (ToType->isRValueReferenceType() &&
6419 Expr *From, QualType ToType,
6431 = DeduceTemplateArguments(FunctionTemplate, ToType,
6449 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
9923 // [ToType] [Return]
10172 /// expression with overloaded function type and @p ToType is the type
