Lines Matching refs:FromType
241 // Note that FromType has not necessarily been transformed by the
243 // check for their presence as well as checking whether FromType is
263 QualType FromType = getFromType();
266 // Note that FromType has not necessarily been transformed by the
270 FromType = Context.getArrayDecayedType(FromType);
272 if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
320 QualType FromType = getToType(0);
330 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
332 } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
364 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
365 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
366 // FromType is larger than ToType.
395 if (!FromType->isIntegralOrUnscopedEnumerationType()) {
401 assert(FromType->isIntegralOrUnscopedEnumerationType());
403 const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
404 const unsigned FromWidth = Ctx.getIntWidth(FromType);
411 // Not all values of FromType can be represented in ToType.
1247 QualType FromType = From->getType();
1248 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1249 (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1250 S.IsDerivedFrom(FromType, ToType))) {
1253 ICS.Standard.setFromType(FromType);
1263 if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1325 /// \brief Determine whether the conversion from FromType to ToType is a valid
1327 bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType,
1329 if (Context.hasSameUnqualifiedType(FromType, ToType))
1338 CanQualType CanFrom = Context.getCanonicalType(FromType);
1373 /// \brief Determine whether the conversion from FromType to ToType is a valid
1378 static bool IsVectorConversion(Sema &S, QualType FromType,
1382 if (!ToType->isVectorType() && !FromType->isVectorType())
1386 if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1393 if (FromType->isExtVectorType())
1397 if (FromType->isArithmeticType()) {
1407 if (ToType->isVectorType() && FromType->isVectorType()) {
1408 if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1409 S.isLaxVectorConversion(FromType, ToType)) {
1436 QualType FromType = From->getType();
1441 SCS.setFromType(FromType);
1446 if (FromType->isRecordType() || ToType->isRecordType()) {
1457 if (FromType == S.Context.OverloadTy) {
1464 FromType = Fn->getType();
1469 S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1472 if (!S.IsNoReturnConversion(FromType,
1480 // function and recompute the FromType accordingly. Take advantage of the
1492 FromType = S.Context.getMemberPointerType(FromType, ClassType);
1497 FromType = S.Context.getPointerType(FromType);
1502 FromType,
1513 !FromType->isFunctionType() && !FromType->isArrayType() &&
1514 S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1520 if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1521 FromType = Atomic->getValueType();
1527 FromType = FromType.getUnqualifiedType();
1528 } else if (FromType->isArrayType()) {
1535 FromType = S.Context.getArrayDecayedType(FromType);
1548 SCS.setAllToTypes(FromType);
1551 } else if (FromType->isFunctionType() && argIsLValue) {
1558 FromType = S.Context.getPointerType(FromType);
1563 SCS.setToType(0, FromType);
1573 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1577 } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1580 FromType = ToType.getUnqualifiedType();
1581 } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1584 FromType = ToType.getUnqualifiedType();
1585 } else if (S.IsComplexPromotion(FromType, ToType)) {
1588 FromType = ToType.getUnqualifiedType();
1590 (FromType->isArithmeticType() ||
1591 FromType->isAnyPointerType() ||
1592 FromType->isBlockPointerType() ||
1593 FromType->isMemberPointerType() ||
1594 FromType->isNullPtrType())) {
1597 FromType = S.Context.BoolTy;
1598 } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1602 FromType = ToType.getUnqualifiedType();
1603 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1606 FromType = ToType.getUnqualifiedType();
1607 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1608 (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1611 FromType = ToType.getUnqualifiedType();
1612 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1615 FromType = ToType.getUnqualifiedType();
1616 } else if ((FromType->isRealFloatingType() &&
1618 (FromType->isIntegralOrUnscopedEnumerationType() &&
1622 FromType = ToType.getUnqualifiedType();
1623 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1626 S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1628 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1629 FromType, IncompatibleObjC)) {
1633 FromType = FromType.getUnqualifiedType();
1634 } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1635 InOverloadResolution, FromType)) {
1638 } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1640 FromType = ToType.getUnqualifiedType();
1642 S.Context.typesAreCompatible(ToType, FromType)) {
1645 FromType = ToType.getUnqualifiedType();
1646 } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) {
1653 FromType = ToType;
1663 FromType = ToType;
1668 SCS.setToType(1, FromType);
1674 if (S.IsQualificationConversion(FromType, ToType, CStyle,
1678 FromType = ToType;
1679 CanonFrom = S.Context.getCanonicalType(FromType);
1689 CanonFrom = S.Context.getCanonicalType(FromType);
1694 FromType = ToType;
1698 SCS.setToType(2, FromType);
1732 /// expression From (whose potentially-adjusted type is FromType) to
1735 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1747 if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
1748 !FromType->isEnumeralType()) {
1750 (FromType->isSignedIntegerType() ||
1753 (!FromType->isSignedIntegerType() &&
1754 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
1779 if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
1795 !RequireCompleteType(From->getLocStart(), FromType, 0))
1809 if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
1813 bool FromIsSigned = FromType->isSignedIntegerType();
1814 uint64_t FromSize = Context.getTypeSize(FromType);
1849 if (FromType->isIntegralType(Context) &&
1856 (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
1862 if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
1872 if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
1880 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
1882 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
1883 if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
1915 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
1916 const ComplexType *FromComplex = FromType->getAs<ComplexType>();
1994 /// expression From, which has the (possibly adjusted) type FromType,
2009 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2014 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2026 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2060 if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2063 FromType->getAs<ObjCObjectPointerType>(),
2068 const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2162 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2169 Qualifiers FromQualifiers = FromType.getQualifiers();
2175 FromType->getAs<ObjCObjectPointerType>();
2194 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType,
2241 else if (FromType->getAs<BlockPointerType>() &&
2252 if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2255 FromType->getAs<BlockPointerType>())
2352 /// \param FromType The type we're converting form.
2358 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2361 Context.hasSameUnqualifiedType(FromType, ToType))
2379 if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2416 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2427 FromType->getAs<BlockPointerType>())
2519 QualType FromType, QualType ToType) {
2521 if (FromType.isNull() || ToType.isNull()) {
2527 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2528 const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(),
2535 FromType = FromMember->getPointeeType();
2539 if (FromType->isPointerType())
2540 FromType = FromType->getPointeeType();
2545 FromType = FromType.getNonReferenceType();
2549 if (FromType->isInstantiationDependentType() &&
2550 !FromType->getAs<TemplateSpecializationType>()) {
2556 if (Context.hasSameType(FromType, ToType)) {
2561 const FunctionProtoType *FromFunction = FromType->getAs<FunctionProtoType>(),
2635 QualType FromType = From->getType();
2640 if (!IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2652 if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
2673 FromType->getAs<ObjCObjectPointerType>()) {
2679 } else if (FromType->isBlockPointerType()) {
2685 if (!FromType->isBlockPointerType())
2698 /// expression From, which has the (possibly adjusted) type FromType, can be
2702 bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
2719 const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
2749 QualType FromType = From->getType();
2750 const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
2817 /// an rvalue of type FromType to ToType is a qualification conversion
2824 Sema::IsQualificationConversion(QualType FromType, QualType ToType,
2826 FromType = Context.getCanonicalType(FromType);
2830 // If FromType and ToType are the same type, this is not a
2832 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
2840 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
2849 Qualifiers FromQuals = FromType.getQualifiers();
2892 // We are left with FromType and ToType being the pointee types
2893 // after unwrapping the original FromType and ToType the same number
2894 // of types. If we unwrapped any pointers, and if FromType and
2897 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
4718 TryObjectArgumentInitialization(Sema &S, QualType FromType,
4734 if (const PointerType *PT = FromType->getAs<PointerType>()) {
4735 FromType = PT->getPointeeType();
4742 assert(FromType->isRecordType());
4763 QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
4768 FromType, ImplicitParamType);
4778 } else if (S.IsDerivedFrom(FromType, ClassType))
4782 FromType, ImplicitParamType);
4795 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, FromType,
4804 ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, FromType,
4815 ICS.Standard.setFromType(FromType);