Fix PR8767, improve diagnostic wording when allocating an object of an

abstract class type.

Patch by Stephen Hines, with a wording tweak from Doug applied by me.

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

include/clang/Basic/DiagnosticSemaKinds.td

@@ -500,7 +500,7 @@ def err_partial_specialization_friend : Error<
 def err_abstract_type_in_decl : Error<
   "%select{return|parameter|variable|field}0 type %1 is an abstract class">;
 def err_allocation_of_abstract_type : Error<
-  "allocation of an object of abstract type %0">;
+  "allocating an object of abstract class type %0">;
 def err_throw_abstract_type : Error<
   "cannot throw an object of abstract type %0">;
 def err_array_of_abstract_type : Error<"array of abstract class type %0">;
@@ -517,7 +517,7 @@ def err_type_defined_in_param_type : Error<
   "%0 can not be defined in a parameter type">;
 
 def note_pure_virtual_function : Note<
-  "pure virtual function %0">;
+  "unimplemented pure virtual method %0 in %1">;
 
 def err_deleted_non_function : Error<
   "only functions can have deleted definitions">;

lib/Sema/SemaDeclCXX.cpp

@@ -2535,7 +2535,7 @@ void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
 
       Diag(SO->second.front().Method->getLocation(), 
            diag::note_pure_virtual_function) 
-        << SO->second.front().Method->getDeclName();
+        << SO->second.front().Method->getDeclName() << RD->getDeclName();
     }
   }
 

test/CXX/class.derived/class.abstract/p4.cpp

