Improve access control diagnostics. Perform access control on member-pointer

conversions.  Fix an access-control bug where privileges were not considered
at intermediate points along the inheritance path.  Prepare for friends.



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

10 files changed, 79 insertions, 69 deletions

diff --git a/test/CXX/class.access/class.access.base/p1.cpp b/test/CXX/class.access/class.access.base/p1.cpp
index fd0d9f68e1..1bbcedb9a1 100644
--- a/test/CXX/class.access/class.access.base/p1.cpp
+++ b/test/CXX/class.access/class.access.base/p1.cpp
@@ -54,13 +54,13 @@ namespace test0 {
 //   of the base class are accessible as protected members of the
 //   derived class.
 namespace test1 {
-  class Base { // expected-note 6 {{constrained by protected inheritance}}
-  public: int pub; static int spub; // expected-note 2 {{constrained by protected inheritance}}
+  class Base {
+  public: int pub; static int spub;
   protected: int prot; static int sprot; // expected-note 4 {{declared protected here}}
   private: int priv; static int spriv; // expected-note 8 {{declared private here}}
   };
 
-  class Test : protected Base {
+  class Test : protected Base { // expected-note 6 {{declared protected here}} expected-note 8 {{constrained by protected inheritance here}}
     void test() {
       pub++;
       spub++;
@@ -79,19 +79,19 @@ namespace test1 {
   };
 
   void test(Test *t) {
-    t->pub++; // expected-error {{protected member}}
+    t->pub++; // expected-error {{protected member}} expected-error {{protected base class}}
     t->spub++; // expected-error {{protected member}}
-    t->prot++; // expected-error {{protected member}}
+    t->prot++; // expected-error {{protected member}} expected-error {{protected base class}}
     t->sprot++; // expected-error {{protected member}}
-    t->priv++; // expected-error {{private member}}
+    t->priv++; // expected-error {{private member}} expected-error {{protected base class}}
     t->spriv++; // expected-error {{private member}}
 
     // Two possible errors here: one for Base, one for the member
-    t->Base::pub++; // expected-error {{protected member}}
+    t->Base::pub++; // expected-error {{protected member}} expected-error {{protected base class}}
     t->Base::spub++; // expected-error {{protected member}}
-    t->Base::prot++; // expected-error 2 {{protected member}}
+    t->Base::prot++; // expected-error 2 {{protected member}} expected-error {{protected base class}}
     t->Base::sprot++; // expected-error 2 {{protected member}}
-    t->Base::priv++; // expected-error {{protected member}} expected-error {{private member}}
+    t->Base::priv++; // expected-error {{protected member}} expected-error {{private member}} expected-error {{protected base class}}
     t->Base::spriv++; // expected-error {{protected member}} expected-error {{private member}}
   }
 }
@@ -102,21 +102,20 @@ namespace test1 {
 //   the base class are accessible as private members of the derived
 //   class.
 namespace test2 {
-  class Base { //expected-note 6 {{constrained by private inheritance}}
+  class Base {
   public:
-    int pub; // expected-note {{constrained by private inheritance}}
-    static int spub; // expected-note {{constrained by private inheritance}}
+    int pub;
+    static int spub;
   protected:
-    int prot; // expected-note {{constrained by private inheritance}} \
-              // expected-note {{declared protected here}}
-    static int sprot; // expected-note {{constrained by private inheritance}} \
-                      // expected-note {{declared protected here}}
+    int prot; // expected-note {{declared protected here}}
+    static int sprot; // expected-note {{declared protected here}}
   private:
     int priv; // expected-note 4 {{declared private here}}
     static int spriv; // expected-note 4 {{declared private here}}
   };
 
-  class Test : private Base { // expected-note 6 {{'private' inheritance specifier here}}
+  class Test : private Base { // expected-note 6 {{declared private here}} \
+                              // expected-note 10 {{constrained by private inheritance here}}
     void test() {
       pub++;
       spub++;
@@ -135,18 +134,18 @@ namespace test2 {
   };
 
   void test(Test *t) {
-    t->pub++; // expected-error {{private member}} expected-error {{inaccessible base class}}
+    t->pub++; // expected-error {{private member}} expected-error {{private base class}}
     t->spub++; // expected-error {{private member}}
-    t->prot++; // expected-error {{private member}} expected-error {{inaccessible base class}}
+    t->prot++; // expected-error {{private member}} expected-error {{private base class}}
     t->sprot++; // expected-error {{private member}}
-    t->priv++; // expected-error {{private member}} expected-error {{inaccessible base class}}
+    t->priv++; // expected-error {{private member}} expected-error {{private base class}}
     t->spriv++; // expected-error {{private member}}
 
-    t->Base::pub++; // expected-error {{private member}} expected-error {{inaccessible base class}}
+    t->Base::pub++; // expected-error {{private member}} expected-error {{private base class}}
     t->Base::spub++; // expected-error {{private member}}
-    t->Base::prot++; // expected-error {{protected member}} expected-error {{private member}} expected-error {{inaccessible base class}}
+    t->Base::prot++; // expected-error {{protected member}} expected-error {{private member}} expected-error {{private base class}}
     t->Base::sprot++; // expected-error {{protected member}} expected-error {{private member}}
-    t->Base::priv++; // expected-error 2 {{private member}} expected-error {{inaccessible base class}}
+    t->Base::priv++; // expected-error 2 {{private member}} expected-error {{private base class}}
     t->Base::spriv++; // expected-error 2 {{private member}}
   }
 }
diff --git a/test/CXX/class.access/p4.cpp b/test/CXX/class.access/p4.cpp
index 83e467d9b9..7aa614cd8b 100644
--- a/test/CXX/class.access/p4.cpp
+++ b/test/CXX/class.access/p4.cpp
@@ -23,12 +23,12 @@ namespace test0 {
 
   void test(A *op) {
     op->foo(PublicInst);
-    op->foo(ProtectedInst); // expected-error {{access to protected member outside any class}}
-    op->foo(PrivateInst); // expected-error {{access to private member outside any class}}
+    op->foo(ProtectedInst); // expected-error {{'foo' is a protected member}}
+    op->foo(PrivateInst); // expected-error {{'foo' is a private member}}
 
     void (A::*a)(Public&) = &A::foo;
-    void (A::*b)(Protected&) = &A::foo; // expected-error {{access to protected member outside any class}}
-    void (A::*c)(Private&) = &A::foo; // expected-error {{access to private member outside any class}}
+    void (A::*b)(Protected&) = &A::foo; // expected-error {{'foo' is a protected member}}
+    void (A::*c)(Private&) = &A::foo; // expected-error {{'foo' is a private member}}
   }
 }
 
@@ -62,15 +62,15 @@ namespace test1 {
 
   void test(A &a, Public &pub, Protected &prot, Private &priv) {
     a + pub;
-    a + prot; // expected-error {{access to protected member}}
-    a + priv; // expected-error {{access to private member}}
+    a + prot; // expected-error {{'operator+' is a protected member}}
+    a + priv; // expected-error {{'operator+' is a private member}}
     a[pub];
-    a[prot]; // expected-error {{access to protected member}}
-    a[priv]; // expected-error {{access to private member}}
+    a[prot]; // expected-error {{'operator[]' is a protected member}}
+    a[priv]; // expected-error {{'operator[]' is a private member}}
     a(pub);
-    a(prot); // expected-error {{access to protected member}}
-    a(priv); // expected-error {{access to private member}}
-    -a;       // expected-error {{access to private member}}
+    a(prot); // expected-error {{'operator()' is a protected member}}
+    a(priv); // expected-error {{'operator()' is a private member}}
+    -a;       // expected-error {{'operator-' is a private member}}
 
     const A &ca = a;
     ca + pub;
@@ -79,8 +79,8 @@ namespace test1 {
     -ca;
     // These are all surrogate calls
     ca(pub);
-    ca(prot); // expected-error {{access to protected member}}
-    ca(priv); // expected-error {{access to private member}}
+    ca(prot); // expected-error {{'operator void (*)(class Protected &)' is a protected member}}
+    ca(priv); // expected-error {{'operator void (*)(class Private &)' is a private member}}
   }
 }
 
@@ -93,7 +93,7 @@ namespace test2 {
     static A foo;
   };
 
-  A a; // expected-error {{access to private member}}
+  A a; // expected-error {{calling a private constructor}}
   A A::foo; // okay
 }
 
@@ -105,10 +105,10 @@ namespace test3 {
     static A foo;
   };
 
-  A a; // expected-error {{access to private member}}
+  A a; // expected-error {{'~A' is a private member}}
   A A::foo;
 
-  void foo(A param) { // expected-error {{access to private member}}
-    A local; // expected-error {{access to private member}}
+  void foo(A param) { // expected-error {{'~A' is a private member}}
+    A local; // expected-error {{'~A' is a private member}}
   }
 }
diff --git a/test/CXX/class.access/p6.cpp b/test/CXX/class.access/p6.cpp
index ce60b3bf04..aaf510a6d1 100644
--- a/test/CXX/class.access/p6.cpp
+++ b/test/CXX/class.access/p6.cpp
@@ -23,7 +23,7 @@ namespace test0 {
     type foo();
   };
 
-  A::type foo() { } // expected-error {{access to private member}}
+  A::type foo() { } // expected-error {{'type' is a private member}}
   A::type A::foo() { }
 }
 
@@ -45,10 +45,10 @@ namespace test1 {
   void test() {
     A a;
     Public pub = a;
-    Protected prot = a; // expected-error {{access to protected member}}
-    Private priv = a; // expected-error {{access to private member}}
+    Protected prot = a; // expected-error {{'operator Protected' is a protected member}}
+    Private priv = a; // expected-error {{'operator Private' is a private member}}
     A apub = pub;
-    A aprot = prot; // expected-error {{access to protected member}}
-    A apriv = priv; // expected-error {{access to private member}}
+    A aprot = prot; // expected-error {{protected constructor}}
+    A apriv = priv; // expected-error {{private constructor}}
   }
 }
diff --git a/test/CXX/class/class.local/p2.cpp b/test/CXX/class/class.local/p2.cpp
index 56ff1e53a4..8d281a57e1 100644
--- a/test/CXX/class/class.local/p2.cpp
+++ b/test/CXX/class/class.local/p2.cpp
@@ -3,9 +3,9 @@
 struct A { };
 
 void f() {
-  struct B : private A {}; // expected-note{{'private' inheritance specifier here}}
+  struct B : private A {}; // expected-note{{declared private here}}
   
   B b;
   
-  A *a = &b; // expected-error{{conversion from 'struct B' to inaccessible base class 'struct A'}}
+  A *a = &b; // expected-error{{cannot cast 'struct B' to its private base class 'struct A'}}
 }
diff --git a/test/CXX/conv/conv.mem/p4.cpp b/test/CXX/conv/conv.mem/p4.cpp
index d782cde25a..1ecbc47ffb 100644
--- a/test/CXX/conv/conv.mem/p4.cpp
+++ b/test/CXX/conv/conv.mem/p4.cpp
@@ -15,12 +15,12 @@ namespace test0 {
   }
 }
 
-// FIXME: can't be inaccessible.
+// Can't be inaccessible.
 namespace test1 {
-  struct Derived : private Base {};
+  struct Derived : private Base {}; // expected-note 2 {{declared private here}}
   void test() {
-    int (Derived::*d) = data_ptr; // error
-    int (Derived::*m)() = method_ptr; // error
+    int (Derived::*d) = data_ptr; // expected-error {{cannot cast private base class 'struct Base' to 'struct test1::Derived'}}
+    int (Derived::*m)() = method_ptr; // expected-error {{cannot cast private base class 'struct Base' to 'struct test1::Derived'}}
   }
 };
 
diff --git a/test/SemaCXX/access-base-class.cpp b/test/SemaCXX/access-base-class.cpp
index f4c58d940b..d0b0fb8ee2 100644
--- a/test/SemaCXX/access-base-class.cpp
+++ b/test/SemaCXX/access-base-class.cpp
@@ -2,10 +2,10 @@
 namespace T1 {
   
 class A { };
-class B : private A { }; // expected-note {{'private' inheritance specifier here}}
+class B : private A { }; // expected-note {{declared private here}}
 
 void f(B* b) {
-  A *a = b; // expected-error{{conversion from 'class T1::B' to inaccessible base class 'class T1::A'}}
+  A *a = b; // expected-error{{cannot cast 'class T1::B' to its private base class 'class T1::A'}}
 }
 
 }
@@ -13,10 +13,10 @@ void f(B* b) {
 namespace T2 { 
 
 class A { };
-class B : A { }; // expected-note {{inheritance is implicitly 'private'}}
+class B : A { }; // expected-note {{implicitly declared private here}}
 
 void f(B* b) {
-  A *a = b; // expected-error {{conversion from 'class T2::B' to inaccessible base class 'class T2::A'}}
+  A *a = b; // expected-error {{cannot cast 'class T2::B' to its private base class 'class T2::A'}}
 }
 
 }
@@ -63,13 +63,13 @@ namespace T6 {
   
   class A {};
   
-  class B : private A { // expected-note {{'private' inheritance specifier here}}
+  class B : private A { // expected-note {{declared private here}}
     void f(C* c);
   };
   
   class C : public B { 
     void f(C *c) {
-      A* a = c; // expected-error {{conversion from 'class T6::C' to inaccessible base class 'class T6::A'}}
+      A* a = c; // expected-error {{cannot cast 'class T6::C' to its private base class 'class T6::A'}}
     }
   };
   
@@ -77,3 +77,14 @@ namespace T6 {
     A *a = c;
   }
 }
+
+namespace T7 {
+  class A {};
+  class B : public A {};
+  class C : private B { 
+    void f(C *c) {
+      A* a = c; // okay
+    }
+  };
+}
+
diff --git a/test/SemaCXX/access-control-check.cpp b/test/SemaCXX/access-control-check.cpp
index cf2d191a29..783d4def53 100644
--- a/test/SemaCXX/access-control-check.cpp
+++ b/test/SemaCXX/access-control-check.cpp
@@ -11,5 +11,5 @@ class P {
 
 class N : M,P {
   N() {}
-  int PR() { return iP + PPR(); } // expected-error 2 {{access to private member of 'class P'}}
+  int PR() { return iP + PPR(); } // expected-error 2 {{private member of 'class P'}}
 };
diff --git a/test/SemaCXX/conditional-expr.cpp b/test/SemaCXX/conditional-expr.cpp
index b71133bfee..b961ff2de9 100644
--- a/test/SemaCXX/conditional-expr.cpp
+++ b/test/SemaCXX/conditional-expr.cpp
@@ -25,7 +25,7 @@ struct Derived : Base {
   void fn2();
 };
 struct Convertible { operator Base&(); };
-struct Priv : private Base {}; // expected-note 4 {{'private' inheritance specifier here}}
+struct Priv : private Base {}; // expected-note 4 {{declared private here}}
 struct Mid : Base {};
 struct Fin : Mid, Derived {};
 typedef void (Derived::*DFnPtr)();
@@ -111,12 +111,12 @@ void test()
 
   Priv priv;
   Fin fin;
-  (void)(i1 ? Base() : Priv()); // expected-error{{conversion from 'struct Priv' to inaccessible base class 'struct Base'}}
-  (void)(i1 ? Priv() : Base()); // expected-error{{error: conversion from 'struct Priv' to inaccessible base class 'struct Base'}}
+  (void)(i1 ? Base() : Priv()); // expected-error{{private base class}}
+  (void)(i1 ? Priv() : Base()); // expected-error{{private base class}}
   (void)(i1 ? Base() : Fin()); // expected-error{{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
   (void)(i1 ? Fin() : Base()); // expected-error{{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
-  (void)(i1 ? base : priv); // expected-error {{conversion from 'struct Priv' to inaccessible base class 'struct Base'}}
-  (void)(i1 ? priv : base); // expected-error {{conversion from 'struct Priv' to inaccessible base class 'struct Base'}}
+  (void)(i1 ? base : priv); // expected-error {{private base class}}
+  (void)(i1 ? priv : base); // expected-error {{private base class}}
   (void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
   (void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
 
diff --git a/test/SemaCXX/static-cast.cpp b/test/SemaCXX/static-cast.cpp
index d41b929ee6..4818b041ad 100644
--- a/test/SemaCXX/static-cast.cpp
+++ b/test/SemaCXX/static-cast.cpp
@@ -4,7 +4,7 @@ struct B : public A {};             // Single public base.
 struct C1 : public virtual B {};    // Single virtual base.
 struct C2 : public virtual B {};
 struct D : public C1, public C2 {}; // Diamond
-struct E : private A {};            // Single private base. expected-note 3 {{'private' inheritance specifier here}}
+struct E : private A {};            // Single private base. expected-note 3 {{declared private here}}
 struct F : public C1 {};            // Single path to B with virtual.
 struct G1 : public B {};
 struct G2 : public B {};
@@ -56,7 +56,7 @@ void t_529_2()
   // Bad code below
 
   (void)static_cast<void*>((const int*)0); // expected-error {{static_cast from 'int const *' to 'void *' is not allowed}}
-  (void)static_cast<A*>((E*)0); // expected-error {{inaccessible base class 'struct A'}}
+  (void)static_cast<A*>((E*)0); // expected-error {{private base class 'struct A'}}
   (void)static_cast<A*>((H*)0); // expected-error {{ambiguous conversion}}
   (void)static_cast<int>((int*)0); // expected-error {{static_cast from 'int *' to 'int' is not allowed}}
   (void)static_cast<A**>((B**)0); // expected-error {{static_cast from 'struct B **' to 'struct A **' is not allowed}}
@@ -86,8 +86,8 @@ void t_529_5_8()
   (void)static_cast<D&>(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'struct D &' via virtual base 'struct B'}}
   (void)static_cast<B*>((const A*)0); // expected-error {{static_cast from 'struct A const *' to 'struct B *' casts away constness}}
   (void)static_cast<B&>(*((const A*)0)); // expected-error {{static_cast from 'struct A const' to 'struct B &' casts away constness}}
-  (void)static_cast<E*>((A*)0); // expected-error {{cannot cast 'struct A' to 'struct E' due to inaccessible}}
-  (void)static_cast<E&>(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'struct E' due to inaccessible}}
+  (void)static_cast<E*>((A*)0); // expected-error {{cannot cast private base class 'struct A' to 'struct E'}}
+  (void)static_cast<E&>(*((A*)0)); // expected-error {{cannot cast private base class 'struct A' to 'struct E'}}
   (void)static_cast<H*>((A*)0); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
   (void)static_cast<H&>(*((A*)0)); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
   (void)static_cast<E*>((B*)0); // expected-error {{static_cast from 'struct B *' to 'struct E *' is not allowed}}
diff --git a/test/SemaCXX/virtual-override.cpp b/test/SemaCXX/virtual-override.cpp
index 5e1e9b0899..6f1d83fd8a 100644
--- a/test/SemaCXX/virtual-override.cpp
+++ b/test/SemaCXX/virtual-override.cpp
@@ -29,14 +29,14 @@ class B : A {
 namespace T3 {
 
 struct a { };
-struct b : private a { }; // expected-note{{'private' inheritance specifier here}}
+struct b : private a { }; // expected-note{{declared private here}}
   
 class A {
   virtual a* f(); // expected-note{{overridden virtual function is here}}
 };
 
 class B : A {
-  virtual b* f(); // expected-error{{return type of virtual function 'f' is not covariant with the return type of the function it overrides (conversion from 'struct T3::b' to inaccessible base class 'struct T3::a')}}
+  virtual b* f(); // expected-error{{invalid covariant return for virtual function: 'struct T3::a' is a private base class of 'struct T3::b'}}
 };
 
 }