653 lines · cpp
1// RUN: %clang_cc1 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s2// RUN: %clang_cc1 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s3// RUN: %clang_cc1 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify %s4// RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s5// RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s6// RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s7 8// C++0x [class.access]p4:9 10// Access control is applied uniformly to all names, whether the11// names are referred to from declarations or expressions. In the12// case of overloaded function names, access control is applied to13// the function selected by overload resolution.14 15class Public {} PublicInst;16class Protected {} ProtectedInst;17class Private {} PrivateInst;18 19namespace test0 {20 class A {21 public:22 void foo(Public&);23 protected:24 void foo(Protected&); // expected-note 4 {{declared protected here}}25 private:26 void foo(Private&); // expected-note 4 {{declared private here}}27 };28 29 class B : public A {};30 31 void test(A *op) {32 op->foo(PublicInst);33 op->foo(ProtectedInst); // expected-error {{'foo' is a protected member}}34 op->foo(PrivateInst); // expected-error {{'foo' is a private member}}35 36 void (A::*a)(Public&) = &A::foo;37 void (A::*b)(Protected&) = &A::foo; // expected-error {{'foo' is a protected member}}38 void (A::*c)(Private&) = &A::foo; // expected-error {{'foo' is a private member}}39 }40 41 void test(B *op) {42 op->foo(PublicInst);43 op->foo(ProtectedInst); // expected-error {{'foo' is a protected member}}44 op->foo(PrivateInst); // expected-error {{'foo' is a private member}}45 46 void (B::*a)(Public&) = &B::foo;47 void (B::*b)(Protected&) = &B::foo; // expected-error {{'foo' is a protected member}}48 void (B::*c)(Private&) = &B::foo; // expected-error {{'foo' is a private member}}49 }50}51 52// Member operators.53namespace test1 {54 class A {55 public:56 void operator+(Public&);57 void operator[](Public&);58 void operator()(Public&);59 typedef void (*PublicSurrogate)(Public&);60 operator PublicSurrogate() const;61 protected:62 void operator+(Protected&); // expected-note {{declared protected here}}63 void operator[](Protected&); // expected-note {{declared protected here}}64 void operator()(Protected&); // expected-note {{declared protected here}}65 typedef void (*ProtectedSurrogate)(Protected&);66 operator ProtectedSurrogate() const; // expected-note {{declared protected here}}67 private:68 void operator+(Private&); // expected-note {{declared private here}}69 void operator[](Private&); // expected-note {{declared private here}}70 void operator()(Private&); // expected-note {{declared private here}}71 void operator-(); // expected-note {{declared private here}}72 typedef void (*PrivateSurrogate)(Private&);73 operator PrivateSurrogate() const; // expected-note {{declared private here}}74 };75 void operator+(const A &, Public&);76 void operator+(const A &, Protected&);77 void operator+(const A &, Private&);78 void operator-(const A &);79 80 void test(A &a, Public &pub, Protected &prot, Private &priv) {81 a + pub;82 a + prot; // expected-error {{'operator+' is a protected member}}83 a + priv; // expected-error {{'operator+' is a private member}}84 a[pub];85 a[prot]; // expected-error {{'operator[]' is a protected member}}86 a[priv]; // expected-error {{'operator[]' is a private member}}87 a(pub);88 a(prot); // expected-error {{'operator()' is a protected member}}89 a(priv); // expected-error {{'operator()' is a private member}}90 -a; // expected-error {{'operator-' is a private member}}91 92 const A &ca = a;93 ca + pub;94 ca + prot;95 ca + priv;96 -ca;97 // These are all surrogate calls98 ca(pub);99 ca(prot); // expected-error {{'operator void (*)(Protected &)' is a protected member}}100 ca(priv); // expected-error {{'operator void (*)(Private &)' is a private member}}101 }102}103 104// Implicit constructor calls.105namespace test2 {106 class A {107 private:108 A(); // expected-note 1+{{declared private here}}109 110 static A foo;111 };112 113 A a; // expected-error {{calling a private constructor}}114 A A::foo; // okay115 116#if __cplusplus < 201103L117 class B : A { }; // expected-error {{base class 'A' has private default constructor}}118 B b; // expected-note{{implicit default constructor}}119 120 class C : virtual A { 121 public:122 C();123 };124 125 class D : C { }; // expected-error {{inherited virtual base class 'A' has private default constructor}}126 D d; // expected-note{{implicit default constructor}}127#else128 class B : A { }; // expected-note {{base class 'A' has an inaccessible default constructor}}129 B b; // expected-error {{call to implicitly-deleted default constructor}}130 131 // FIXME: Do a better job of explaining how we get here from class D.132 class C : virtual A { // expected-note {{default constructor of 'D' is implicitly deleted because base class 'A' has an inaccessible default constructor}}133 public:134 C();135 };136 137 class D : C { };138 D d; // expected-error {{call to implicitly-deleted default constructor}}139#endif140}141 142// Implicit destructor calls.143namespace test3 {144 class A {145 private:146 ~A(); // expected-note 2 {{declared private here}}147 static A foo;148 };149 150 A a; // expected-error {{variable of type 'A' has private destructor}}151 A A::foo;152 153 void foo(A param) { // okay154 A local; // expected-error {{variable of type 'A' has private destructor}}155 }156 157#if __cplusplus < 201103L && !defined(_MSC_VER)158 template <unsigned N> class Base { ~Base(); }; // expected-note 14 {{declared private here}}159 class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 3 {{declared private here}} \160 // expected-error {{base class 'Base<2>' has private destructor}}161 class Base3 : virtual Base<3> { public: ~Base3(); }; // expected-error {{base class 'Base<3>' has private destructor}}162 163 // These don't cause diagnostics because we don't need the destructor.164 class Derived0 : Base<0> { ~Derived0(); };165 class Derived1 : Base<1> { };166 167 class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \168 // expected-error {{inherited virtual base class 'Base<3>' has private destructor}}169 Base<0>, // expected-error {{base class 'Base<0>' has private destructor}}170 virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}171 Base2, // expected-error {{base class 'Base2' has private destructor}}172 virtual Base3173 {174 ~Derived2() {}175 };176 177 class Derived3 : // expected-error 2 {{inherited virtual base class 'Base<2>' has private destructor}} \178 // expected-error 2 {{inherited virtual base class 'Base<3>' has private destructor}} \179 // expected-note 2{{implicit default constructor}}180 Base<0>, // expected-error 2 {{base class 'Base<0>' has private destructor}}181 virtual Base<1>, // expected-error 2 {{base class 'Base<1>' has private destructor}}182 Base2, // expected-error 2 {{base class 'Base2' has private destructor}}183 virtual Base3184 {};185 Derived3 d3; // expected-note{{implicit destructor}}} \186 // expected-note 3 {{implicit default constructor}}187#elif __cplusplus < 201103L && defined(_MSC_VER)188 template <unsigned N> class Base { ~Base(); }; // expected-note 14 {{declared private here}}189 class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 3 {{declared private here}} \190 // expected-error {{base class 'Base<2>' has private destructor}}191 class Base3 : virtual Base<3> { public: ~Base3(); }; // expected-error {{base class 'Base<3>' has private destructor}}192 193 // These don't cause diagnostics because we don't need the destructor.194 class Derived0 : Base<0> { ~Derived0(); };195 class Derived1 : Base<1> { };196 197 class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \198 // expected-error {{inherited virtual base class 'Base<3>' has private destructor}}199 Base<0>, // expected-error {{base class 'Base<0>' has private destructor}}200 virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}201 Base2, // expected-error {{base class 'Base2' has private destructor}}202 virtual Base3203 {204 ~Derived2() {} // expected-note 2{{in implicit destructor}}205 };206 207 class Derived3 : // expected-error 2 {{inherited virtual base class 'Base<2>' has private destructor}} \208 // expected-error 2 {{inherited virtual base class 'Base<3>' has private destructor}}209 Base<0>, // expected-error 2 {{base class 'Base<0>' has private destructor}}210 virtual Base<1>, // expected-error 2 {{base class 'Base<1>' has private destructor}}211 Base2, // expected-error 2 {{base class 'Base2' has private destructor}}212 virtual Base3213 {};214 Derived3 d3; // expected-note{{implicit destructor}}} expected-note {{implicit default constructor}}215#elif __cplusplus >= 201103L && !defined(_MSC_VER)216 template <unsigned N> class Base { ~Base(); }; // expected-note 4{{declared private here}}217 class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 1{{declared private here}}218 class Base3 : virtual Base<3> { public: ~Base3(); };219 220 // These don't cause diagnostics because we don't need the destructor.221 class Derived0 : Base<0> { ~Derived0(); };222 class Derived1 : Base<1> { };223 224 class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \225 // expected-error {{inherited virtual base class 'Base<3>' has private destructor}}226 Base<0>, // expected-error {{base class 'Base<0>' has private destructor}}227 virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}228 Base2, // expected-error {{base class 'Base2' has private destructor}}229 virtual Base3230 {231 ~Derived2() {}232 };233 234 class Derived3 :235 Base<0>, // expected-note {{deleted because base class 'Base<0>' has an inaccessible destructor}}236 virtual Base<1>,237 Base2,238 virtual Base3239 {};240 Derived3 d3; // expected-error {{implicitly-deleted default constructor}}241#elif __cplusplus >= 201103L && defined(_MSC_VER)242 template <unsigned N> class Base { ~Base(); }; // expected-note 6{{declared private here}}243 // expected-error@+1 {{inherited virtual base class 'Base<2>' has private destructor}}244 class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 1{{declared private here}}245 // expected-error@+1 {{inherited virtual base class 'Base<3>' has private destructor}}246 class Base3 : virtual Base<3> { public: ~Base3(); };247 248 // These don't cause diagnostics because we don't need the destructor.249 class Derived0 : Base<0> { ~Derived0(); };250 class Derived1 : Base<1> { };251 252 class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \253 // expected-error {{inherited virtual base class 'Base<3>' has private destructor}}254 Base<0>, // expected-error {{base class 'Base<0>' has private destructor}}255 virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}256 Base2, // expected-error {{base class 'Base2' has private destructor}}257 virtual Base3258 {259 // expected-note@+2 {{in implicit destructor for 'test3::Base2' first required here}}260 // expected-note@+1 {{in implicit destructor for 'test3::Base3' first required here}}261 ~Derived2() {}262 };263 264 class Derived3 :265 Base<0>, // expected-note {{deleted because base class 'Base<0>' has an inaccessible destructor}}266 virtual Base<1>,267 Base2,268 virtual Base3269 {};270 Derived3 d3; // expected-error {{implicitly-deleted default constructor}}271#else272#error "missing case of MSVC cross C++ versions"273#endif274}275 276// Conversion functions.277namespace test4 {278 class Base {279 private:280 operator Private(); // expected-note 4 {{declared private here}}281 public:282 operator Public(); // expected-note 2{{member is declared here}}283 };284 285 class Derived1 : private Base { // expected-note {{constrained by private inheritance}}286 Private test1() { return *this; } // expected-error {{'operator Private' is a private member}}287 Public test2() { return *this; }288 };289 Private test1(Derived1 &d) { return d; } // expected-error {{'operator Private' is a private member}}290 Public test2(Derived1 &d) { return d; } // expected-error {{'operator Public' is a private member}}291 292 293 class Derived2 : public Base {294 Private test1() { return *this; } // expected-error {{'operator Private' is a private member}}295 Public test2() { return *this; }296 };297 Private test1(Derived2 &d) { return d; } // expected-error {{'operator Private' is a private member}}298 Public test2(Derived2 &d) { return d; }299 300 class Derived3 : private Base { // expected-note {{constrained by private inheritance here}}301 public:302 operator Private();303 };304 Private test1(Derived3 &d) { return d; }305 Public test2(Derived3 &d) { return d; } // expected-error {{'operator Public' is a private member of 'test4::Base'}}306 307 class Derived4 : public Base {308 public:309 operator Private();310 };311 Private test1(Derived4 &d) { return d; }312 Public test2(Derived4 &d) { return d; }313}314 315// Implicit copy assignment operator uses.316namespace test5 {317 class A {318 void operator=(const A &);319#if __cplusplus < 201103L320 // expected-note@-2 2{{implicitly declared private here}}321#endif322 };323 324#if __cplusplus < 201103L325 class Test1 { A a; }; // expected-error {{private member}}326 void test1() {327 Test1 a; 328 a = Test1(); // expected-note{{implicit copy}}329 }330 331 class Test2 : A {}; // expected-error {{private member}}332 void test2() {333 Test2 a;334 a = Test2(); // expected-note{{implicit copy}}335 }336#else337 class Test1 { A a; }; // expected-note {{because field 'a' has an inaccessible copy assignment operator}}338 void test1() {339 Test1 a; 340 a = Test1(); // expected-error {{copy assignment operator is implicitly deleted}}341 }342 343 class Test2 : A {}; // expected-note {{because base class 'A' has an inaccessible copy assignment operator}}344 void test2() {345 Test2 a;346 a = Test2(); // expected-error {{copy assignment operator is implicitly deleted}}347 }348#endif349}350 351// Implicit copy constructor uses.352namespace test6 {353 class A {354 public: A();355 private: A(const A &);356#if __cplusplus < 201103L357 // expected-note@-2 2{{declared private here}}358#endif359 };360 361#if __cplusplus < 201103L362 class Test1 { A a; }; // expected-error {{field of type 'A' has private copy constructor}}363 void test1(const Test1 &t) {364 Test1 a = t; // expected-note{{implicit copy}}365 }366 367 class Test2 : A {}; // expected-error {{base class 'A' has private copy constructor}}368 void test2(const Test2 &t) {369 Test2 a = t; // expected-note{{implicit copy}}370 }371#else372 class Test1 { A a; }; // expected-note {{field 'a' has an inaccessible copy constructor}}373 void test1(const Test1 &t) {374 Test1 a = t; // expected-error{{implicitly-deleted}}375 }376 377 class Test2 : A {}; // expected-note {{base class 'A' has an inaccessible copy constructor}}378 void test2(const Test2 &t) {379 Test2 a = t; // expected-error{{implicitly-deleted}}380 }381#endif382}383 384// Redeclaration lookups are not accesses.385namespace test7 {386 class A {387 int private_member;388 };389 class B : A {390 int foo(int private_member) {391 return 0;392 }393 };394}395 396// Ignored operator new and delete overloads are not 397namespace test8 {398 typedef __typeof__(sizeof(int)) size_t;399 400 class A {401 void *operator new(size_t s);402 void operator delete(void *p);403 public:404 void *operator new(size_t s, int n);405 void operator delete(void *p, int n);406 };407 408 void test() {409 new (2) A();410 }411}412 413// Don't silently upgrade forbidden-access paths to private.414namespace test9 {415 class A {416 public: static int x; // expected-note {{member is declared here}}417 };418 class B : private A { // expected-note {{constrained by private inheritance here}}419 };420 class C : public B {421 static int getX() { return x; } // expected-error {{'x' is a private member of 'test9::A'}}422 };423}424 425namespace test10 {426 class A {427 enum {428 value = 10 // expected-note {{declared private here}}429 };430 friend class C;431 };432 433 class B {434 enum {435 value = A::value // expected-error {{'value' is a private member of 'test10::A'}}436 };437 };438 439 class C {440 enum {441 value = A::value442 };443 };444}445 446namespace test11 {447 class A {448 protected: virtual ~A();449 };450 451 class B : public A {452 ~B();453 };454 455 B::~B() {};456}457 458namespace test12 {459 class A {460 int x;461 462 void foo() {463 class Local {464 int foo(A *a) {465 return a->x;466 }467 };468 }469 };470}471 472namespace test13 {473 struct A {474 int x;475 unsigned foo() const;476 };477 478 struct B : protected A {479 using A::foo;480 using A::x;481 };482 483 void test() {484 A *d;485 d->foo();486 (void) d->x;487 }488}489 490// Destructors for temporaries.491namespace test14 {492 class A {493 private: ~A(); // expected-note {{declared private here}}494 };495 A foo();496 497 void test() {498 foo(); // expected-error {{temporary of type 'A' has private destructor}}499 }500 501 class X {502 ~X(); // expected-note {{declared private here}}503 };504 505 struct Y1 {506 operator X();507 };508 509 void g() {510 const X &xr = Y1(); // expected-error{{temporary of type 'X' has private destructor}}511 }512}513 514// PR 7024515namespace test15 {516 template <class T> class A {517 private:518 int private_foo; // expected-note {{declared private here}}519 static int private_sfoo; // expected-note {{declared private here}}520 protected:521 int protected_foo; // expected-note 3 {{declared protected here}} // expected-note {{can only access this member on an object of type 'test15::B<int>'}}522 static int protected_sfoo; // expected-note 3 {{declared protected here}}523 524 int test1(A<int> &a) {525 return a.private_foo; // expected-error {{private member}}526 }527 528 int test2(A<int> &a) {529 return a.private_sfoo; // expected-error {{private member}}530 }531 532 int test3(A<int> &a) {533 return a.protected_foo; // expected-error {{protected member}}534 }535 536 int test4(A<int> &a) {537 return a.protected_sfoo; // expected-error {{protected member}}538 }539 };540 541 template class A<int>;542 template class A<long>; // expected-note 4 {{in instantiation}} 543 544 template <class T> class B : public A<T> {545 // TODO: These first two accesses can be detected as ill-formed at546 // definition time because they're member accesses and A<int> can't547 // be a subclass of B<T> for any T.548 549 int test1(A<int> &a) {550 return a.protected_foo; // expected-error 2 {{protected member}}551 }552 553 int test2(A<int> &a) {554 return a.protected_sfoo; // expected-error {{protected member}}555 }556 557 int test3(B<int> &b) {558 return b.protected_foo; // expected-error {{protected member}}559 }560 561 int test4(B<int> &b) {562 return b.protected_sfoo; // expected-error {{protected member}}563 }564 };565 566 template class B<int>; // expected-note {{in instantiation}}567 template class B<long>; // expected-note 4 {{in instantiation}}568}569 570// PR7281571namespace test16 {572 class A { ~A(); }; // expected-note 2{{declared private here}}573 void b() { throw A(); } // expected-error{{temporary of type 'A' has private destructor}} \574 // expected-error{{exception object of type 'A' has private destructor}}575}576 577namespace test17 {578 class A {579 template <typename T> class Inner { }; // expected-note {{declared private here}}580 };581 582 A::Inner<int> s; // expected-error {{'Inner' is a private member of 'test17::A'}}583}584 585namespace test18 {586 template <class T> class A {}; // expected-note {{member is declared here}}587 class B : A<int> { // expected-note {{constrained by implicitly private inheritance here}}588 A<int> member;589 };590 class C : B {591 A<int> member; // expected-error {{'A' is a private member of 'test18::A<int>'}}592 };593}594 595// PR8325596namespace test19 {597 class A { ~A(); };598 // The destructor is not implicitly referenced here. Contrast to test16, 599 // testing PR7281, earlier in this file.600 void b(A* x) { throw x; }601}602 603// PR7930604namespace test20 {605 class Foo {606 Foo(); // expected-note {{implicitly declared private here}}607 };608 Foo::Foo() {}609 610 void test() {611 Foo a; // expected-error {{calling a private constructor}}612 }613}614 615namespace test21 {616 template <class T> class A {617 void foo();618 void bar();619 class Inner; // expected-note {{implicitly declared private here}}620 public:621 void baz();622 };623 template <class T> class A<T>::Inner {};624 class B {625 template <class T> class A<T>::Inner; // expected-error{{non-friend class member 'Inner' cannot have a qualified name}}626 // expected-error@-1{{forward declaration of class cannot have a nested name specifier}}627 };628 629 void test() {630 A<int>::Inner i; // expected-error {{'Inner' is a private member}}631 }632}633 634namespace rdar8876150 {635 struct A { operator bool(); };636 struct B : private A { using A::operator bool; };637 638 bool f() {639 B b;640 return !b;641 }642}643 644namespace test23 {645 template <typename T> class A {646 A();647 static A instance;648 };649 650 template <typename T> A<T> A<T>::instance;651 template class A<int>;652}653