883dbc43d9
member function" context notes to registering an entry on the context stack. Also reorder the steps within defining special members to be consistent. This has a few benefits: if multiple diagnostics are produced while checking such a member, the note is now attached to the first such diagnostic rather than the last, this prepares us for persisting these diagnostics between the point at which we require the implicit instantiation of a template and the point at which that instantiation is actually performed, and this fixes some cases where we would fail to produce a full note stack leading back to user code in the case of such a diagnostic. The reordering exposed a case where we could recursively attempt to define a defaulted destructor while we're already defining one (and other such cases also appear to be possible, with or without this change), so this change also reuses the "willHaveBody" flag on function declarations to track that we're in the middle of synthesizing a body for the function and bails out if we try to define a function that we're already defining. llvm-svn: 303930
587 lines
17 KiB
C++
587 lines
17 KiB
C++
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
|
|
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
|
|
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
|
|
|
|
// C++0x [class.access]p4:
|
|
|
|
// Access control is applied uniformly to all names, whether the
|
|
// names are referred to from declarations or expressions. In the
|
|
// case of overloaded function names, access control is applied to
|
|
// the function selected by overload resolution.
|
|
|
|
class Public {} PublicInst;
|
|
class Protected {} ProtectedInst;
|
|
class Private {} PrivateInst;
|
|
|
|
namespace test0 {
|
|
class A {
|
|
public:
|
|
void foo(Public&);
|
|
protected:
|
|
void foo(Protected&); // expected-note 2 {{declared protected here}}
|
|
private:
|
|
void foo(Private&); // expected-note 2 {{declared private here}}
|
|
};
|
|
|
|
void test(A *op) {
|
|
op->foo(PublicInst);
|
|
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 {{'foo' is a protected member}}
|
|
void (A::*c)(Private&) = &A::foo; // expected-error {{'foo' is a private member}}
|
|
}
|
|
}
|
|
|
|
// Member operators.
|
|
namespace test1 {
|
|
class A {
|
|
public:
|
|
void operator+(Public&);
|
|
void operator[](Public&);
|
|
void operator()(Public&);
|
|
typedef void (*PublicSurrogate)(Public&);
|
|
operator PublicSurrogate() const;
|
|
protected:
|
|
void operator+(Protected&); // expected-note {{declared protected here}}
|
|
void operator[](Protected&); // expected-note {{declared protected here}}
|
|
void operator()(Protected&); // expected-note {{declared protected here}}
|
|
typedef void (*ProtectedSurrogate)(Protected&);
|
|
operator ProtectedSurrogate() const; // expected-note {{declared protected here}}
|
|
private:
|
|
void operator+(Private&); // expected-note {{declared private here}}
|
|
void operator[](Private&); // expected-note {{declared private here}}
|
|
void operator()(Private&); // expected-note {{declared private here}}
|
|
void operator-(); // expected-note {{declared private here}}
|
|
typedef void (*PrivateSurrogate)(Private&);
|
|
operator PrivateSurrogate() const; // expected-note {{declared private here}}
|
|
};
|
|
void operator+(const A &, Public&);
|
|
void operator+(const A &, Protected&);
|
|
void operator+(const A &, Private&);
|
|
void operator-(const A &);
|
|
|
|
void test(A &a, Public &pub, Protected &prot, Private &priv) {
|
|
a + pub;
|
|
a + prot; // expected-error {{'operator+' is a protected member}}
|
|
a + priv; // expected-error {{'operator+' is a private member}}
|
|
a[pub];
|
|
a[prot]; // expected-error {{'operator[]' is a protected member}}
|
|
a[priv]; // expected-error {{'operator[]' is a private member}}
|
|
a(pub);
|
|
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;
|
|
ca + prot;
|
|
ca + priv;
|
|
-ca;
|
|
// These are all surrogate calls
|
|
ca(pub);
|
|
ca(prot); // expected-error {{'operator void (*)(Protected &)' is a protected member}}
|
|
ca(priv); // expected-error {{'operator void (*)(Private &)' is a private member}}
|
|
}
|
|
}
|
|
|
|
// Implicit constructor calls.
|
|
namespace test2 {
|
|
class A {
|
|
private:
|
|
A(); // expected-note 1+{{declared private here}}
|
|
|
|
static A foo;
|
|
};
|
|
|
|
A a; // expected-error {{calling a private constructor}}
|
|
A A::foo; // okay
|
|
|
|
#if __cplusplus < 201103L
|
|
class B : A { }; // expected-error {{base class 'test2::A' has private default constructor}}
|
|
B b; // expected-note{{implicit default constructor}}
|
|
|
|
class C : virtual A {
|
|
public:
|
|
C();
|
|
};
|
|
|
|
class D : C { }; // expected-error {{inherited virtual base class 'test2::A' has private default constructor}}
|
|
D d; // expected-note{{implicit default constructor}}
|
|
#else
|
|
class B : A { }; // expected-note {{base class 'test2::A' has an inaccessible default constructor}}
|
|
B b; // expected-error {{call to implicitly-deleted default constructor}}
|
|
|
|
// FIXME: Do a better job of explaining how we get here from class D.
|
|
class C : virtual A { // expected-note {{default constructor of 'D' is implicitly deleted because base class 'test2::A' has an inaccessible default constructor}}
|
|
public:
|
|
C();
|
|
};
|
|
|
|
class D : C { };
|
|
D d; // expected-error {{call to implicitly-deleted default constructor}}
|
|
#endif
|
|
}
|
|
|
|
// Implicit destructor calls.
|
|
namespace test3 {
|
|
class A {
|
|
private:
|
|
~A(); // expected-note 2 {{declared private here}}
|
|
static A foo;
|
|
};
|
|
|
|
A a; // expected-error {{variable of type 'test3::A' has private destructor}}
|
|
A A::foo;
|
|
|
|
void foo(A param) { // okay
|
|
A local; // expected-error {{variable of type 'test3::A' has private destructor}}
|
|
}
|
|
|
|
#if __cplusplus < 201103L
|
|
template <unsigned N> class Base { ~Base(); }; // expected-note 14 {{declared private here}}
|
|
class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 3 {{declared private here}} \
|
|
// expected-error {{base class 'Base<2>' has private destructor}}
|
|
class Base3 : virtual Base<3> { public: ~Base3(); }; // expected-error {{base class 'Base<3>' has private destructor}}
|
|
|
|
// These don't cause diagnostics because we don't need the destructor.
|
|
class Derived0 : Base<0> { ~Derived0(); };
|
|
class Derived1 : Base<1> { };
|
|
|
|
class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \
|
|
// expected-error {{inherited virtual base class 'Base<3>' has private destructor}}
|
|
Base<0>, // expected-error {{base class 'Base<0>' has private destructor}}
|
|
virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}
|
|
Base2, // expected-error {{base class 'test3::Base2' has private destructor}}
|
|
virtual Base3
|
|
{
|
|
~Derived2() {}
|
|
};
|
|
|
|
class Derived3 : // expected-error 2 {{inherited virtual base class 'Base<2>' has private destructor}} \
|
|
// expected-error 2 {{inherited virtual base class 'Base<3>' has private destructor}} \
|
|
// expected-note 2{{implicit default constructor}}
|
|
Base<0>, // expected-error 2 {{base class 'Base<0>' has private destructor}}
|
|
virtual Base<1>, // expected-error 2 {{base class 'Base<1>' has private destructor}}
|
|
Base2, // expected-error 2 {{base class 'test3::Base2' has private destructor}}
|
|
virtual Base3
|
|
{};
|
|
Derived3 d3; // expected-note 3{{implicit default constructor}}\
|
|
// expected-note{{implicit destructor}}}
|
|
#else
|
|
template <unsigned N> class Base { ~Base(); }; // expected-note 4{{declared private here}}
|
|
class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 1{{declared private here}}
|
|
class Base3 : virtual Base<3> { public: ~Base3(); };
|
|
|
|
// These don't cause diagnostics because we don't need the destructor.
|
|
class Derived0 : Base<0> { ~Derived0(); };
|
|
class Derived1 : Base<1> { };
|
|
|
|
class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \
|
|
// expected-error {{inherited virtual base class 'Base<3>' has private destructor}}
|
|
Base<0>, // expected-error {{base class 'Base<0>' has private destructor}}
|
|
virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}
|
|
Base2, // expected-error {{base class 'test3::Base2' has private destructor}}
|
|
virtual Base3
|
|
{
|
|
~Derived2() {}
|
|
};
|
|
|
|
class Derived3 :
|
|
Base<0>, // expected-note {{deleted because base class 'Base<0>' has an inaccessible destructor}}
|
|
virtual Base<1>,
|
|
Base2,
|
|
virtual Base3
|
|
{};
|
|
Derived3 d3; // expected-error {{implicitly-deleted default constructor}}
|
|
#endif
|
|
}
|
|
|
|
// Conversion functions.
|
|
namespace test4 {
|
|
class Base {
|
|
private:
|
|
operator Private(); // expected-note 4 {{declared private here}}
|
|
public:
|
|
operator Public(); // expected-note 2{{member is declared here}}
|
|
};
|
|
|
|
class Derived1 : private Base { // expected-note 2 {{declared private here}} \
|
|
// expected-note {{constrained by private inheritance}}
|
|
Private test1() { return *this; } // expected-error {{'operator Private' is a private member}}
|
|
Public test2() { return *this; }
|
|
};
|
|
Private test1(Derived1 &d) { return d; } // expected-error {{'operator Private' is a private member}} \
|
|
// expected-error {{cannot cast 'test4::Derived1' to its private base class}}
|
|
Public test2(Derived1 &d) { return d; } // expected-error {{cannot cast 'test4::Derived1' to its private base class}} \
|
|
// expected-error {{'operator Public' is a private member}}
|
|
|
|
|
|
class Derived2 : public Base {
|
|
Private test1() { return *this; } // expected-error {{'operator Private' is a private member}}
|
|
Public test2() { return *this; }
|
|
};
|
|
Private test1(Derived2 &d) { return d; } // expected-error {{'operator Private' is a private member}}
|
|
Public test2(Derived2 &d) { return d; }
|
|
|
|
class Derived3 : private Base { // expected-note {{constrained by private inheritance here}} \
|
|
// expected-note {{declared private here}}
|
|
public:
|
|
operator Private();
|
|
};
|
|
Private test1(Derived3 &d) { return d; }
|
|
Public test2(Derived3 &d) { return d; } // expected-error {{'operator Public' is a private member of 'test4::Base'}} \
|
|
// expected-error {{cannot cast 'test4::Derived3' to its private base class}}
|
|
|
|
class Derived4 : public Base {
|
|
public:
|
|
operator Private();
|
|
};
|
|
Private test1(Derived4 &d) { return d; }
|
|
Public test2(Derived4 &d) { return d; }
|
|
}
|
|
|
|
// Implicit copy assignment operator uses.
|
|
namespace test5 {
|
|
class A {
|
|
void operator=(const A &);
|
|
#if __cplusplus < 201103L
|
|
// expected-note@-2 2{{implicitly declared private here}}
|
|
#endif
|
|
};
|
|
|
|
#if __cplusplus < 201103L
|
|
class Test1 { A a; }; // expected-error {{private member}}
|
|
void test1() {
|
|
Test1 a;
|
|
a = Test1(); // expected-note{{implicit copy}}
|
|
}
|
|
|
|
class Test2 : A {}; // expected-error {{private member}}
|
|
void test2() {
|
|
Test2 a;
|
|
a = Test2(); // expected-note{{implicit copy}}
|
|
}
|
|
#else
|
|
class Test1 { A a; }; // expected-note {{because field 'a' has an inaccessible copy assignment operator}}
|
|
void test1() {
|
|
Test1 a;
|
|
a = Test1(); // expected-error {{copy assignment operator is implicitly deleted}}
|
|
}
|
|
|
|
class Test2 : A {}; // expected-note {{because base class 'test5::A' has an inaccessible copy assignment operator}}
|
|
void test2() {
|
|
Test2 a;
|
|
a = Test2(); // expected-error {{copy assignment operator is implicitly deleted}}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Implicit copy constructor uses.
|
|
namespace test6 {
|
|
class A {
|
|
public: A();
|
|
private: A(const A &);
|
|
#if __cplusplus < 201103L
|
|
// expected-note@-2 2{{declared private here}}
|
|
#endif
|
|
};
|
|
|
|
#if __cplusplus < 201103L
|
|
class Test1 { A a; }; // expected-error {{field of type 'test6::A' has private copy constructor}}
|
|
void test1(const Test1 &t) {
|
|
Test1 a = t; // expected-note{{implicit copy}}
|
|
}
|
|
|
|
class Test2 : A {}; // expected-error {{base class 'test6::A' has private copy constructor}}
|
|
void test2(const Test2 &t) {
|
|
Test2 a = t; // expected-note{{implicit copy}}
|
|
}
|
|
#else
|
|
class Test1 { A a; }; // expected-note {{field 'a' has an inaccessible copy constructor}}
|
|
void test1(const Test1 &t) {
|
|
Test1 a = t; // expected-error{{implicitly-deleted}}
|
|
}
|
|
|
|
class Test2 : A {}; // expected-note {{base class 'test6::A' has an inaccessible copy constructor}}
|
|
void test2(const Test2 &t) {
|
|
Test2 a = t; // expected-error{{implicitly-deleted}}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Redeclaration lookups are not accesses.
|
|
namespace test7 {
|
|
class A {
|
|
int private_member;
|
|
};
|
|
class B : A {
|
|
int foo(int private_member) {
|
|
return 0;
|
|
}
|
|
};
|
|
}
|
|
|
|
// Ignored operator new and delete overloads are not
|
|
namespace test8 {
|
|
typedef __typeof__(sizeof(int)) size_t;
|
|
|
|
class A {
|
|
void *operator new(size_t s);
|
|
void operator delete(void *p);
|
|
public:
|
|
void *operator new(size_t s, int n);
|
|
void operator delete(void *p, int n);
|
|
};
|
|
|
|
void test() {
|
|
new (2) A();
|
|
}
|
|
}
|
|
|
|
// Don't silently upgrade forbidden-access paths to private.
|
|
namespace test9 {
|
|
class A {
|
|
public: static int x; // expected-note {{member is declared here}}
|
|
};
|
|
class B : private A { // expected-note {{constrained by private inheritance here}}
|
|
};
|
|
class C : public B {
|
|
static int getX() { return x; } // expected-error {{'x' is a private member of 'test9::A'}}
|
|
};
|
|
}
|
|
|
|
namespace test10 {
|
|
class A {
|
|
enum {
|
|
value = 10 // expected-note {{declared private here}}
|
|
};
|
|
friend class C;
|
|
};
|
|
|
|
class B {
|
|
enum {
|
|
value = A::value // expected-error {{'value' is a private member of 'test10::A'}}
|
|
};
|
|
};
|
|
|
|
class C {
|
|
enum {
|
|
value = A::value
|
|
};
|
|
};
|
|
}
|
|
|
|
namespace test11 {
|
|
class A {
|
|
protected: virtual ~A();
|
|
};
|
|
|
|
class B : public A {
|
|
~B();
|
|
};
|
|
|
|
B::~B() {};
|
|
}
|
|
|
|
namespace test12 {
|
|
class A {
|
|
int x;
|
|
|
|
void foo() {
|
|
class Local {
|
|
int foo(A *a) {
|
|
return a->x;
|
|
}
|
|
};
|
|
}
|
|
};
|
|
}
|
|
|
|
namespace test13 {
|
|
struct A {
|
|
int x;
|
|
unsigned foo() const;
|
|
};
|
|
|
|
struct B : protected A {
|
|
using A::foo;
|
|
using A::x;
|
|
};
|
|
|
|
void test() {
|
|
A *d;
|
|
d->foo();
|
|
(void) d->x;
|
|
}
|
|
}
|
|
|
|
// Destructors for temporaries.
|
|
namespace test14 {
|
|
class A {
|
|
private: ~A(); // expected-note {{declared private here}}
|
|
};
|
|
A foo();
|
|
|
|
void test() {
|
|
foo(); // expected-error {{temporary of type 'test14::A' has private destructor}}
|
|
}
|
|
|
|
class X {
|
|
~X(); // expected-note {{declared private here}}
|
|
};
|
|
|
|
struct Y1 {
|
|
operator X();
|
|
};
|
|
|
|
void g() {
|
|
const X &xr = Y1(); // expected-error{{temporary of type 'test14::X' has private destructor}}
|
|
}
|
|
}
|
|
|
|
// PR 7024
|
|
namespace test15 {
|
|
template <class T> class A {
|
|
private:
|
|
int private_foo; // expected-note {{declared private here}}
|
|
static int private_sfoo; // expected-note {{declared private here}}
|
|
protected:
|
|
int protected_foo; // expected-note 3 {{declared protected here}} // expected-note {{can only access this member on an object of type 'test15::B<int>'}}
|
|
static int protected_sfoo; // expected-note 3 {{declared protected here}}
|
|
|
|
int test1(A<int> &a) {
|
|
return a.private_foo; // expected-error {{private member}}
|
|
}
|
|
|
|
int test2(A<int> &a) {
|
|
return a.private_sfoo; // expected-error {{private member}}
|
|
}
|
|
|
|
int test3(A<int> &a) {
|
|
return a.protected_foo; // expected-error {{protected member}}
|
|
}
|
|
|
|
int test4(A<int> &a) {
|
|
return a.protected_sfoo; // expected-error {{protected member}}
|
|
}
|
|
};
|
|
|
|
template class A<int>;
|
|
template class A<long>; // expected-note 4 {{in instantiation}}
|
|
|
|
template <class T> class B : public A<T> {
|
|
// TODO: These first two accesses can be detected as ill-formed at
|
|
// definition time because they're member accesses and A<int> can't
|
|
// be a subclass of B<T> for any T.
|
|
|
|
int test1(A<int> &a) {
|
|
return a.protected_foo; // expected-error 2 {{protected member}}
|
|
}
|
|
|
|
int test2(A<int> &a) {
|
|
return a.protected_sfoo; // expected-error {{protected member}}
|
|
}
|
|
|
|
int test3(B<int> &b) {
|
|
return b.protected_foo; // expected-error {{protected member}}
|
|
}
|
|
|
|
int test4(B<int> &b) {
|
|
return b.protected_sfoo; // expected-error {{protected member}}
|
|
}
|
|
};
|
|
|
|
template class B<int>; // expected-note {{in instantiation}}
|
|
template class B<long>; // expected-note 4 {{in instantiation}}
|
|
}
|
|
|
|
// PR7281
|
|
namespace test16 {
|
|
class A { ~A(); }; // expected-note 2{{declared private here}}
|
|
void b() { throw A(); } // expected-error{{temporary of type 'test16::A' has private destructor}} \
|
|
// expected-error{{exception object of type 'test16::A' has private destructor}}
|
|
}
|
|
|
|
// rdar://problem/8146294
|
|
namespace test17 {
|
|
class A {
|
|
template <typename T> class Inner { }; // expected-note {{declared private here}}
|
|
};
|
|
|
|
A::Inner<int> s; // expected-error {{'Inner' is a private member of 'test17::A'}}
|
|
}
|
|
|
|
namespace test18 {
|
|
template <class T> class A {};
|
|
class B : A<int> {
|
|
A<int> member;
|
|
};
|
|
|
|
// FIXME: this access to A should be forbidden (because C++ is dumb),
|
|
// but LookupResult can't express the necessary information to do
|
|
// the check, so we aggressively suppress access control.
|
|
class C : B {
|
|
A<int> member;
|
|
};
|
|
}
|
|
|
|
// PR8325
|
|
namespace test19 {
|
|
class A { ~A(); };
|
|
// The destructor is not implicitly referenced here. Contrast to test16,
|
|
// testing PR7281, earlier in this file.
|
|
void b(A* x) { throw x; }
|
|
}
|
|
|
|
// PR7930
|
|
namespace test20 {
|
|
class Foo {
|
|
Foo(); // expected-note {{implicitly declared private here}}
|
|
};
|
|
Foo::Foo() {}
|
|
|
|
void test() {
|
|
Foo a; // expected-error {{calling a private constructor}}
|
|
}
|
|
}
|
|
|
|
namespace test21 {
|
|
template <class T> class A {
|
|
void foo();
|
|
void bar();
|
|
class Inner; // expected-note {{implicitly declared private here}}
|
|
public:
|
|
void baz();
|
|
};
|
|
template <class T> class A<T>::Inner {};
|
|
class B {
|
|
template <class T> class A<T>::Inner; // expected-error{{non-friend class member 'Inner' cannot have a qualified name}}
|
|
};
|
|
|
|
void test() {
|
|
A<int>::Inner i; // expected-error {{'Inner' is a private member}}
|
|
}
|
|
}
|
|
|
|
namespace rdar8876150 {
|
|
struct A { operator bool(); };
|
|
struct B : private A { using A::operator bool; };
|
|
|
|
bool f() {
|
|
B b;
|
|
return !b;
|
|
}
|
|
}
|
|
|
|
namespace test23 {
|
|
template <typename T> class A {
|
|
A();
|
|
static A instance;
|
|
};
|
|
|
|
template <typename T> A<T> A<T>::instance;
|
|
template class A<int>;
|
|
}
|