1// RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -pedantic-errors -fcxx-exceptions -fexceptions %s
2// RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -pedantic-errors -fcxx-exceptions -fexceptions -std=c++98 %s
3// RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -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),
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 {{an attribute list cannot appear here}}
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#if __cplusplus <= 199711L
241  // expected-error@-2 {{'template' keyword outside of a template}}
242#endif
243  // expected-error@-4 {{expected a qualified name after 'typename'}}
244}
245}
246
247namespace PR17567 {
248  struct Foobar { // expected-note 2{{declared here}}
249    FooBar(); // expected-error {{missing return type for function 'FooBar'; did you mean the constructor name 'Foobar'?}}
250    ~FooBar(); // expected-error {{expected the class name after '~' to name a destructor}}
251  };
252  FooBar::FooBar() {} // expected-error {{undeclared}} expected-error {{missing return type}}
253  FooBar::~FooBar() {} // expected-error {{undeclared}} expected-error {{expected the class name}}
254}
255
256namespace DuplicateFriend {
257  struct A {
258    friend void friend f(); // expected-warning {{duplicate 'friend' declaration specifier}}
259    friend struct B friend; // expected-warning {{duplicate 'friend' declaration specifier}}
260#if __cplusplus >= 201103L
261    // expected-error@-2 {{'friend' must appear first in a non-function declaration}}
262#endif
263  };
264}
265
266// PR8380
267extern ""      // expected-error {{unknown linkage language}}
268test6a { ;// expected-error {{C++ requires a type specifier for all declarations}}
269#if __cplusplus <= 199711L
270// expected-error@-2 {{expected ';' after top level declarator}}
271#else
272// expected-error@-4 {{expected expression}}
273// expected-note@-5 {{to match this}}
274#endif
275
276  int test6b;
277#if __cplusplus >= 201103L
278// expected-error@+3 {{expected}}
279// expected-error@-3 {{expected ';' after top level declarator}}
280#endif
281
282