1 // RUN: %clang_cc1 -fsyntax-only -verify -Wc++11-compat %s 2 class C { 3 public: 4 auto int errx; // expected-error {{storage class specified for a member declaration}} expected-warning {{'auto' storage class specifier is redundant}} 5 register int erry; // expected-error {{storage class specified for a member declaration}} 6 extern int errz; // expected-error {{storage class specified for a member declaration}} 7 8 static void sm() { 9 sx = 0; 10 this->x = 0; // expected-error {{invalid use of 'this' outside of a non-static member function}} 11 x = 0; // expected-error {{invalid use of member 'x' in static member function}} 12 } 13 14 class NestedC { 15 public: 16 NestedC(int); 17 void f() { 18 sx = 0; 19 x = 0; // expected-error {{use of non-static data member 'x' of 'C' from nested type 'NestedC'}} 20 sm(); 21 m(); // expected-error {{call to non-static member function 'm' of 'C' from nested type 'NestedC'}} 22 } 23 }; 24 25 int b : 1, w : 2; 26 int : 1, : 2; 27 typedef int E : 1; // expected-error {{typedef member 'E' cannot be a bit-field}} 28 static int sb : 1; // expected-error {{static member 'sb' cannot be a bit-field}} 29 static int vs; 30 31 typedef int func(); 32 func tm; 33 func *ptm; 34 func btm : 1; // expected-error {{bit-field 'btm' has non-integral type}} 35 NestedC bc : 1; // expected-error {{bit-field 'bc' has non-integral type}} 36 37 enum E1 { en1, en2 }; 38 39 int i = 0; // expected-warning {{in-class initialization of non-static data member is a C++11 extension}} 40 static int si = 0; // expected-error {{non-const static data member must be initialized out of line}} 41 static const NestedC ci = 0; // expected-error {{static data member of type 'const C::NestedC' must be initialized out of line}} 42 static const int nci = vs; // expected-error {{in-class initializer for static data member is not a constant expression}} 43 static const int vi = 0; 44 static const volatile int cvi = 0; // ok, illegal in C++11 45 static const E evi = 0; 46 47 void m() { 48 sx = 0; 49 this->x = 0; 50 y = 0; 51 this = 0; // expected-error {{expression is not assignable}} 52 } 53 54 int f1(int p) { 55 A z = 6; 56 return p + x + this->y + z; 57 } 58 59 typedef int A; 60 61 virtual int viv; // expected-error {{'virtual' can only appear on non-static member functions}} 62 virtual static int vsif(); // expected-error {{'virtual' can only appear on non-static member functions}} 63 virtual int vif(); 64 65 private: 66 int x,y; 67 static int sx; 68 69 mutable int mi; 70 mutable int &mir; // expected-error {{'mutable' cannot be applied to references}} 71 mutable void mfn(); // expected-error {{'mutable' cannot be applied to functions}} 72 mutable const int mci; // expected-error {{'mutable' and 'const' cannot be mixed}} 73 74 static const int number = 50; 75 static int arr[number]; 76 }; 77 78 class C2 { 79 void f() { 80 static int lx; 81 class LC1 { 82 int m() { return lx; } 83 }; 84 class LC2 { 85 int m() { return lx; } 86 }; 87 } 88 }; 89 90 struct C3 { 91 int i; 92 mutable int j; 93 }; 94 void f() 95 { 96 const C3 c3 = { 1, 2 }; 97 (void)static_cast<int*>(&c3.i); // expected-error {{static_cast from 'const int *' to 'int *' is not allowed}} 98 // but no error here 99 (void)static_cast<int*>(&c3.j); 100 } 101 102 // Play with mutable a bit more, to make sure it doesn't crash anything. 103 mutable int gi; // expected-error {{'mutable' can only be applied to member variables}} 104 mutable void gfn(); // expected-error {{illegal storage class on function}} 105 void ogfn() 106 { 107 mutable int ml; // expected-error {{'mutable' can only be applied to member variables}} 108 109 // PR3020: This used to crash due to double ownership of C4. 110 struct C4; 111 C4; // expected-warning {{declaration does not declare anything}} 112 } 113 114 struct C4 { 115 void f(); // expected-note{{previous declaration is here}} 116 int f; // expected-error{{duplicate member 'f'}} 117 }; 118 119 // PR5415 - don't hang! 120 struct S 121 { 122 void f(); // expected-note 1 {{previous declaration}} expected-note {{previous declaration}} 123 void S::f() {} // expected-error {{extra qualification on member}} expected-error {{class member cannot be redeclared}} 124 void f() {} // expected-error {{class member cannot be redeclared}} 125 }; 126 127 // Don't crash on this bogus code. 128 namespace pr6629 { 129 template<class T1, class T2> struct foo : 130 bogus<foo<T1,T2> > // expected-error {{unknown template name 'bogus'}} 131 { }; 132 133 template<> struct foo<unknown,unknown> { // expected-error {{undeclared identifier 'unknown'}} 134 template <typename U1, typename U2> struct bar { 135 typedef bar type; 136 static const int value = 0; 137 }; 138 }; 139 } 140 141 namespace PR7153 { 142 class EnclosingClass { 143 public: 144 struct A { } mutable *member; 145 }; 146 147 void f(const EnclosingClass &ec) { 148 ec.member = 0; 149 } 150 } 151 152 namespace PR7196 { 153 struct A { 154 int a; 155 156 void f() { 157 char i[sizeof(a)]; 158 enum { x = sizeof(i) }; 159 enum { y = sizeof(a) }; 160 } 161 }; 162 } 163 164 namespace rdar8066414 { 165 class C { 166 C() {} 167 } // expected-error{{expected ';' after class}} 168 } 169 170 namespace rdar8367341 { 171 float foo(); 172 173 struct A { 174 static const float x = 5.0f; // expected-warning {{in-class initializer for static data member of type 'const float' is a GNU extension}} 175 static const float y = foo(); // expected-warning {{in-class initializer for static data member of type 'const float' is a GNU extension}} expected-error {{in-class initializer for static data member is not a constant expression}} 176 }; 177 } 178 179 namespace with_anon { 180 struct S { 181 union { 182 char c; 183 }; 184 }; 185 186 void f() { 187 S::c; // expected-error {{invalid use of non-static data member}} 188 } 189 } 190 191 struct PR9989 { 192 static int const PR9989_Member = sizeof PR9989_Member; 193 }; 194
