Lines Matching refs:RHSType
656 QualType RHSType,
658 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
663 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingComplexCast);
664 return RHSType;
717 QualType RHSType,
720 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType,
723 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType,
725 return RHSType;
739 bool RHSComplexFloat = RHSType->isComplexType();
744 LHSType, RHSType,
751 S, LHS, RHS, LHSType, RHSType, /*convertComplexExpr*/!IsCompAssign,
756 S, RHS, LHS, RHSType, LHSType, /*convertComplexExpr*/true,
795 QualType RHSType, bool IsCompAssign) {
797 bool RHSFloat = RHSType->isRealFloatingType();
802 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
810 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingCast);
811 return RHSType;
815 RHSType,
819 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
830 QualType RHSType,
833 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType();
846 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralComplexCast);
847 return RHSType;
865 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralRealToComplex);
867 return RHSType;
874 QualType RHSType, bool IsCompAssign) {
876 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType);
878 bool RHSSigned = RHSType->hasSignedIntegerRepresentation();
885 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast);
886 return RHSType;
894 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast);
895 return RHSType;
896 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) {
904 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast);
905 return RHSType;
912 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
942 QualType RHSType =
946 if (LHSType == RHSType)
951 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType())
965 if (LHSType == RHSType)
971 if (LHSType->isComplexType() || RHSType->isComplexType())
972 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType,
976 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
977 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,
981 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType())
982 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType,
986 return handleIntegerConversion(*this, LHS, RHS, LHSType, RHSType,
5150 checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) {
5152 assert(RHSType.isCanonical() && "RHS not canonicalized!");
5158 llvm::tie(rhptee, rhq) = cast<PointerType>(RHSType)->getPointeeType().split();
5274 QualType RHSType) {
5276 assert(RHSType.isCanonical() && "RHS not canonicalized!");
5282 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType();
5294 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType))
5304 QualType RHSType) {
5306 assert(RHSType.isCanonical() && "RHS was not canonicalized!");
5310 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() &&
5311 !RHSType->isObjCQualifiedClassType())
5315 if (RHSType->isObjCBuiltinType()) {
5316 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() &&
5322 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType();
5329 if (S.Context.typesAreCompatible(LHSType, RHSType))
5331 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType())
5338 QualType LHSType, QualType RHSType) {
5343 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue);
5370 QualType RHSType = RHS.get()->getType();
5376 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType();
5380 if (LHSType == RHSType) {
5386 if (AtomicTy->getValueType() == RHSType) {
5392 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(RHSType)) {
5408 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) {
5418 if (RHSType->isExtVectorType())
5420 if (RHSType->isArithmeticType()) {
5424 if (elType != RHSType) {
5434 if (LHSType->isVectorType() || RHSType->isVectorType()) {
5435 if (LHSType->isVectorType() && RHSType->isVectorType()) {
5438 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) {
5447 (Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType))) {
5456 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
5465 if (isa<PointerType>(RHSType)) {
5467 return checkPointerTypesForAssignment(*this, LHSType, RHSType);
5471 if (RHSType->isIntegerType()) {
5478 if (isa<ObjCObjectPointerType>(RHSType)) {
5486 if (RHSType->isObjCClassType() &&
5498 if (RHSType->getAs<BlockPointerType>()) {
5511 if (RHSType->isBlockPointerType()) {
5513 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType);
5517 if (RHSType->isIntegerType()) {
5523 if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) {
5529 if (const PointerType *RHSPT = RHSType->getAs<PointerType>())
5541 if (RHSType->isObjCObjectPointerType()) {
5544 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType);
5547 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
5553 if (RHSType->isIntegerType()) {
5560 if (isa<PointerType>(RHSType)) {
5564 if (RHSType->isVoidPointerType()) {
5570 Context.hasSameType(RHSType,
5579 if (RHSType->isBlockPointerType()) {
5589 if (isa<PointerType>(RHSType)) {
5606 if (isa<ObjCObjectPointerType>(RHSType)) {
5623 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
5624 if (Context.typesAreCompatible(LHSType, RHSType)) {
5658 QualType RHSType = RHS.get()->getType();
5677 if (RHSType->isPointerType())
5678 if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
5813 QualType RHSType =
5817 if (LHSType == RHSType)
5821 if (LHSType->isVectorType() && RHSType->isVectorType() &&
5822 Context.areCompatibleVectorTypes(LHSType, RHSType)) {
5829 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast);
5830 return RHSType;
5834 Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType)) {
5846 if (RHSType->isExtVectorType() && !IsCompAssign) {
5849 std::swap(RHSType, LHSType);
5855 if (EltTy->isIntegralType(Context) && RHSType->isIntegralType(Context)) {
5856 int order = Context.getIntegerTypeOrder(EltTy, RHSType);
5865 if (EltTy->isRealFloatingType() && RHSType->isScalarType() &&
5866 RHSType->isRealFloatingType()) {
5867 int order = Context.getFloatingTypeOrder(EltTy, RHSType);
6531 QualType RHSType = RHS.get()->getType();
6532 assert((LHSType->isPointerType() && RHSType->isPointerType()) ||
6533 (LHSType->isMemberPointerType() && RHSType->isMemberPointerType()));
6545 << LHSType << RHSType << T << LHS.get()->getSourceRange()
6577 QualType RHSType = RHS.get()->getType();
6607 } else if (LHSType->isArrayType() && RHSType->isArrayType() &&
6690 RHSType = RHS.get()->getType();
6696 if (LHSType->isRealType() && RHSType->isRealType())
6703 if (LHSType->isArithmeticType() && RHSType->isArithmeticType())
6714 if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2
6718 RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
6753 << LHSType << RHSType << LHS.get()->getSourceRange()
6769 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast);
6778 if (LHSType->isNullPtrType() && RHSType->isNullPtrType())
6794 ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) ||
6796 (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) {
6797 LHS = ImpCastExprToType(LHS.take(), RHSType,
6798 RHSType->isMemberPointerType()
6806 LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) {
6823 RHSType->isBlockPointerType()) {
6825 QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType();
6830 << LHSType << RHSType << LHS.get()->getSourceRange()
6839 && ((LHSType->isBlockPointerType() && RHSType->isPointerType())
6840 || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
6842 if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>()
6847 << LHSType << RHSType << LHS.get()->getSourceRange()
6851 LHS = ImpCastExprToType(LHS.take(), RHSType,
6852 RHSType->isPointerType() ? CK_BitCast
6862 RHSType->isObjCObjectPointerType()) {
6864 const PointerType *RPT = RHSType->getAs<PointerType>();
6870 !Context.typesAreCompatible(LHSType, RHSType)) {
6875 LHS = ImpCastExprToType(LHS.take(), RHSType,
6883 RHSType->isObjCObjectPointerType()) {
6884 if (!Context.areComparableObjCPointerTypes(LHSType, RHSType))
6888 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast);
6894 if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) ||
6895 (LHSType->isIntegerType() && RHSType->isAnyPointerType())) {
6899 (RHSIsNull && RHSType->isIntegerType())) {
6912 << LHSType << RHSType << LHS.get()->getSourceRange()
6919 LHS = ImpCastExprToType(LHS.take(), RHSType,
6929 && LHSType->isBlockPointerType() && RHSType->isIntegerType()) {
6934 && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
6935 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_NullToPointer);
7313 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() :
7324 RHSType->isObjCObjectPointerType()) ||
7325 (Context.isObjCNSObjectType(RHSType) &&
7364 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType);
7367 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
