Clang Project

clang_source_code/test/Parser/cxx-decl.cpp
1// RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -Wredundant-parens -pedantic-errors -fcxx-exceptions -fexceptions %s
2// RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -Wredundant-parens -pedantic-errors -fcxx-exceptions -fexceptions -std=c++98 %s
3// RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -Wredundant-parens -pedantic-errors -fcxx-exceptions -fexceptions -std=c++11 %s
4
5const char const *x10; // expected-error {{duplicate 'const' declaration specifier}}
6
7int x(*g); // expected-error {{use of undeclared identifier 'g'}}
8
9struct Type {
10  int Type;
11};
12
13// rdar://8365458
14// rdar://9132143
15typedef char bool; // expected-error {{redeclaration of C++ built-in type 'bool'}}
16
17// PR4451 - We should recover well from the typo of '::' as ':' in a2.
18namespace y {
19  struct a { };
20  typedef int b;
21}
22
23y::a a1;
24y:a a2;  // expected-error {{unexpected ':' in nested name specifier}}
25y::a a3 = a2;
26
27// Some valid colons:
28void foo() {
29y:  // label
30  y::a s;
31  
32  int a = 4;
33  a = a ? a : a+1;
34}
35
36struct b : y::a {};
37
38template <typename T>
39class someclass {
40  
41  int bar() {
42    T *P;
43    return 1 ? P->x : P->y;
44  }
45};
46
47class asm_class_test {
48  void foo() __asm__("baz");
49};
50
51enum { fooenum = 1, };
52#if __cplusplus <= 199711L
53// expected-error@-2 {{commas at the end of enumerator lists are a C++11 extension}}
54#endif
55
56struct a {
57  int Type : fooenum;
58};
59
60void test(struct Type *P) {
61  int Type;
62  Type = 1 ? P->Type : Type;
63  
64  Type = (y:b) 4;   // expected-error {{unexpected ':' in nested name specifier}}
65  Type = 1 ? (
66              (y:b)  // expected-error {{unexpected ':' in nested name specifier}}
67              4) : 5;
68}
69
70struct test4 {
71  int x  // expected-error {{expected ';' at end of declaration list}}
72  int y;
73  int z  // expected-error {{expected ';' at end of declaration list}}
74};
75
76// Make sure we know these are legitimate commas and not typos for ';'.
77namespace Commas {
78  struct S {
79    static int a;
80    int c,
81    operator()();
82  };
83
84  int global1,
85  __attribute__(()) global2,
86  (global5), // expected-warning {{redundant parentheses surrounding declarator}}
87  *global6,
88  &global7 = global1,
89  &&global8 = static_cast<int&&>(global1),
90#if __cplusplus <= 199711L
91  // expected-error@-2 2{{rvalue references are a C++11 extension}}
92#endif
93
94  S::a,
95  global9,
96  global10 = 0,
97  global11 == 0, // expected-error {{did you mean '='}}
98  global12 __attribute__(()),
99  global13(0),
100  global14[2],
101  global15;
102
103  void g() {
104    static int a,
105    b __asm__("ebx"), // expected-error {{expected ';' at end of declaration}}
106    Statics:return;
107  }
108}
109
110// PR5825
111struct test5 {};
112::new(static_cast<void*>(0)) test5; // expected-error {{expected unqualified-id}}
113
114
115// PR6782
116template<class T>
117class Class1;
118
119class Class2 {
120} // expected-error {{expected ';' after class}}
121
122typedef Class1<Class2> Type1;
123
124// rdar : // 8307865
125struct CodeCompleteConsumer {
126};
127
128void CodeCompleteConsumer::() { // expected-error {{xpected unqualified-id}}
129} 
130
131;
132
133// PR4111
134void f(sqrgl); // expected-error {{unknown type name 'sqrgl'}}
135
136// PR9903
137struct S {
138  typedef void a() { }; // expected-error {{function definition declared 'typedef'}}
139  typedef void c() try { } catch(...) { } // expected-error {{function definition declared 'typedef'}}
140  int n, m;
141  typedef S() : n(1), m(2) { } // expected-error {{function definition declared 'typedef'}}
142};
143
144
145namespace TestIsValidAfterTypeSpecifier {
146struct s {} v;
147
148namespace a {
149struct s operator++(struct s a)
150{ return a; }
151}
152
153namespace b {
154// The newline after s should make no difference.
155struct s
156operator++(struct s a)
157{ return a; }
158}
159
160struct X {
161  struct s
162  friend f();
163  struct s
164  virtual f();
165};
166
167struct s
168&r0 = v;
169struct s
170bitand r2 = v;
171
172}
173
174struct DIE {
175  void foo() {}
176};
177
178void test (DIE die, DIE *Die, DIE INT, DIE *FLOAT) {
179  DIE.foo();  // expected-error {{cannot use dot operator on a type}}
180  die.foo();
181
182  DIE->foo();  // expected-error {{cannot use arrow operator on a type}}
183  Die->foo();
184
185  int.foo();  // expected-error {{cannot use dot operator on a type}}
186  INT.foo();
187
188  float->foo();  // expected-error {{cannot use arrow operator on a type}}
189  FLOAT->foo();
190}
191
192namespace PR15017 {
193  template<typename T = struct X { int i; }> struct S {}; // expected-error {{'PR15017::X' cannot be defined in a type specifier}}
194}
195
196// Ensure we produce at least some diagnostic for attributes in C++98.
197[[]] struct S;
198#if __cplusplus <= 199711L
199// expected-error@-2 {{expected expression}}
200// expected-error@-3 {{expected unqualified-id}}
201#else
202// expected-error@-5 {{misplaced attributes}}
203#endif
204
205namespace test7 {
206  struct Foo {
207    void a();
208    void b();
209  };
210
211  void Foo::
212  // Comment!
213  a() {}
214
215
216  void Foo::  // expected-error {{expected unqualified-id}}
217  // Comment!
218}
219
220void test8() {
221  struct {} o;
222  // This used to crash.
223  (&o)->(); // expected-error{{expected unqualified-id}}
224}
225
226namespace PR5066 {
227  template<typename T> struct X {};
228  X<int N> x; // expected-error {{type-id cannot have a name}}
229
230  using T = int (*T)(); // expected-error {{type-id cannot have a name}}
231#if __cplusplus <= 199711L
232  // expected-error@-2 {{alias declarations are a C++11 extensio}}
233#endif
234
235}
236
237namespace PR17255 {
238void foo() {
239  typename A::template B<>; // expected-error {{use of undeclared identifier 'A'}}
240  // expected-error@-1 {{'template' keyword not permitted here}}
241#if __cplusplus <= 199711L
242  // expected-error@-3 {{'template' keyword outside of a template}}
243#endif
244  // expected-error@-5 {{expected a qualified name after 'typename'}}
245}
246}
247
248namespace PR17567 {
249  struct Foobar { // expected-note 2{{declared here}}
250    FooBar(); // expected-error {{missing return type for function 'FooBar'; did you mean the constructor name 'Foobar'?}}
251    ~FooBar(); // expected-error {{expected the class name after '~' to name a destructor}}
252  };
253  FooBar::FooBar() {} // expected-error {{undeclared}} expected-error {{missing return type}}
254  FooBar::~FooBar() {} // expected-error {{undeclared}} expected-error {{expected the class name}}
255}
256
257namespace DuplicateFriend {
258  struct A {
259    friend void friend f(); // expected-warning {{duplicate 'friend' declaration specifier}}
260    friend struct B friend; // expected-warning {{duplicate 'friend' declaration specifier}}
261#if __cplusplus >= 201103L
262    // expected-error@-2 {{'friend' must appear first in a non-function declaration}}
263#endif
264  };
265}
266
267namespace NNS {
268  struct A {};
269  namespace B { extern A C1, C2, *C3, C4[], C5; }
270  // Do not produce a redundant parentheses warning here; removing these parens
271  // changes the meaning of the program.
272  A (::NNS::B::C1);
273  A (NNS::B::C2); // expected-warning {{redundant parentheses surrounding declarator}}
274  A (*::NNS::B::C3); // expected-warning {{redundant parentheses surrounding declarator}}
275  A (::NNS::B::C4[2]);
276  // Removing one of these sets of parentheses would be reasonable.
277  A ((::NNS::B::C5)); // expected-warning {{redundant parentheses surrounding declarator}}
278
279  void f() {
280    // FIXME: A vexing-parse warning here would be useful.
281    A(::NNS::B::C1); // expected-error {{definition or redeclaration}}
282    A(NNS::B::C1); // expected-warning {{redundant paren}} expected-error {{definition or redeclaration}}
283  }
284}
285
286inline namespace ParensAroundFriend { // expected-error 0-1{{C++11}}
287  struct A {};
288  struct B {
289    static A C();
290  };
291  namespace X {
292    struct B {};
293    struct D {
294      // No warning here: while this could be written as
295      //   friend (::B::C)();
296      // we do need parentheses *somewhere* here.
297      friend A (::B::C());
298    };
299  }
300}
301
302namespace rdar37099386 {
303  class A typename A; // expected-error {{expected a qualified name after 'typename'}}
304  // expected-error@-1 {{cannot combine with previous 'class' declaration specifier}}
305}
306
307// PR8380
308extern ""      // expected-error {{unknown linkage language}}
309test6a { ;// expected-error {{C++ requires a type specifier for all declarations}}
310#if __cplusplus <= 199711L
311// expected-error@-2 {{expected ';' after top level declarator}}
312#else
313// expected-error@-4 {{expected expression}}
314// expected-note@-5 {{to match this}}
315#endif
316  
317  int test6b;
318#if __cplusplus >= 201103L
319// expected-error@+3 {{expected}}
320// expected-error@-3 {{expected ';' after top level declarator}}
321#endif
322
323
CodeThinker, Enjoy your reading code