@@ -24,7 +24,7 @@ namespace PR6631 {
 // subobject but not pure in another subobject.
 namespace PartlyPure {
   struct A { 
-    virtual void f() = 0; // expected-note{{pure virtual function}}
+    virtual void f() = 0; // expected-note{{unimplemented pure virtual method}}
   };
 
   struct B : A {
@@ -36,7 +36,7 @@ namespace PartlyPure {
   struct D : B, C { };
 
   void f() {
-    (void) new D; // expected-error{{abstract type}}
+    (void) new D; // expected-error{{abstract class}}
   }
 }
 

test/CXX/class.derived/class.abstract/p5.cpp

@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct A {
-  virtual void f() = 0; // expected-note{{pure virtual function}}
+  virtual void f() = 0; // expected-note{{unimplemented pure virtual method}}
 };
 
 struct B : A {
@@ -9,15 +9,15 @@ struct B : A {
 };
 
 struct C : B {
-  virtual void f() = 0; // expected-note 2{{pure virtual function}}
+  virtual void f() = 0; // expected-note 2{{unimplemented pure virtual method}}
 };
 
 struct D : C {
 };
 
 void test() {
-  (void)new A; // expected-error{{object of abstract type}}
+  (void)new A; // expected-error{{abstract class}}
   (void)new B;
-  (void)new C; // expected-error{{object of abstract type}}
-  (void)new D; // expected-error{{object of abstract type}}
+  (void)new C; // expected-error{{abstract class}}
+  (void)new D; // expected-error{{abstract class}}
 }

test/SemaCXX/abstract.cpp

@@ -9,7 +9,7 @@
 #endif
 
 class C {
-  virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
+  virtual void f() = 0; // expected-note {{unimplemented pure virtual method 'f'}}
 };
 
 static_assert(__is_abstract(C), "C has a pure virtual function");
@@ -25,7 +25,7 @@ class E : D {
 
 static_assert(!__is_abstract(E), "E inherits from an abstract class but implements f");
 
-C *d = new C; // expected-error {{allocation of an object of abstract type 'C'}}
+C *d = new C; // expected-error {{allocating an object of type 'C', which is an abstract class}}
 
 C c; // expected-error {{variable type 'C' is an abstract class}}
 void t1(C c); // expected-error {{parameter type 'C' is an abstract class}}
@@ -38,8 +38,8 @@ struct S {
 void t3(const C&);
 
 void f() {
-  C(); // expected-error {{allocation of an object of abstract type 'C'}}
-  t3(C()); // expected-error {{allocation of an object of abstract type 'C'}}
+  C(); // expected-error {{allocating an object of type 'C', which is an abstract class}}
+  t3(C()); // expected-error {{allocating an object of type 'C', which is an abstract class}}
 }
 
 C e1[2]; // expected-error {{array of abstract class type 'C'}}
@@ -64,7 +64,7 @@ class F {
     void u(F c); // expected-error {{parameter type 'F' is an abstract class}}
   };
     
-  virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
+  virtual void f() = 0; // expected-note {{unimplemented pure virtual method 'f'}}
 };
 
 // Diagnosing in these cases is prohibitively expensive.  We still
@@ -193,14 +193,14 @@ namespace test1 {
 // rdar://problem/8302168
 namespace test2 {
   struct X1 {
-    virtual void xfunc(void) = 0;  // expected-note {{pure virtual function}}
+    virtual void xfunc(void) = 0;  // expected-note {{unimplemented pure virtual method}}
     void g(X1 parm7);        // expected-error {{parameter type 'test2::X1' is an abstract class}}
     void g(X1 parm8[2]);     // expected-error {{array of abstract class type 'test2::X1'}}
   };
 
   template <int N>
   struct X2 {
-    virtual void xfunc(void) = 0;  // expected-note {{pure virtual function}}
+    virtual void xfunc(void) = 0;  // expected-note {{unimplemented pure virtual method}}
     void g(X2 parm10);        // expected-error {{parameter type 'X2<N>' is an abstract class}}
     void g(X2 parm11[2]);     // expected-error {{array of abstract class type 'X2<N>'}}
   };
@@ -219,11 +219,11 @@ namespace test3 {
 
   struct C {
     static C x; // expected-error {{abstract class}}
-    virtual void abstract() = 0; // expected-note {{pure virtual function}}
+    virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}}
   };
 
   struct D {
-    virtual void abstract() = 0; // expected-note {{pure virtual function}}
+    virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}}
     static D x; // expected-error {{abstract class}}
   };
 }
@@ -231,21 +231,21 @@ namespace test3 {
 namespace test4 {
   template <class T> struct A {
     A x; // expected-error {{abstract class}}
-    virtual void abstract() = 0; // expected-note {{pure virtual function}}
+    virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}}
   };
 
   template <class T> struct B {
-    virtual void abstract() = 0; // expected-note {{pure virtual function}}
+    virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}}
     B x; // expected-error {{abstract class}}
   };
 
   template <class T> struct C {
     static C x; // expected-error {{abstract class}}
-    virtual void abstract() = 0; // expected-note {{pure virtual function}}
+    virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}}
   };
 
   template <class T> struct D {
-    virtual void abstract() = 0; // expected-note {{pure virtual function}}
+    virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}}
     static D x; // expected-error {{abstract class}}
   };
 }

test/SemaCXX/exceptions.cpp

@@ -2,7 +2,7 @@
 
 struct A; // expected-note 4 {{forward declaration of 'A'}}
 
-struct Abstract { virtual void f() = 0; }; // expected-note {{pure virtual function 'f'}}
+struct Abstract { virtual void f() = 0; }; // expected-note {{unimplemented pure virtual method 'f'}}
 
 void trys() {
   try {
@@ -105,7 +105,7 @@ public:
   void bar () {
     throw *this; // expected-error{{cannot throw an object of abstract type 'foo'}}
   }
-  virtual void test () = 0; // expected-note{{pure virtual function 'test'}}
+  virtual void test () = 0; // expected-note{{unimplemented pure virtual method 'test'}}
 };
 
 namespace PR6831 {

test/SemaCXX/virtual-override.cpp

@@ -167,7 +167,7 @@ void test2() {
 };
 
 struct Foo3 {
-  virtual void f(int) = 0; // expected-note{{pure virtual function}}
+  virtual void f(int) = 0; // expected-note{{unimplemented pure virtual method}}
 };
 
 template<typename T>