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
5 const char const *x10; // expected-error {{duplicate 'const' declaration specifier}}
6
7 int x(*g); // expected-error {{use of undeclared identifier 'g'}}
8
9 struct Type {
10 int Type;
11 };
12
13 // rdar://8365458
14 // rdar://9132143
15 typedef 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.
18 namespace y {
19 struct a { };
20 typedef int b;
21 }
22
23 y::a a1;
24 y:a a2; // expected-error {{unexpected ':' in nested name specifier}}
25 y::a a3 = a2;
26
27 // Some valid colons:
foo()28 void foo() {
29 y: // label
30 y::a s;
31
32 int a = 4;
33 a = a ? a : a+1;
34 }
35
36 struct b : y::a {};
37
38 template <typename T>
39 class someclass {
40
bar()41 int bar() {
42 T *P;
43 return 1 ? P->x : P->y;
44 }
45 };
46
47 class asm_class_test {
48 void foo() __asm__("baz");
49 };
50
51 enum { 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
56 struct a {
57 int Type : fooenum;
58 };
59
test(struct Type * P)60 void 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
70 struct 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 ';'.
77 namespace 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
g()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
111 struct test5 {};
112 ::new(static_cast<void*>(0)) test5; // expected-error {{expected unqualified-id}}
113
114
115 // PR6782
116 template<class T>
117 class Class1;
118
119 class Class2 {
120 } // expected-error {{expected ';' after class}}
121
122 typedef Class1<Class2> Type1;
123
124 // rdar : // 8307865
125 struct CodeCompleteConsumer {
126 };
127
128 void CodeCompleteConsumer::() { // expected-error {{xpected unqualified-id}}
129 }
130
131 ;
132
133 // PR4111
134 void f(sqrgl); // expected-error {{unknown type name 'sqrgl'}}
135
136 // PR9903
137 struct 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
145 namespace TestIsValidAfterTypeSpecifier {
146 struct s {} v;
147
148 namespace a {
149 struct s operator++(struct s a)
150 { return a; }
151 }
152
153 namespace b {
154 // The newline after s should make no difference.
155 struct s
156 operator++(struct s a)
157 { return a; }
158 }
159
160 struct X {
161 struct s
162 friend f();
163 struct s
164 virtual f();
165 };
166
167 struct s
168 &r0 = v;
169 struct s
170 bitand r2 = v;
171
172 }
173
174 struct DIE {
175 void foo() {}
176 };
177
178 void 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
192 namespace 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
205 namespace 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
220 void test8() {
221 struct {} o;
222 // This used to crash.
223 (&o)->(); // expected-error{{expected unqualified-id}}
224 }
225
226 namespace 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
237 namespace PR17255 {
238 void 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
247 namespace 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
256 namespace 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
267 extern "" // expected-error {{unknown linkage language}}
268 test6a { ;// 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