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 
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:
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 
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 
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), // 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
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 {{misplaced attributes}}
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   // 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 
248 namespace 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 
257 namespace 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 
267 namespace 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 
286 inline 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 
302 namespace 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
308 extern ""      // expected-error {{unknown linkage language}}
309 test6a { ;// 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