[clang] fixed bug #54406

[randyli]

Summary

try to fix bug #54406

Per [class.access.base]/6, this example is ill-formed:

struct A {
  int m;
} a;
struct B : A {};
int n = a.B::m;

... because the object expression a cannot be implicitly converted to B (because B is not a base class of A). Clang does not diagnose this and accepts the member access. This opens a hole in the protected member access rules:

struct C {
protected:
  int m;
};
struct D : private C {
  int get(C &c) { return c.D::m; }
};

This example is invalid for the same reason, but Clang accepts it. ([class.protected]p1, which normally would prevent D from accessing protected members on a C object that is not a D object, does not apply here because m as a member of the naming class D is private, not protected.)

[rjmccall]

clang/lib/Sema/SemaExprMember.cpp

690

We don't generally cite bug numbers in the source code; we just cite the language rule. You can reference the bug number in your test, though.

The standard says that this is an error even when the member access is implicit, so the check for BaseExpr is incorrect.

Conversely, the standard says this is not an error when the declaration referenced is not a non-static data member or member function, so you cannot do this before the lookup; in fact, you cannot do it until we've fully resolved the lookup, which may require contextual information.

All of the code paths that build a non-static member eventually funnel into BuildMemberExpr, so maybe that's the right place for the check? But note that you have to check explicitly for a non-static member, because MemberExpr is used for all of them.

Technically, this rule wasn't in C++98, but since it does appear in C++03, I agree we should just enforce it unconditionally, as we usually treat C++03 as an errata release rather than its own language mode.

[randyli]

clang/lib/Sema/SemaExprMember.cpp

690

ok, thank you for the suggestion, I'll look into BuildMemeberExpr and try again

clang/include/clang/Basic/DiagnosticSemaKinds.td

def ext_nested_name_member_ref_lookup_ambiguous : ExtWarn<
   "lookup of %0 in member access expression is ambiguous; using member of %1">,
   InGroup<AmbigMemberTemplate>;
 def note_ambig_member_ref_object_type : Note<
   "lookup in the object type %0 refers here">;
 def note_ambig_member_ref_scope : Note<
   "lookup from the current scope refers here">;
 def err_qualified_member_nonclass : Error<
   "qualified member access refers to a member in %0">;
+def err_qualified_member_not_base : Error<
+  "%0 is not a base of %1">;
 def err_incomplete_member_access : Error<
   "member access into incomplete type %0">;
 def err_incomplete_type : Error<
   "incomplete type %0 where a complete type is required">;
 def warn_cxx98_compat_enum_nested_name_spec : Warning<
   "enumeration type in nested name specifier is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_nested_name_spec_is_not_class : Error<

clang/lib/Sema/SemaExprMember.cpp

if (SS.isSet()) {
 
     assert(DC && "Cannot handle non-computable dependent contexts in lookup");
 
     if (!isa<TypeDecl>(DC)) {
       SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass)
           << DC << SS.getRange();
       return true;
     }
+    // fix bug #54406
+    // Per [class.access.base]/6, this example is ill-formed:
+    // struct A {
+    //  int m;
+    // } a;
+    // struct B : A {};
+    // int n = a.B::m;
+    if (BaseExpr && isa<CXXRecordDecl>(DC) && isa<CXXRecordDecl>(RDecl)) {
+      CXXRecordDecl *SRecord = cast<CXXRecordDecl>(DC)->getCanonicalDecl();
+      CXXRecordDecl *RRecord = cast<CXXRecordDecl>(RDecl)->getCanonicalDecl();
+      if (SRecord != RRecord && RRecord->isProvablyNotDerivedFrom(SRecord)) {
+        SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_not_base)
+          << DC << RDecl << SS.getRange();
+        return true;
+      }
+    }
   }
 
   // The record definition is complete, now look up the member.
   SemaRef.LookupQualifiedName(R, DC, SS);
 
   if (!R.empty())
     return false;
 

clang/test/CXX/class.access/class.protected/p1.cpp

