[Sema] Tweak error message for invalid vector/scalar combinations

[uweigand]

Summary

Before the patch:

typedef unsigned int v4si attribute((ext_vector_type(4)));
void foo(v4si *ptr) { *ptr += 1.0f; }

would generate:

error: can't convert between vector values of different size ('v4si' (vector of 4 'unsigned int' values) and 'float')
void foo(v4si *ptr) { *ptr += 1.0f; }

~~~~ ^  ~~~~

This is a bit misleading, since the problem is a type mismatch between
the type of the scalar and the type of the vector elements, not a problem
with vectors of different size. (E.g. the code is correct with "1.0f"
replaced by the like-sized "1".) The patch changes the error to the more
generic:

error: invalid operands to binary expression ('v4si' (vector of 4 'unsigned int' values) and 'float')
void foo(v4si *ptr) { *ptr += 1.0f; }

~~~~ ^  ~~~~

Original patch by Richard Sandiford.

lib/Sema/SemaExpr.cpp

QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
   if ((!RHSVecType && !RHSType->isRealType()) ||
       (!LHSVecType && !LHSType->isRealType())) {
     Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
       << LHSType << RHSType
       << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
     return QualType();
   }
 
+  // Otherwise, if one is a vector and one isn't, treat it as a general invalid
+  // combination, rather than as an incompatibility between two vector sizes.
+  if (!LHSVecType || !RHSVecType)
+    return InvalidOperands(Loc, LHS, RHS);
+
   // Otherwise, use the generic diagnostic.
   Diag(Loc, diag::err_typecheck_vector_not_convertable)
     << LHSType << RHSType
     << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
   return QualType();
 }
 
 // checkArithmeticNull - Detect when a NULL constant is used improperly in an

test/Sema/ext_vector_casts.c

static void splats(int i, long l, __uint128_t t, float f, double d) {
   int4 vi = i;
   ulong2 vl = (unsigned long)l;
   float2 vf = f;
   double2 vd = d;
   
   vs = 65536 + vs; // expected-warning {{implicit conversion from 'int' to 'short8' (vector of 8 'short' values) changes value from 65536 to 0}}
   vs = vs + i; // expected-warning {{implicit conversion loses integer precision}}
   vs = vs + 1;
-  vs = vs + 1.f; // expected-error {{can't convert between vector values of different size}}
+  vs = vs + 1.f; // expected-error {{invalid operands to binary expression}}
   
   vi = l + vi; // expected-warning {{implicit conversion loses integer precision}}
   vi = 1 + vi;
-  vi = vi + 2.0; // expected-error {{can't convert between vector values of different size}}
+  vi = vi + 2.0; // expected-error {{invalid operands to binary expression}}
   vi = vi + 0xffffffff; // expected-warning {{implicit conversion changes signedness}}
   
   vl = l + vl; // expected-warning {{implicit conversion changes signedness}}
   vl = vl + t; // expected-warning {{implicit conversion loses integer precision}}
   
   vf = 1 + vf;
   vf = l + vf;
   vf = 2.0 + vf;
   vf = d + vf; // expected-warning {{implicit conversion loses floating-point precision}}
   vf = vf + 0xffffffff;
   vf = vf + 2.1; // expected-warning {{implicit conversion loses floating-point precision}}
   
   vd = l + vd;
   vd = vd + t;
 }

test/SemaOpenCL/cond.cl

 
 float2 ntest04(int2 C, int2 X, float2 Y)
 {
   return C ? X : Y; // expected-error {{can't convert between vector values of different size ('int2' (vector of 2 'int' values) and 'float2' (vector of 2 'float' values))}}
 }
 
 float2 ntest05(int2 C, int2 X, float Y)
 {
-  return C ? X : Y; // expected-error {{can't convert between vector values of different size ('int2' (vector of 2 'int' values) and 'float')}}
+  return C ? X : Y; // expected-error {{invalid operands to binary expression ('int2' (vector of 2 'int' values) and 'float')}}
 }
 
 char2 ntest06(int2 C, char2 X, char2 Y)
 {
   return C ? X : Y; // expected-error {{vector condition type 'int2' (vector of 2 'int' values) and result type 'char2' (vector of 2 'char' values) do not have elements of the same size}}
 }
 
 float ntest07(float C, float X, float Y)