Lines Matching defs:ToType
69 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
76 QualType &ToType,
81 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
261 QualType ToType = getToType(1);
270 if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
318 QualType ToType = getToType(1);
327 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
329 } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
335 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
361 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
362 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
363 // FromType is larger than ToType.
372 Ctx.getFloatTypeSemantics(ToType),
399 assert(ToType->isIntegralOrUnscopedEnumerationType());
402 const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
403 const unsigned ToWidth = Ctx.getIntWidth(ToType);
408 // Not all values of FromType can be represented in ToType.
1088 /// \brief Tries a user-defined conversion from From to ToType.
1093 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1104 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1111 = IsUserDefinedConversion(S, From, ToType, ICS.UserDefined, Conversions,
1128 = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1136 ICS.Standard.setAllToTypes(ToType);
1151 ICS.setBad(BadConversionSequence::suppressed_user, From, ToType);
1156 ICS.Ambiguous.setToType(ToType);
1162 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1169 /// from the given expression (Expr) to the given type (ToType). This
1196 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1203 if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1210 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1222 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1223 (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1224 S.IsDerivedFrom(FromType, ToType))) {
1228 ICS.Standard.setAllToTypes(ToType);
1237 if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1243 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1249 Sema::TryImplicitConversion(Expr *From, QualType ToType,
1255 return clang::TryImplicitConversion(*this, From, ToType,
1262 /// expression From to the type ToType. Returns the
1267 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1270 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1274 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1285 ICS = clang::TryImplicitConversion(*this, From, ToType,
1291 return PerformImplicitConversion(From, ToType, ICS, Action);
1294 /// \brief Determine whether the conversion from FromType to ToType is a valid
1296 bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType,
1298 if (Context.hasSameUnqualifiedType(FromType, ToType))
1306 CanQualType CanTo = Context.getCanonicalType(ToType);
1338 ResultTy = ToType;
1342 /// \brief Determine whether the conversion from FromType to ToType is a valid
1348 QualType ToType, ImplicitConversionKind &ICK) {
1351 if (!ToType->isVectorType() && !FromType->isVectorType())
1355 if (Context.hasSameUnqualifiedType(FromType, ToType))
1359 if (ToType->isExtVectorType()) {
1376 if (ToType->isVectorType() && FromType->isVectorType()) {
1377 if (Context.areCompatibleVectorTypes(FromType, ToType) ||
1379 (Context.getTypeSize(FromType) == Context.getTypeSize(ToType)))) {
1388 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1395 /// expression From to the type ToType. Standard conversion sequences
1401 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1417 if (FromType->isRecordType() || ToType->isRecordType()) {
1431 = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1437 // we can sometimes resolve &foo<int> regardless of ToType, so check
1440 S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1444 S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1446 if (!ToType->isBooleanType())
1508 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1544 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1548 } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1551 FromType = ToType.getUnqualifiedType();
1552 } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1555 FromType = ToType.getUnqualifiedType();
1556 } else if (S.IsComplexPromotion(FromType, ToType)) {
1559 FromType = ToType.getUnqualifiedType();
1560 } else if (ToType->isBooleanType() &&
1570 ToType->isIntegralType(S.Context)) {
1573 FromType = ToType.getUnqualifiedType();
1574 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1577 FromType = ToType.getUnqualifiedType();
1578 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1579 (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1582 FromType = ToType.getUnqualifiedType();
1583 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1586 FromType = ToType.getUnqualifiedType();
1588 ToType->isIntegralType(S.Context)) ||
1590 ToType->isRealFloatingType())) {
1593 FromType = ToType.getUnqualifiedType();
1594 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1597 S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1599 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1605 } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1609 } else if (IsVectorConversion(S.Context, FromType, ToType, SecondICK)) {
1611 FromType = ToType.getUnqualifiedType();
1613 S.Context.typesAreCompatible(ToType, FromType)) {
1616 FromType = ToType.getUnqualifiedType();
1617 } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) {
1620 } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1624 FromType = ToType;
1625 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1630 } else if (ToType->isEventT() &&
1634 FromType = ToType;
1645 if (S.IsQualificationConversion(FromType, ToType, CStyle,
1649 FromType = ToType;
1651 CanonTo = S.Context.getCanonicalType(ToType);
1661 CanonTo = S.Context.getCanonicalType(ToType);
1665 FromType = ToType;
1681 QualType &ToType,
1686 const RecordType *UT = ToType->getAsUnionType();
1697 ToType = it->getType();
1706 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1708 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1709 const BuiltinType *To = ToType->getAs<BuiltinType>();
1727 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
1762 return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1763 IsIntegralPromotion(From, Underlying, ToType);
1767 if (ToType->isIntegerType() &&
1769 return Context.hasSameUnqualifiedType(ToType,
1783 ToType->isIntegerType()) {
1804 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
1825 ToSize = Context.getTypeSize(ToType);
1853 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
1855 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
1857 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
1888 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
1893 const ComplexType *ToComplex = ToType->getAs<ComplexType>();
1905 /// same type qualifiers as FromPtr has on its pointee type. ToType,
1906 /// if non-empty, will be a pointer to ToType that may or may not have
1911 QualType ToPointee, QualType ToType,
1919 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
1920 return ToType.getUnqualifiedType();
1932 // ToType is exactly what we need. Return it.
1933 if (!ToType.isNull())
1934 return ToType.getUnqualifiedType();
1938 if (isa<ObjCObjectPointerType>(ToType))
1947 if (isa<ObjCObjectPointerType>(ToType))
1968 /// can be converted to the type ToType via a pointer conversion (C++
1970 /// might differ from ToType in its cv-qualifiers at some level) into
1982 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
1987 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
1992 if (ToType->isObjCObjectPointerType() &&
1994 ConvertedType = ToType;
1999 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2000 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
2001 ConvertedType = ToType;
2006 if (ToType->isBlockPointerType() &&
2008 ConvertedType = ToType;
2014 if (ToType->isNullPtrType() &&
2016 ConvertedType = ToType;
2020 const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2026 ConvertedType = ToType;
2038 ToType, Context);
2059 ToType, Context,
2069 ToType, Context);
2079 ToType, Context);
2103 ToType, Context);
2111 ToType, Context);
2135 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2146 ToType->getAs<ObjCObjectPointerType>();
2161 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2167 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType,
2169 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2183 ToType, Context);
2195 ToType, Context);
2202 if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2205 ToType->getAs<BlockPointerType>()) {
2209 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2218 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2313 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2327 /// \param ToType The type we're converting to.
2331 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2334 Context.hasSameUnqualifiedType(FromType, ToType))
2339 if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2389 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2393 ToType->getAs<BlockPointerType>())
2475 ConvertedType = ToType;
2492 QualType FromType, QualType ToType) {
2494 if (FromType.isNull() || ToType.isNull()) {
2500 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2502 *ToMember = ToType->getAs<MemberPointerType>();
2509 ToType = ToMember->getPointeeType();
2514 if (ToType->isPointerType())
2515 ToType = ToType->getPointeeType();
2519 ToType = ToType.getNonReferenceType();
2529 if (Context.hasSameType(FromType, ToType)) {
2535 *ToFunction = ToType->getAs<FunctionProtoType>();
2596 /// expression From to the type ToType. This routine checks for
2601 bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2616 << ToType << From->getSourceRange());
2619 << ToType << From->getSourceRange();
2621 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2641 ToType->getAs<ObjCObjectPointerType>()) {
2654 } else if (ToType->isBlockPointerType()) {
2669 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2671 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2673 QualType ToType,
2676 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2684 ConvertedType = ToType;
2710 /// expression From to the type ToType. This routine checks for ambiguous or
2715 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
2730 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2775 /// an rvalue of type FromType to ToType is a qualification conversion
2782 Sema::IsQualificationConversion(QualType FromType, QualType ToType,
2785 ToType = Context.getCanonicalType(ToType);
2788 // If FromType and ToType are the same type, this is not a
2790 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
2798 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
2808 Qualifiers ToQuals = ToType.getQualifiers();
2849 // We are left with FromType and ToType being the pointee types
2850 // after unwrapping the original FromType and ToType the same number
2852 // ToType have the same unqualified type (since we checked
2854 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
2862 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
2866 const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
2899 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
2927 isFirstArgumentCompatibleWithType(S.Context, Constructor, ToType);
2955 User.After.setAllToTypes(ToType);
2972 /// ToType. If such a conversion exists, User will contain the
2981 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
2990 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
2999 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3001 S.IsDerivedFrom(From->getType(), ToType)))
3004 S.RequireCompleteType(From->getExprLoc(), ToType, 0);
3006 // during template instantiation, but ToType may be complete enough now
3008 if (ToType->isIncompleteType()) {
3019 S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3061 S.Context, Constructor, ToType);
3071 // From->ToType conversion via an static cast (c-style, etc).
3110 ActingContext, From, ToType,
3114 From, ToType, CandidateSet);
3151 User.After.setAllToTypes(ToType);
3196 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3200 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3205 << From->getType() << ToType << From->getSourceRange();
3207 if (!RequireCompleteType(From->getLocStart(), ToType,
3212 << From->getType() << From->getSourceRange() << ToType;
4380 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4386 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4389 TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
4398 Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4403 if (S.RequireCompleteType(From->getLocStart(), ToType, 0))
4413 if (ToType->isArrayType())
4414 X = S.Context.getAsArrayType(ToType)->getElementType();
4416 toStdInitializerList = S.isStdInitializerList(ToType, &X);
4441 Result.Standard.setFromType(ToType);
4442 Result.Standard.setAllToTypes(ToType);
4456 if (ToType->isRecordType() && !ToType->isAggregateType()) {
4458 Result = TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4470 if (ToType->isAggregateType()) {
4475 InitializedEntity::InitializeParameter(S.Context, ToType,
4485 Result.UserDefined.After.setFromType(ToType);
4486 Result.UserDefined.After.setAllToTypes(ToType);
4494 if (ToType->isReferenceType()) {
4499 QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4514 Init, ToType, false, Found))
4527 return TryReferenceInit(S, Init, ToType,
4544 if (ToType->isRValueReferenceType() ||
4549 SCS.IsLvalueReference = ToType->isLValueReferenceType();
4556 From, ToType);
4562 if (!ToType->isRecordType()) {
4568 Result = TryCopyInitialization(S, From->getInit(0), ToType,
4577 Result.Standard.setFromType(ToType);
4578 Result.Standard.setAllToTypes(ToType);
4590 /// ToType from the expression From. Return the implicit conversion
4596 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4602 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
4605 if (ToType->isReferenceType())
4606 return TryReferenceInit(S, From, ToType,
4611 return TryImplicitConversion(S, From, ToType,
5142 QualType ToType = Conversion->getConversionType().getNonReferenceType();
5147 Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5173 collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
5192 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet);
5195 ToType, CandidateSet);
5275 QualType ToType;
5307 if (ToType.isNull())
5308 ToType = CurToType.getUnqualifiedType();
5310 (CurToType.getUnqualifiedType() != ToType))
5329 if (ToType.isNull()) {
5346 collectViableConversionCandidates(*this, From, ToType, ViableConversions,
5808 /// and ToType is the type that we're eventually trying to convert to
5815 Expr *From, QualType ToType,
5842 Candidate.FinalConversion.setAllToTypes(ToType);
5875 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
5884 // convert to (ToType), we need to synthesize a call to the
5913 TryCopyInitialization(*this, &Call, ToType,
5937 if (ToType->isRValueReferenceType() &&
5964 Expr *From, QualType ToType,
5975 = DeduceTemplateArguments(FunctionTemplate, ToType,
5993 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
9354 // [ToType] [Return]
9591 /// expression with overloaded function type and @p ToType is the type
