Improve diagnostics when we fail to convert from a source type to a

destination type for initialization, assignment, parameter-passing,
etc. The main issue fixed here is that we used rather confusing
wording for diagnostics such as

t.c:2:9: warning: initializing 'char const [2]' discards qualifiers,
      expected 'char *' [-pedantic]
  char *name = __func__;
        ^      ~~~~~~~~

We're not initializing a 'char const [2]', we're initializing a 'char
*' with an expression of type 'char const [2]'. Similar problems
existed for other diagnostics in this area, so I've normalized them all
with more precise descriptive text to say what we're
initializing/converting/assigning/etc. from and to. The warning for
the code above is now:

t.c:2:9: warning: initializing 'char *' from an expression of type
      'char const [2]' discards qualifiers [-pedantic]
  char *name = __func__;
        ^      ~~~~~~~~

Fixes <rdar://problem/7447179>.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@100832 91177308-0d34-0410-b5e6-96231b3b80d8

68 files changed, 175 insertions, 176 deletions

diff --git a/test/Analysis/null-deref-ps.c b/test/Analysis/null-deref-ps.c
index 5376ca0eb3..5a1049c7d7 100644
--- a/test/Analysis/null-deref-ps.c
+++ b/test/Analysis/null-deref-ps.c
@@ -62,8 +62,8 @@ int f4(int *p) {
 
 int f4_b() {
   short array[2];
-  uintptr_t x = array; // expected-warning{{incompatible pointer to integer conversion initializing}}
-  short *p = x; // expected-warning{{incompatible integer to pointer conversion initializing}}
+  uintptr_t x = array; // expected-warning{{incompatible pointer to integer conversion}}
+  short *p = x; // expected-warning{{incompatible integer to pointer conversion}}
   
   // The following branch should be infeasible.
   if (!(p = &array[0])) {
diff --git a/test/Analysis/override-werror.c b/test/Analysis/override-werror.c
index 522b9dcb94..f4854bb819 100644
--- a/test/Analysis/override-werror.c
+++ b/test/Analysis/override-werror.c
@@ -6,7 +6,7 @@
 // analyzer results.
 
 char* f(int *p) { 
-  return p; // expected-warning{{incompatible pointer types returning 'int *', expected 'char *'}}
+  return p; // expected-warning{{incompatible pointer types}}
 }
 
 void g(int *p) {
diff --git a/test/CXX/except/except.handle/p16.cpp b/test/CXX/except/except.handle/p16.cpp
index 87972f5985..4950a2f6aa 100644
--- a/test/CXX/except/except.handle/p16.cpp
+++ b/test/CXX/except/except.handle/p16.cpp
@@ -11,12 +11,12 @@ class X {
 public:
   X(const X<T> &) {
     int *ip = 0;
-    ptr = ip; // expected-error{{incompatible type assigning 'int *', expected 'float *'}}
+    ptr = ip; // expected-error{{assigning to 'float *' from incompatible type 'int *'}}
   }
 
   ~X() {
     float *fp = 0;
-    ptr = fp; // expected-error{{incompatible type assigning 'float *', expected 'int *'}}
+    ptr = fp; // expected-error{{assigning to 'int *' from incompatible type 'float *'}}
   }
 };
 
diff --git a/test/FixIt/fixit-objc.m b/test/FixIt/fixit-objc.m
index 665ac74441..072d50a69b 100644
--- a/test/FixIt/fixit-objc.m
+++ b/test/FixIt/fixit-objc.m
@@ -27,7 +27,7 @@ void h(id a);
 void f(Test *t) {
   NSString *a = "Foo";
   id b = "Foo";
-  A* c = "Foo"; // expected-warning {{incompatible pointer types initializing 'char [4]', expected 'A *'}}
+  A* c = "Foo"; // expected-warning {{incompatible pointer types initializing 'A *' from an expression of type 'char [4]'}}
   g("Foo");
   h("Foo");
   h(("Foo"));
diff --git a/test/PCH/functions.c b/test/PCH/functions.c
index eb8579ab2e..5d7849e129 100644
--- a/test/PCH/functions.c
+++ b/test/PCH/functions.c
@@ -15,7 +15,7 @@ float *test_f1(int val, double x, double y) {
 }
 
 void test_g0(int *x, float * y) {
-  g0(y); // expected-warning{{incompatible pointer types passing 'float *', expected 'int *'}}
+  g0(y); // expected-warning{{incompatible pointer types passing 'float *' to parameter of type 'int *'}}
   g0(x); 
 }
 
diff --git a/test/PCH/types.c b/test/PCH/types.c
index 1ebc01be6a..5ca6a6893f 100644
--- a/test/PCH/types.c
+++ b/test/PCH/types.c
@@ -66,7 +66,7 @@ int_ptr_ptr ipp = &int_value_ptr;
 // TYPE_TYPEOF_EXPR
 typeof_17 *t17 = &int_value;
 struct S { int x, y; };
-typeof_17 t17_2 = (struct S){1, 2}; // expected-error{{incompatible type initializing}}
+typeof_17 t17_2 = (struct S){1, 2}; // expected-error{{initializing 'typeof_17' (aka 'int') from an expression of incompatible type 'struct S'}}
 
 // TYPE_TYPEOF
 int_ptr_ptr2 ipp2 = &int_value_ptr;
diff --git a/test/Parser/altivec.c b/test/Parser/altivec.c
index c2a32cfa39..6c4601abe9 100644
--- a/test/Parser/altivec.c
+++ b/test/Parser/altivec.c
@@ -81,8 +81,8 @@ void f() {
   gccvector unsigned int gv = v;
   gccvector int gvi = (gccvector int)v;
   __attribute__((vector_size(8))) unsigned int gv8;
-  gv8 = gccv;     // expected-error {{incompatible type assigning '__attribute__((__vector_size__(4 * sizeof(unsigned int)))) unsigned int', expected '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int'}}
-  av = gv8;       // expected-error {{incompatible type assigning '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int', expected '__vector unsigned int'}}
+  gv8 = gccv;     // expected-error {{assigning to '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int' from incompatible type '__attribute__((__vector_size__(4 * sizeof(unsigned int)))) unsigned int'}}
+  av = gv8;       // expected-error {{assigning to '__vector unsigned int' from incompatible type '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int'}}
 
   v = gccv;
   __vector unsigned int tv = gccv;
diff --git a/test/Parser/builtin_types_compatible.c b/test/Parser/builtin_types_compatible.c
index 325615c7ee..ac81e7b08d 100644
--- a/test/Parser/builtin_types_compatible.c
+++ b/test/Parser/builtin_types_compatible.c
@@ -35,7 +35,7 @@ static void test()
   struct xx { int a; } x, y;
   
   c = __builtin_choose_expr(a+3-7, b, x); // expected-error{{'__builtin_choose_expr' requires a constant expression}}
-  c = __builtin_choose_expr(0, b, x); // expected-error{{incompatible type assigning 'struct xx', expected 'int'}}
+  c = __builtin_choose_expr(0, b, x); // expected-error{{assigning to 'int' from incompatible type 'struct xx'}}
   c = __builtin_choose_expr(5+3-7, b, x);
   y = __builtin_choose_expr(4+3-7, b, x);
 
diff --git a/test/Parser/cxx-altivec.cpp b/test/Parser/cxx-altivec.cpp
index 3610c0e049..13a270b8e6 100644
--- a/test/Parser/cxx-altivec.cpp
+++ b/test/Parser/cxx-altivec.cpp
@@ -81,8 +81,8 @@ void f() {
   gccvector unsigned int gv = v;
   gccvector int gvi = (gccvector int)v;
   __attribute__((vector_size(8))) unsigned int gv8;
-  gv8 = gccv;     // expected-error {{incompatible type assigning '__attribute__((__vector_size__(4 * sizeof(unsigned int)))) unsigned int', expected '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int'}}
-  av = gv8;       // expected-error {{incompatible type assigning '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int', expected '__vector unsigned int'}}
+  gv8 = gccv;     // expected-error {{assigning to '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int' from incompatible type '__attribute__((__vector_size__(4 * sizeof(unsigned int)))) unsigned int'}}
+  av = gv8;       // expected-error {{assigning to '__vector unsigned int' from incompatible type '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int'}}
 
   v = gccv;
   __vector unsigned int tv = gccv;
diff --git a/test/Parser/declarators.c b/test/Parser/declarators.c
index 91803c1c5d..31712af26c 100644
--- a/test/Parser/declarators.c
+++ b/test/Parser/declarators.c
@@ -53,7 +53,7 @@ myenum c;      // expected-error {{must use 'enum' tag to refer to type 'myenum'
 float *test7() {
   // We should recover 'b' by parsing it with a valid type of "struct xyz", which
   // allows us to diagnose other bad things done with y, such as this.
-  return &b.y;   // expected-warning {{incompatible pointer types returning 'int *', expected 'float *'}}
+  return &b.y;   // expected-warning {{incompatible pointer types returning 'int *' from a function with result type 'float *'}}
 }
 
 struct xyz test8() { return a; }  // a should be be marked invalid, no diag.
diff --git a/test/Parser/implicit-casts.c b/test/Parser/implicit-casts.c
index 900b4ece8b..a2b31f929f 100644
--- a/test/Parser/implicit-casts.c
+++ b/test/Parser/implicit-casts.c
@@ -14,7 +14,7 @@ void test2() {
 }
 int test3() {
   int a[2];
-  a[0] = test3; // expected-warning{{incompatible pointer to integer conversion assigning 'int ()', expected 'int'}}
+  a[0] = test3; // expected-warning{{incompatible pointer to integer conversion assigning to 'int' from 'int ()'}}
   return 0;
 }
 short x; void test4(char c) { x += c; }
diff --git a/test/Sema/address_spaces.c b/test/Sema/address_spaces.c
index badd2383ab..6258114578 100644
--- a/test/Sema/address_spaces.c
+++ b/test/Sema/address_spaces.c
@@ -37,6 +37,6 @@ struct _st {
 __attribute__((address_space(256))) void * * const base = 0;
 void * get_0(void) {
   return base[0];  // expected-error {{illegal implicit cast between two pointers with different address spaces}} \
-                      expected-warning {{returning 'void __attribute__((address_space(256))) *' discards qualifiers, expected 'void *'}}
+                      expected-warning {{returning 'void __attribute__((address_space(256))) *' from a function with result type 'void *' discards qualifiers}}
 }
 
diff --git a/test/Sema/anonymous-struct-union.c b/test/Sema/anonymous-struct-union.c
index 118854fd47..b91426ca6c 100644
--- a/test/Sema/anonymous-struct-union.c
+++ b/test/Sema/anonymous-struct-union.c
@@ -101,4 +101,4 @@ struct s2 {
 typedef struct {
   int x;
 } a_struct;
-int tmp = (a_struct) { .x = 0 }; // expected-error {{incompatible type initializing 'a_struct', expected 'int'}}
+int tmp = (a_struct) { .x = 0 }; // expected-error {{initializing 'int' from an expression of incompatible type 'a_struct'}}
diff --git a/test/Sema/array-constraint.c b/test/Sema/array-constraint.c
index 66f15c3a3c..8b577fa5d7 100644
--- a/test/Sema/array-constraint.c
+++ b/test/Sema/array-constraint.c
@@ -46,7 +46,7 @@ typedef int TA[I]; // expected-error {{variable length array declaration not all
 void strFunc(char *);
 const char staticAry[] = "test";
 void checkStaticAry() { 
-  strFunc(staticAry); // expected-warning{{passing 'char const [5]' discards qualifiers, expected 'char *'}}
+  strFunc(staticAry); // expected-warning{{passing 'char const [5]' to parameter of type 'char *' discards qualifiers}}
 }
 
 
diff --git a/test/Sema/array-init.c b/test/Sema/array-init.c
index 45d3183852..ac45ff77c8 100644
--- a/test/Sema/array-init.c
+++ b/test/Sema/array-init.c
@@ -9,7 +9,7 @@ int ary2[] = { x, y, z }; // expected-error{{initializer element is not a compil
 
 extern int fileScopeExtern[3] = { 1, 3, 5 }; // expected-warning{{'extern' variable has an initializer}}
 
-static long ary3[] = { 1, "abc", 3, 4 }; // expected-warning{{incompatible pointer to integer conversion initializing 'char [4]', expected 'long'}}
+static long ary3[] = { 1, "abc", 3, 4 }; // expected-warning{{incompatible pointer to integer conversion initializing 'long' from an expression of type 'char [4]'}}
 
 void func() {
   int x = 1;
@@ -44,11 +44,11 @@ void func() {
     int a,b,c;
   } z = { 1 };
 
-  struct threeElements *p = 7; // expected-warning{{incompatible integer to pointer conversion initializing 'int', expected 'struct threeElements *'}}
+  struct threeElements *p = 7; // expected-warning{{incompatible integer to pointer conversion initializing 'struct threeElements *' from an expression of type 'int'}}
   
   extern int blockScopeExtern[3] = { 1, 3, 5 }; // expected-error{{'extern' variable cannot have an initializer}}
   
-  static long x2[3] = { 1.0, "abc" , 5.8 }; // expected-warning{{incompatible pointer to integer conversion initializing 'char [4]', expected 'long'}}
+  static long x2[3] = { 1.0, "abc" , 5.8 }; // expected-warning{{incompatible pointer to integer conversion initializing 'long' from an expression of type 'char [4]'}}
 }
 
 void test() {
@@ -155,10 +155,10 @@ void charArrays() {
   char c[] = { "Hello" };
   int l[sizeof(c) == 6 ? 1 : -1];
   
-  int i[] = { "Hello "}; // expected-warning{{incompatible pointer to integer conversion initializing 'char [7]', expected 'int'}}
+  int i[] = { "Hello "}; // expected-warning{{incompatible pointer to integer conversion initializing 'int' from an expression of type 'char [7]'}}
   char c2[] = { "Hello", "Good bye" }; //expected-warning{{excess elements in char array initializer}}
 
-  int i2[1] = { "Hello" }; //expected-warning{{incompatible pointer to integer conversion initializing 'char [6]', expected 'int'}}
+  int i2[1] = { "Hello" }; //expected-warning{{incompatible pointer to integer conversion initializing 'int' from an expression of type 'char [6]'}}
   char c3[5] = { "Hello" };
   char c4[4] = { "Hello" }; //expected-warning{{initializer-string for char array is too long}}
 
@@ -191,12 +191,12 @@ void autoStructTest() {
 struct s1 {char a; char b;} t1;
 struct s2 {struct s1 c;} t2 = { t1 };
 // The following is a less than great diagnostic (though it's on par with EDG).
-struct s1 t3[] = {t1, t1, "abc", 0}; //expected-warning{{incompatible pointer to integer conversion initializing 'char [4]', expected 'char'}}
+struct s1 t3[] = {t1, t1, "abc", 0}; //expected-warning{{incompatible pointer to integer conversion initializing 'char' from an expression of type 'char [4]'}}
 int t4[sizeof t3 == 6 ? 1 : -1];
 }
 struct foo { int z; } w;
 int bar (void) { 
-  struct foo z = { w }; //expected-error{{incompatible type initializing 'struct foo', expected 'int'}}
+  struct foo z = { w }; //expected-error{{initializing 'int' from an expression of incompatible type 'struct foo'}}
   return z.z; 
 } 
 struct s3 {void (*a)(void);} t5 = {autoStructTest};
diff --git a/test/Sema/block-call.c b/test/Sema/block-call.c
index 0aba75e14a..01906bc4f2 100644
--- a/test/Sema/block-call.c
+++ b/test/Sema/block-call.c
@@ -13,7 +13,7 @@ int main() {
   int (^IFP) () = PFR; // OK
 
 
-  const int (^CIC) () = IFP; // expected-error {{incompatible block pointer types initializing 'int (^)()', expected 'int const (^)()'}}
+  const int (^CIC) () = IFP; // expected-error {{incompatible block pointer types initializing 'int const (^)()' from an expression of type 'int (^)()'}}
 
   const int (^CICC) () = CIC;
 
@@ -21,7 +21,7 @@ int main() {
 
   int * const (^IPCC1) () = IPCC;
 
-  int * (^IPCC2) () = IPCC;       // expected-error {{incompatible block pointer types initializing 'int *const (^)()', expected 'int *(^)()'}}
+  int * (^IPCC2) () = IPCC;       // expected-error {{incompatible block pointer types initializing 'int *(^)()' from an expression of type 'int *const (^)()'}}
 
   int (^IPCC3) (const int) = PFR;
 
@@ -29,14 +29,14 @@ int main() {
 
   int (^IPCC5) (int, char (^CArg) (double)) = IPCC4;
 
-  int (^IPCC6) (int, char (^CArg) (float))  = IPCC4; // expected-error {{incompatible block pointer types initializing 'int (^)(int, char (^)(double))', expected 'int (^)(int, char (^)(float))'}}
+  int (^IPCC6) (int, char (^CArg) (float))  = IPCC4; // expected-error {{incompatible block pointer types initializing 'int (^)(int, char (^)(float))' from an expression of type 'int (^)(int, char (^)(double))'}}
 
   IPCC2 = 0;
-  IPCC2 = 1; // expected-error {{invalid conversion assigning integer 'int', expected block pointer 'int *(^)()'}}
+  IPCC2 = 1; // expected-error {{invalid block pointer conversion assigning to 'int *(^)()' from 'int'}}
   int (^x)() = 0;
-  int (^y)() = 3;   // expected-error {{invalid conversion initializing integer 'int', expected block pointer 'int (^)()'}}
+  int (^y)() = 3;   // expected-error {{invalid block pointer conversion initializing 'int (^)()' from an expression of type 'int'}}
   int a = 1;
-  int (^z)() = a+4;   // expected-error {{invalid conversion initializing integer 'int', expected block pointer 'int (^)()'}}
+  int (^z)() = a+4;   // expected-error {{invalid block pointer conversion initializing 'int (^)()' from an expression of type 'int'}}
 }
 
 int blah() {
diff --git a/test/Sema/block-misc.c b/test/Sema/block-misc.c
index ca71ab12b2..e31cdb5bcd 100644
--- a/test/Sema/block-misc.c
+++ b/test/Sema/block-misc.c
@@ -144,7 +144,7 @@ void foo(long (^comp)()) {
 
 void (^test15f)(void);
 void test15() {
-  foo(^{ return LESS; }); // expected-error {{incompatible block pointer types passing 'int (^)(void)', expected 'long (^)()'}}
+  foo(^{ return LESS; }); // expected-error {{incompatible block pointer types passing 'int (^)(void)' to parameter of type 'long (^)()'}}
 }
 
 __block int test16i;  // expected-error {{__block attribute not allowed, only allowed on local variables}}
diff --git a/test/Sema/block-return.c b/test/Sema/block-return.c
index 2385106630..f4eff65ed4 100644
--- a/test/Sema/block-return.c
+++ b/test/Sema/block-return.c
@@ -4,7 +4,7 @@ typedef void (^CL)(void);
 
 CL foo() {
   short y;
-  short (^add1)(void) = ^{ return y+1; }; // expected-error {{incompatible block pointer types initializing 'int (^)(void)', expected 'short (^)(void)'}}
+  short (^add1)(void) = ^{ return y+1; }; // expected-error {{incompatible block pointer types initializing 'short (^)(void)' from an expression of type 'int (^)(void)'}}
 
   CL X = ^{
     if (2)
@@ -26,7 +26,7 @@ CL foo() {
       return (char*)0;
   };
 
-  double (^A)(void) = ^ { // expected-error {{incompatible block pointer types initializing 'float (^)(void)', expected 'double (^)(void)'}}
+  double (^A)(void) = ^ { // expected-error {{incompatible block pointer types initializing 'double (^)(void)' from an expression of type 'float (^)(void)'}}
     if (1)
       return (float)1.0;
     else
@@ -38,10 +38,10 @@ CL foo() {
     if (3)
       return "";
     else
-      return 2; // expected-warning {{incompatible integer to pointer conversion returning 'int', expected 'char *'}}
+