Lines Matching defs:RHSType
914 QualType RHSType,
916 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
921 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingComplexCast);
922 return RHSType;
975 QualType RHSType,
978 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType,
981 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType,
983 return RHSType;
997 bool RHSComplexFloat = RHSType->isComplexType();
1002 LHSType, RHSType,
1009 S, LHS, RHS, LHSType, RHSType, /*convertComplexExpr*/!IsCompAssign,
1014 S, RHS, LHS, RHSType, LHSType, /*convertComplexExpr*/true,
1053 QualType RHSType, bool IsCompAssign) {
1055 bool RHSFloat = RHSType->isRealFloatingType();
1060 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
1068 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingCast);
1069 return RHSType;
1073 return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
1077 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
1102 QualType RHSType, bool IsCompAssign) {
1104 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType);
1106 bool RHSSigned = RHSType->hasSignedIntegerRepresentation();
1113 LHS = (*doLHSCast)(S, LHS.take(), RHSType);
1114 return RHSType;
1122 LHS = (*doLHSCast)(S, LHS.take(), RHSType);
1123 return RHSType;
1124 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) {
1132 LHS = (*doLHSCast)(S, LHS.take(), RHSType);
1133 return RHSType;
1140 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
1152 QualType RHSType,
1155 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType();
1171 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1213 QualType RHSType =
1221 if (LHSType == RHSType)
1226 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType())
1240 if (LHSType == RHSType)
1246 if (LHSType->isComplexType() || RHSType->isComplexType())
1247 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType,
1251 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
1252 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,
1256 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType())
1257 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType,
1262 (*this, LHS, RHS, LHSType, RHSType, IsCompAssign);
5877 checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) {
5879 assert(RHSType.isCanonical() && "RHS not canonicalized!");
5885 llvm::tie(rhptee, rhq) = cast<PointerType>(RHSType)->getPointeeType().split();
6001 QualType RHSType) {
6003 assert(RHSType.isCanonical() && "RHS not canonicalized!");
6009 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType();
6021 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType))
6031 QualType RHSType) {
6033 assert(RHSType.isCanonical() && "RHS was not canonicalized!");
6037 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() &&
6038 !RHSType->isObjCQualifiedClassType())
6042 if (RHSType->isObjCBuiltinType()) {
6043 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() &&
6049 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType();
6056 if (S.Context.typesAreCompatible(LHSType, RHSType))
6058 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType())
6065 QualType LHSType, QualType RHSType) {
6070 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue);
6097 QualType RHSType = RHS.get()->getType();
6103 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType();
6106 if (LHSType == RHSType) {
6132 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) {
6142 if (RHSType->isExtVectorType())
6144 if (RHSType->isArithmeticType()) {
6148 if (elType != RHSType) {
6158 if (LHSType->isVectorType() || RHSType->isVectorType()) {
6159 if (LHSType->isVectorType() && RHSType->isVectorType()) {
6162 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) {
6171 RHSType))) {
6180 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
6189 if (isa<PointerType>(RHSType)) {
6191 return checkPointerTypesForAssignment(*this, LHSType, RHSType);
6195 if (RHSType->isIntegerType()) {
6202 if (isa<ObjCObjectPointerType>(RHSType)) {
6210 if (RHSType->isObjCClassType() &&
6222 if (RHSType->getAs<BlockPointerType>()) {
6235 if (RHSType->isBlockPointerType()) {
6237 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType);
6241 if (RHSType->isIntegerType()) {
6247 if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) {
6253 if (const PointerType *RHSPT = RHSType->getAs<PointerType>())
6265 if (RHSType->isObjCObjectPointerType()) {
6268 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType);
6271 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
6277 if (RHSType->isIntegerType()) {
6284 if (isa<PointerType>(RHSType)) {
6288 if (RHSType->isVoidPointerType()) {
6294 Context.hasSameType(RHSType,
6303 if (RHSType->isBlockPointerType()) {
6313 if (isa<PointerType>(RHSType)) {
6330 if (isa<ObjCObjectPointerType>(RHSType)) {
6347 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
6348 if (Context.typesAreCompatible(LHSType, RHSType)) {
6381 QualType RHSType = RHS.get()->getType();
6400 if (RHSType->isPointerType())
6401 if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
6542 QualType RHSType =
6546 if (LHSType == RHSType)
6550 if (LHSType->isVectorType() && RHSType->isVectorType() &&
6551 Context.areCompatibleVectorTypes(LHSType, RHSType)) {
6558 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast);
6559 return RHSType;
6563 Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType)) {
6575 if (RHSType->isExtVectorType() && !IsCompAssign) {
6578 std::swap(RHSType, LHSType);
6584 if (EltTy->isIntegralType(Context) && RHSType->isIntegralType(Context)) {
6585 int order = Context.getIntegerTypeOrder(EltTy, RHSType);
6594 if (EltTy->isRealFloatingType() && RHSType->isScalarType()) {
6595 if (RHSType->isRealFloatingType()) {
6596 int order = Context.getFloatingTypeOrder(EltTy, RHSType);
6605 if (RHSType->isIntegralType(Context)) {
7158 QualType RHSType = RHS.get()->getType();
7162 !RHSType->hasIntegerRepresentation())
7168 isScopedEnumerationType(RHSType)) {
7250 QualType RHSType = RHS.get()->getType();
7251 assert((LHSType->isPointerType() && RHSType->isPointerType()) ||
7252 (LHSType->isMemberPointerType() && RHSType->isMemberPointerType()));
7264 << LHSType << RHSType << T << LHS.get()->getSourceRange()
7493 QualType RHSType
7524 } else if (LHSType->isArrayType() && RHSType->isArrayType() &&
7584 RHSType = RHS.get()->getType();
7590 if (LHSType->isRealType() && RHSType->isRealType())
7597 if (LHSType->isArithmeticType() && RHSType->isArithmeticType())
7608 if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2
7612 RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
7647 << LHSType << RHSType << LHS.get()->getSourceRange()
7663 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast);
7672 if (LHSType->isNullPtrType() && RHSType->isNullPtrType())
7688 ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) ||
7690 (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) {
7691 LHS = ImpCastExprToType(LHS.take(), RHSType,
7692 RHSType->isMemberPointerType()
7700 LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) {
7717 RHSType->isBlockPointerType()) {
7719 QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType();
7724 << LHSType << RHSType << LHS.get()->getSourceRange()
7733 && ((LHSType->isBlockPointerType() && RHSType->isPointerType())
7734 || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
7736 if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>()
7741 << LHSType << RHSType << LHS.get()->getSourceRange()
7745 LHS = ImpCastExprToType(LHS.take(), RHSType,
7746 RHSType->isPointerType() ? CK_BitCast
7756 RHSType->isObjCObjectPointerType()) {
7758 const PointerType *RPT = RHSType->getAs<PointerType>();
7764 !Context.typesAreCompatible(LHSType, RHSType)) {
7771 CheckObjCARCConversion(SourceRange(), RHSType, E, CCK_ImplicitConversion);
7772 LHS = ImpCastExprToType(E, RHSType,
7785 RHSType->isObjCObjectPointerType()) {
7786 if (!Context.areComparableObjCPointerTypes(LHSType, RHSType))
7793 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast);
7799 if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) ||
7800 (LHSType->isIntegerType() && RHSType->isAnyPointerType())) {
7807 (RHSIsNull && RHSType->isIntegerType())) {
7820 << LHSType << RHSType << LHS.get()->getSourceRange()
7827 LHS = ImpCastExprToType(LHS.take(), RHSType,
7837 && LHSType->isBlockPointerType() && RHSType->isIntegerType()) {
7842 && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
7843 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_NullToPointer);
8227 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() :
8242 RHSType->isObjCObjectPointerType()) ||
8243 (Context.isObjCNSObjectType(RHSType) &&
8302 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType);
8305 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
