Lines Matching defs:ToType
72 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
79 QualType &ToType,
84 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
237 QualType ToType = getToType(1);
246 if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
295 QualType ToType = getToType(1);
315 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
317 } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
323 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
349 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
350 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
351 // FromType is larger than ToType.
360 Ctx.getFloatTypeSemantics(ToType),
382 assert(ToType->isIntegralOrUnscopedEnumerationType());
385 const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
386 const unsigned ToWidth = Ctx.getIntWidth(ToType);
391 // Not all values of FromType can be represented in ToType.
1153 /// \brief Tries a user-defined conversion from From to ToType.
1158 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1170 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1177 switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1196 = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1205 ICS.Standard.setAllToTypes(ToType);
1216 ICS.Ambiguous.setToType(ToType);
1225 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1233 /// from the given expression (Expr) to the given type (ToType). This
1260 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1268 if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1275 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1287 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1288 (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1289 S.IsDerivedFrom(From->getLocStart(), FromType, ToType))) {
1293 ICS.Standard.setAllToTypes(ToType);
1302 if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1308 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1315 Sema::TryImplicitConversion(Expr *From, QualType ToType,
1321 return ::TryImplicitConversion(*this, From, ToType,
1329 /// expression From to the type ToType. Returns the
1334 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1337 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1341 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1353 ToType, From->getType(), From);
1354 ICS = ::TryImplicitConversion(*this, From, ToType,
1361 return PerformImplicitConversion(From, ToType, ICS, Action);
1364 /// \brief Determine whether the conversion from FromType to ToType is a valid
1366 bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType,
1368 if (Context.hasSameUnqualifiedType(FromType, ToType))
1376 CanQualType CanTo = Context.getCanonicalType(ToType);
1408 ResultTy = ToType;
1412 /// \brief Determine whether the conversion from FromType to ToType is a valid
1418 QualType ToType, ImplicitConversionKind &ICK) {
1421 if (!ToType->isVectorType() && !FromType->isVectorType())
1425 if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1429 if (ToType->isExtVectorType()) {
1446 if (ToType->isVectorType() && FromType->isVectorType()) {
1447 if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1448 S.isLaxVectorConversion(FromType, ToType)) {
1457 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1464 /// expression From to the type ToType. Standard conversion sequences
1470 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1486 (FromType->isRecordType() || ToType->isRecordType()))
1496 = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1503 // we can sometimes resolve &foo<int> regardless of ToType, so check
1506 S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1510 S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1512 if (!ToType->isBooleanType())
1574 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1615 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1619 } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1622 FromType = ToType.getUnqualifiedType();
1623 } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1626 FromType = ToType.getUnqualifiedType();
1627 } else if (S.IsComplexPromotion(FromType, ToType)) {
1630 FromType = ToType.getUnqualifiedType();
1631 } else if (ToType->isBooleanType() &&
1641 ToType->isIntegralType(S.Context)) {
1644 FromType = ToType.getUnqualifiedType();
1645 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1648 FromType = ToType.getUnqualifiedType();
1649 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1650 (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1653 FromType = ToType.getUnqualifiedType();
1654 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1657 FromType = ToType.getUnqualifiedType();
1659 ToType->isIntegralType(S.Context)) ||
1661 ToType->isRealFloatingType())) {
1664 FromType = ToType.getUnqualifiedType();
1665 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1668 S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1670 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1676 } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1680 } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1682 FromType = ToType.getUnqualifiedType();
1684 S.Context.typesAreCompatible(ToType, FromType)) {
1687 FromType = ToType.getUnqualifiedType();
1688 } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) {
1691 } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1695 FromType = ToType;
1696 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1701 } else if (ToType->isEventT() &&
1705 FromType = ToType;
1716 if (S.IsQualificationConversion(FromType, ToType, CStyle,
1720 FromType = ToType;
1722 CanonTo = S.Context.getCanonicalType(ToType);
1732 CanonTo = S.Context.getCanonicalType(ToType);
1736 FromType = ToType;
1751 auto Conv = S.CheckSingleAssignmentConstraints(ToType, ER,
1758 SCS.setAllToTypes(ToType);
1769 QualType &ToType,
1774 const RecordType *UT = ToType->getAsUnionType();
1783 ToType = it->getType();
1792 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1794 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1795 const BuiltinType *To = ToType->getAs<BuiltinType>();
1813 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
1850 return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1851 IsIntegralPromotion(nullptr, Underlying, ToType);
1855 if (ToType->isIntegerType() &&
1858 ToType, FromEnumType->getDecl()->getPromotionType());
1871 ToType->isIntegerType()) {
1892 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
1912 ToSize = Context.getTypeSize(ToType);
1941 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
1943 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
1945 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
1976 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
1981 const ComplexType *ToComplex = ToType->getAs<ComplexType>();
1993 /// same type qualifiers as FromPtr has on its pointee type. ToType,
1994 /// if non-empty, will be a pointer to ToType that may or may not have
1999 QualType ToPointee, QualType ToType,
2007 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
2008 return ToType.getUnqualifiedType();
2020 // ToType is exactly what we need. Return it.
2021 if (!ToType.isNull())
2022 return ToType.getUnqualifiedType();
2026 if (isa<ObjCObjectPointerType>(ToType))
2035 if (isa<ObjCObjectPointerType>(ToType))
2056 /// can be converted to the type ToType via a pointer conversion (C++
2058 /// might differ from ToType in its cv-qualifiers at some level) into
2070 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2075 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2080 if (ToType->isObjCObjectPointerType() &&
2082 ConvertedType = ToType;
2087 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2088 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
2089 ConvertedType = ToType;
2094 if (ToType->isBlockPointerType() &&
2096 ConvertedType = ToType;
2102 if (ToType->isNullPtrType() &&
2104 ConvertedType = ToType;
2108 const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2114 ConvertedType = ToType;
2126 ToType, Context);
2147 ToType, Context,
2157 ToType, Context);
2167 ToType, Context);
2190 ToType, Context);
2198 ToType, Context);
2222 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2233 ToType->getAs<ObjCObjectPointerType>();
2254 ToType, Context);
2266 ToType, Context);
2273 if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2276 ToType->getAs<BlockPointerType>()) {
2280 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2289 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2384 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2398 /// \param ToType The type we're converting to.
2402 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2405 Context.hasSameUnqualifiedType(FromType, ToType))
2410 if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2460 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2464 ToType->getAs<BlockPointerType>())
2546 ConvertedType = ToType;
2575 QualType FromType, QualType ToType) {
2577 if (FromType.isNull() || ToType.isNull()) {
2583 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2585 *ToMember = ToType->getAs<MemberPointerType>();
2592 ToType = ToMember->getPointeeType();
2597 if (ToType->isPointerType())
2598 ToType = ToType->getPointeeType();
2602 ToType = ToType.getNonReferenceType();
2612 if (Context.hasSameType(FromType, ToType)) {
2618 *ToFunction = tryGetFunctionProtoType(ToType);
2682 /// expression From to the type ToType. This routine checks for
2687 bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2703 << ToType << From->getSourceRange());
2706 << ToType << From->getSourceRange();
2708 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2742 ToType->getAs<ObjCObjectPointerType>()) {
2755 } else if (ToType->isBlockPointerType()) {
2770 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2772 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2774 QualType ToType,
2777 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2785 ConvertedType = ToType;
2810 /// expression From to the type ToType. This routine checks for ambiguous or
2815 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
2830 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2888 /// an rvalue of type FromType to ToType is a qualification conversion
2895 Sema::IsQualificationConversion(QualType FromType, QualType ToType,
2898 ToType = Context.getCanonicalType(ToType);
2901 // If FromType and ToType are the same type, this is not a
2903 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
2911 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
2921 Qualifiers ToQuals = ToType.getQualifiers();
2963 // We are left with FromType and ToType being the pointee types
2964 // after unwrapping the original FromType and ToType the same number
2966 // ToType have the same unqualified type (since we checked
2968 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
2976 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
2980 const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
3013 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
3041 isFirstArgumentCompatibleWithType(S.Context, Constructor, ToType);
3072 User.After.setAllToTypes(ToType);
3087 /// ToType. If such a conversion exists, User will contain the
3100 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
3112 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3121 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3123 S.IsDerivedFrom(From->getLocStart(), From->getType(), ToType)))
3126 if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3137 S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3179 S.Context, Constructor, ToType);
3189 // From->ToType conversion via an static cast (c-style, etc).
3225 ActingContext, From, ToType,
3230 From, ToType, CandidateSet,
3270 User.After.setAllToTypes(ToType);
3312 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3317 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3321 << From->getType() << ToType << From->getSourceRange();
3323 if (!RequireCompleteType(From->getLocStart(), ToType,
3327 << false << From->getType() << From->getSourceRange() << ToType;
4534 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4540 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4543 TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
4552 Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4556 if (!S.isCompleteType(From->getLocStart(), ToType))
4570 if (ToType->isRecordType()) {
4572 if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
4573 S.IsDerivedFrom(From->getLocStart(), InitType, ToType))
4574 return TryCopyInitialization(S, From->getInit(0), ToType,
4581 if (ToType->isArrayType()) {
4583 InitializedEntity::InitializeParameter(S.Context, ToType,
4588 Result.Standard.setFromType(ToType);
4589 Result.Standard.setAllToTypes(ToType);
4612 if (ToType->isArrayType())
4613 X = S.Context.getAsArrayType(ToType)->getElementType();
4615 toStdInitializerList = S.isStdInitializerList(ToType, &X);
4641 Result.Standard.setFromType(ToType);
4642 Result.Standard.setAllToTypes(ToType);
4656 if (ToType->isRecordType() && !ToType->isAggregateType()) {
4658 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4670 if (ToType->isAggregateType()) {
4675 InitializedEntity::InitializeParameter(S.Context, ToType,
4685 Result.UserDefined.After.setFromType(ToType);
4686 Result.UserDefined.After.setAllToTypes(ToType);
4695 if (ToType->isReferenceType()) {
4700 QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4715 Init, ToType, false, Found))
4728 return TryReferenceInit(S, Init, ToType, /*FIXME*/From->getLocStart(),
4745 if (ToType->isRValueReferenceType() ||
4750 SCS.IsLvalueReference = ToType->isLValueReferenceType();
4757 From, ToType);
4764 if (!ToType->isRecordType()) {
4770 Result = TryCopyInitialization(S, From->getInit(0), ToType,
4779 Result.Standard.setFromType(ToType);
4780 Result.Standard.setAllToTypes(ToType);
4792 /// ToType from the expression From. Return the implicit conversion
4798 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4804 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
4807 if (ToType->isReferenceType())
4808 return TryReferenceInit(S, From, ToType,
4813 return TryImplicitConversion(S, From, ToType,
5377 QualType ToType = Conversion->getConversionType().getNonReferenceType();
5382 Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5408 collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
5427 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
5431 ToType, CandidateSet,
5512 QualType ToType;
5542 if (ToType.isNull())
5543 ToType = CurToType.getUnqualifiedType();
5545 (CurToType.getUnqualifiedType() != ToType))
5564 if (ToType.isNull()) {
5581 collectViableConversionCandidates(*this, From, ToType, ViableConversions,
6339 /// \param ToType The type we are converting to.
6346 QualType ConvType, QualType ToType,
6348 QualType ToNonRefType = ToType.getNonReferenceType();
6375 /// and ToType is the type that we're eventually trying to convert to
6382 Expr *From, QualType ToType,
6403 !isAllowableExplicitConversion(*this, ConvType, ToType,
6418 Candidate.FinalConversion.setAllToTypes(ToType);
6450 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
6460 // convert to (ToType), we need to synthesize a call to the
6489 TryCopyInitialization(*this, &Call, ToType,
6514 if (ToType->isRValueReferenceType() &&
6549 Expr *From, QualType ToType,
6561 = DeduceTemplateArguments(FunctionTemplate, ToType,
6579 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
10297 // [ToType] [Return]
10565 /// expression with overloaded function type and @p ToType is the type