namespace test8 {
   void D::test() {
     call(&A::foo); // expected-error {{'foo' is a protected member}}
     calls(&A::foo);
   }
 }
 
 namespace test9 {
   class A { // expected-note {{member is declared here}}
-  protected: int foo(); // expected-note 4 {{declared}} expected-note 3 {{can only access this member on an object of type}} expected-note 2 {{member is declared here}}
+  protected: int foo(); // expected-note 2 {{can only access this member on an object of type 'test9::D'}} \
+                        // expected-note 2 {{member is declared here}}
   };
 
   class B : public A { // expected-note {{member is declared here}}
     friend class D;
   };
 
-  class C : protected B { // expected-note {{declared}} \
-                          // expected-note 7 {{constrained}}
+  class C : protected B { // expected-note 5 {{constrained by protected inheritance here}} expected-note {{declared protected here}}
+                    
   };
 
   class D : public A {
     static void test(A &a) {
       a.foo(); // expected-error {{'foo' is a protected member}}
       a.A::foo(); // expected-error {{'foo' is a protected member}}
-      a.B::foo(); // expected-error {{'foo' is a protected member}}
-      a.C::foo(); // expected-error {{'foo' is a protected member}}
-      a.D::foo(); // expected-error {{'foo' is a protected member}}
+      a.B::foo(); // expected-error {{'test9::B' is not a base of 'A'}}
+      a.C::foo(); // expected-error {{'test9::C' is not a base of 'A'}}
+      a.D::foo(); // expected-error {{'test9::D' is not a base of 'A'}}
     }
 
     static void test(B &b) {
       b.foo();
       b.A::foo();
       b.B::foo(); // accessible as named in A
-      b.C::foo(); // expected-error {{'foo' is a protected member}}
+      b.C::foo(); // expected-error {{'test9::C' is not a base of 'B'}}
     }
 
     static void test(C &c) {
       c.foo();    // expected-error {{'foo' is a protected member}}
       c.A::foo(); // expected-error {{'A' is a protected member}} \
                   // expected-error {{cannot cast}}
       c.B::foo(); // expected-error {{'B' is a protected member}} \
                   // expected-error {{cannot cast}}
       c.C::foo(); // expected-error {{'foo' is a protected member}}
     }
 
     static void test(D &d) {
       d.foo();
       d.A::foo();
-      d.B::foo();
-      d.C::foo(); // expected-error {{'foo' is a protected member}}
+      d.B::foo(); // expected-error {{'test9::B' is not a base of 'D'}}
+      d.C::foo(); // expected-error {{'test9::C' is not a base of 'D'}}
     }
   };
 }
 
 namespace test10 {
   template<typename T> class A {
   protected:
     int foo();

clang/test/CXX/drs/dr1xx.cpp

namespace dr140 { // dr140: yes
   void f(int *const) {} // expected-note {{previous}}
   void f(int[3]) {} // expected-error {{redefinition}}
   void g(const int);
   void g(int n) { n = 2; }
 }
 
 namespace dr141 { // dr141: yes
   template<typename T> void f();
-  template<typename T> struct S { int n; }; // expected-note {{'::dr141::S<int>::n' declared here}}
+  template<typename T> struct S { int n; };
   struct A : S<int> {
     template<typename T> void f();
     template<typename T> struct S {};
   } a;
   struct B : S<int> {} b;
   void g() {
     a.f<int>();
-    (void)a.S<int>::n; // expected-error {{no member named 'n' in 'dr141::A::S<int>'; did you mean '::dr141::S<int>::n'?}}
+    (void)a.S<int>::n; // expected-error {{'dr141::A::S<int>' is not a base of 'A'}}
 #if __cplusplus < 201103L
     // expected-error@-2 {{ambiguous}}
     // expected-note@-11 {{lookup from the current scope}}
     // expected-note@-9 {{lookup in the object type}}
 #endif
     b.f<int>(); // expected-error {{no member}} expected-error +{{}}
     (void)b.S<int>::n;
   }

clang/test/CXX/expr/expr.prim/expr.prim.general/p8-0x.cpp

struct str {
     operator decltype(outer())::middle::inner3 ();
     str(int (decltype(outer::middle::inner())::*n)(),
              int (decltype(outer::middle())::inner::*o)(),
              int (decltype(outer())::middle::inner::*p)());
   };
 
   decltype(outer::middle::inner()) a;
   void scope() {
-    a.decltype(outer::middle())::mfunc(); // expected-error{{'PR10127::outer::middle::mfunc' is not a member of class 'decltype(outer::middle::inner())'}}
+    a.decltype(outer::middle())::mfunc(); // expected-error{{PR10127::outer::middle' is not a base of 'inner'}}
     a.decltype(outer::middle::inner())::func();
     a.decltype(outer::middle())::inner::func();
     a.decltype(outer())::middle::inner::func();
 
     a.decltype(outer())::middle::inner::~inner();
 
     decltype(outer())::middle::inner().func();
   }

clang/test/SemaCXX/member-expr.cpp

namespace rdar8231724 {
 
   struct X { };
   struct Y : X { };
 
   template<typename T> struct Z { int n; };
 
   void f(Y *y) {
     y->N::X1<int>; // expected-error{{'rdar8231724::N::X1' is not a member of class 'rdar8231724::Y'}}
-    y->Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}}
-    y->template Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}}
+    y->Z<int>::n; // expected-error{{'rdar8231724::Z<int>' is not a base of 'Y'}}
+    y->template Z<int>::n; // expected-error{{'rdar8231724::Z<int>' is not a base of 'Y'}}
 #if __cplusplus <= 199711L // C++03 or earlier modes
     // expected-warning@-2{{'template' keyword outside of a template}}
 #endif
   }
 }
 
 namespace PR9025 {
   struct S { int x; };

clang/test/SemaCXX/qual-id-test.cpp

void fun()
         a.sub::x();
         a.base::x();
 
         a.B::base::x(); // expected-error{{use of undeclared identifier 'B'}}
 
         a.A::sub::x();
         a.A::B::base::x();
 
-        a.bad::x(); // expected-error{{'bad::x' is not a member of class 'A::sub'}}
+        a.bad::x(); // expected-error{{'bad' is not a base of 'sub'}}
 
         a->foo();
         a->member::foo();
         a->A::member::foo();
     }
 
     void fun2()
     {
         A::sub *a;
 
         a->x();
 
         a->sub::x();
         a->base::x();
 
         a->B::base::x(); // expected-error{{use of undeclared identifier 'B'}}
 
         a->A::sub::x();
         a->A::B::base::x();
 
-        a->bad::x(); // expected-error{{'bad::x' is not a member of class 'A::sub'}}
+        a->bad::x(); // expected-error{{'bad' is not a base of 'sub'}}
 
         (*a)->foo();
         (*a)->member::foo();
         (*a)->A::member::foo();
     }
 
     void fun3()
     {
void fun5()
         T a;
         a.x();
         a->foo();
 
         a.A::sub::x();
         a.A::B::base::x();
         a->A::member::foo();
 
-        a.bad::x(); // expected-error{{'bad::x' is not a member of class 'A::sub'}}
+        a.bad::x(); // expected-error{{'bad' is not a base of 'sub'}}
     }
 
   void test_fun5() {
     fun5<A::sub>(); // expected-note{{instantiation}}
   }
   
   template<typename T>
   void fun6() {

clang/test/SemaTemplate/typo-dependent-name.cpp

struct Y {
 
   template<int U>
   struct Inner : Y { // expected-note {{declared here}}
   };
 
   bool f(T other) {
     // We can determine that 'inner' does not exist at parse time, so can
     // perform typo correction in this case.
-    return this->inner<other>::z; // expected-error {{no template named 'inner' in 'Y<T>'; did you mean 'Inner'?}}
+    return this->inner<other>::z; // expected-error {{Y<Q>::Inner<0>' is not a base of 'Y<Q>'}} expected-error {{no template named 'inner' in 'Y<T>'; did you mean 'Inner'?}}
   }
 };
 
 struct Q { constexpr operator int() { return 0; } };
-void use_y(Y<Q> x) { x.f(Q()); }
+void use_y(Y<Q> x) { x.f(Q()); } // expected-note {{in instantiation of member function 'Y<Q>::f' requested here}}