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