Improve on diagnosing type mismatches because of

lack of viable convesion functions.

llvm-svn: 89216

4 files changed, 13 insertions, 13 deletions

diff --git a/clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp b/clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp
index b32948b4a60..88bc813363f 100644
--- a/clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp
+++ b/clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp
@@ -31,7 +31,7 @@ void test() {
 }
 
 namespace Numbers {
-  struct Number {
+  struct Number {	// expected-note 2 {{candidate}}
     explicit Number(double d) : d(d) {}
     double d;
   };
@@ -57,9 +57,9 @@ void test3() {
 
   int i = Ints::zero;
   Numbers2::f(i);
-  Numbers2::g(i); // expected-error {{incompatible type passing 'int'}}
+  Numbers2::g(i); // expected-error {{no viable conversion from 'int' to 'struct Numbers::Number' is possible}}
 
   float f = Floats::zero;
   Numbers2::f(f);
-  Numbers2::g(f); // expected-error {{incompatible type passing 'float'}}
+  Numbers2::g(f); // expected-error {{no viable conversion from 'float' to 'struct Numbers::Number' is possible}}
 }
diff --git a/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp b/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp
index 35e8c08a112..9528c4b99cb 100644
--- a/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp
+++ b/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp
@@ -4,7 +4,7 @@
 
 template <unsigned N> class test {};
 
-class foo {};
+class foo {};	// expected-note {{candidate}}
 test<0> foo(foo); // expected-note {{candidate}}
 
 namespace Test0 {
@@ -38,7 +38,7 @@ namespace Test0 {
       test<2> _1 = (foo)(a);
 
       class Test0::foo b;
-      test<2> _2 = (foo)(b); // expected-error {{incompatible type passing}}
+      test<2> _2 = (foo)(b); // expected-error {{no viable conversion from 'class Test0::foo' to 'class foo' is possible}}
     }
   }
 }
diff --git a/clang/test/SemaCXX/rval-references.cpp b/clang/test/SemaCXX/rval-references.cpp
index a7d26bb4b0e..5132c2a69be 100644
--- a/clang/test/SemaCXX/rval-references.cpp
+++ b/clang/test/SemaCXX/rval-references.cpp
@@ -65,9 +65,9 @@ int&& should_not_warn(int&& i) { // But GCC 4.4 does
 // Test the return dance. This also tests IsReturnCopyElidable.
 struct MoveOnly {
   MoveOnly();
-  MoveOnly(const MoveOnly&) = delete;
-  MoveOnly(MoveOnly&&);
-  MoveOnly(int&&);
+  MoveOnly(const MoveOnly&) = delete;	// expected-note {{candidate function}}
+  MoveOnly(MoveOnly&&);	// expected-note {{candidate function}}
+  MoveOnly(int&&);	// expected-note {{candidate function}}
 };
 
 MoveOnly returning() {
@@ -87,5 +87,5 @@ MoveOnly returningNonEligible() {
   else if (0) // Copy from reference can't be elided
     return r; // expected-error {{incompatible type returning}}
   else // Construction from different type can't be elided
-    return i; // expected-error {{incompatible type returning}}
+    return i; // expected-error {{no viable conversion from 'int' to 'struct MoveOnly'}}
 }
diff --git a/clang/test/SemaTemplate/constructor-template.cpp b/clang/test/SemaTemplate/constructor-template.cpp
index 12c6f8b9c10..203977e9edd 100644
--- a/clang/test/SemaTemplate/constructor-template.cpp
+++ b/clang/test/SemaTemplate/constructor-template.cpp
@@ -53,7 +53,7 @@ struct B { A<int> x; B(B& a) : x(a.x) {} };
 
 struct X2 {
   X2();
-  X2(X2&);
+  X2(X2&);	// expected-note {{candidate function}}
   template<typename T> X2(T);
 };
 
@@ -61,7 +61,7 @@ X2 test(bool Cond, X2 x2) {
   if (Cond)
     return x2; // okay, uses copy constructor
   
-  return X2(); // expected-error{{incompatible type}}
+  return X2(); // expected-error{{no viable conversion from 'struct X2' to 'struct X2' is possible}}
 }
 
 struct X3 {
@@ -73,12 +73,12 @@ template<> X3::X3(X3); // expected-error{{must pass its first argument by refere
 struct X4 {
   X4();
   ~X4();
-  X4(X4&);
+  X4(X4&);	// expected-note {{candidate function}}
   template<typename T> X4(const T&, int = 17);
 };
 
 X4 test_X4(bool Cond, X4 x4) {
   X4 a(x4, 17); // okay, constructor template
   X4 b(x4); // okay, copy constructor
-  return X4(); // expected-error{{incompatible type}}
+  return X4(); // expected-error{{no viable conversion}}
 }