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}}
123   void S::f() {} // expected-error {{extra qualification on member}} expected-error {{class member cannot be redeclared}} expected-note {{previous declaration}} expected-note {{previous definition}}
124   void f() {} // expected-error {{class member cannot be redeclared}} expected-error {{redefinition}}
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