llvm-project

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
private int cplusplus_is_not_opencl; // expected-error {{expected unqualified-id}}
10

11
struct Type {
12
  int Type;
13
};
14

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
struct CodeCompleteConsumer {
125
};
126

127
void CodeCompleteConsumer::() { // expected-error {{xpected unqualified-id}}
128
}
129

130
;
131

132
// PR4111
133
void f(sqrgl); // expected-error {{unknown type name 'sqrgl'}}
134

135
// PR9903
136
struct S {
137
  typedef void a() { }; // expected-error {{function definition declared 'typedef'}}
138
  typedef void c() try { } catch(...) { } // expected-error {{function definition declared 'typedef'}}
139
  int n, m;
140
  typedef S() : n(1), m(2) { } // expected-error {{function definition declared 'typedef'}}
141
};
142

143

144
namespace TestIsValidAfterTypeSpecifier {
145
struct s {} v;
146

147
namespace a {
148
struct s operator++(struct s a)
149
{ return a; }
150
}
151

152
namespace b {
153
// The newline after s should make no difference.
154
struct s
155
operator++(struct s a)
156
{ return a; }
157
}
158

159
struct X {
160
  struct s
161
  friend f();
162
  struct s
163
  virtual f();
164
};
165

166
struct s
167
&r0 = v;
168
struct s
169
bitand r2 = v;
170

171
}
172

173
struct DIE {
174
  void foo() {}
175
};
176

177
void test (DIE die, DIE *Die, DIE INT, DIE *FLOAT) {
178
  DIE.foo();  // expected-error {{cannot use dot operator on a type}}
179
  die.foo();
180

181
  DIE->foo();  // expected-error {{cannot use arrow operator on a type}}
182
  Die->foo();
183

184
  int.foo();  // expected-error {{cannot use dot operator on a type}}
185
  INT.foo();
186

187
  float->foo();  // expected-error {{cannot use arrow operator on a type}}
188
  FLOAT->foo();
189
}
190

191
namespace PR15017 {
192
  template<typename T = struct X { int i; }> struct S {}; // expected-error {{'PR15017::X' cannot be defined in a type specifier}}
193
}
194

195
// Ensure we produce at least some diagnostic for attributes in C++98.
196
[[]] struct S; // expected-error {{misplaced attributes}}
197
#if __cplusplus < 201103L
198
// expected-error@-2 {{[[]] attributes are a C++11 extension}}
199
#endif
200

201
namespace test7 {
202
  struct Foo {
203
    void a();
204
    void b();
205
  };
206

207
  void Foo::
208
  // Comment!
209
  a() {}
210

211

212
  void Foo::  // expected-error {{expected unqualified-id}}
213
  // Comment!
214
}
215

216
void test8() {
217
  struct {} o;
218
  // This used to crash.
219
  (&o)->(); // expected-error{{expected unqualified-id}}
220
}
221

222
namespace PR5066 {
223
  template<typename T> struct X {};
224
  X<int N> x; // expected-error {{type-id cannot have a name}}
225

226
  using T = int (*T)(); // expected-error {{type-id cannot have a name}}
227
#if __cplusplus <= 199711L
228
  // expected-error@-2 {{alias declarations are a C++11 extensio}}
229
#endif
230

231
}
232

233
namespace PR17255 {
234
void foo() {
235
  typename A::template B<> c; // expected-error {{use of undeclared identifier 'A'}}
236
#if __cplusplus <= 199711L
237
  // expected-error@-2 {{'template' keyword outside of a template}}
238
#endif
239
}
240
}
241

242
namespace PR17567 {
243
  struct Foobar { // expected-note 2{{declared here}}
244
    FooBar(); // expected-error {{missing return type for function 'FooBar'; did you mean the constructor name 'Foobar'?}}
245
    ~FooBar(); // expected-error {{undeclared identifier 'FooBar' in destructor name}}
246
  };
247
  FooBar::FooBar() {} // expected-error {{undeclared}} expected-error {{missing return type}}
248
  FooBar::~FooBar() {} // expected-error 2{{undeclared}}
249
}
250

251
namespace DuplicateFriend {
252
  struct A {
253
    friend void friend f(); // expected-warning {{duplicate 'friend' declaration specifier}}
254
    friend struct B friend; // expected-warning {{duplicate 'friend' declaration specifier}}
255
  };
256
}
257

258
namespace NNS {
259
  struct A {};
260
  namespace B { extern A C1, C2, *C3, C4[], C5; }
261
  // Do not produce a redundant parentheses warning here; removing these parens
262
  // changes the meaning of the program.
263
  A (::NNS::B::C1);
264
  A (NNS::B::C2); // expected-warning {{redundant parentheses surrounding declarator}}
265
  A (*::NNS::B::C3); // expected-warning {{redundant parentheses surrounding declarator}}
266
  A (::NNS::B::C4[2]);
267
  // Removing one of these sets of parentheses would be reasonable.
268
  A ((::NNS::B::C5)); // expected-warning {{redundant parentheses surrounding declarator}}
269

270
  void f() {
271
    // FIXME: A vexing-parse warning here would be useful.
272
    A(::NNS::B::C1); // expected-error {{definition or redeclaration}}
273
    A(NNS::B::C1); // expected-warning {{redundant paren}} expected-error {{definition or redeclaration}}
274
  }
275
}
276

277
inline namespace ParensAroundFriend { // expected-error 0-1{{C++11}}
278
  struct A {};
279
  struct B {
280
    static A C();
281
  };
282
  namespace X {
283
    struct B {};
284
    struct D {
285
      // No warning here: while this could be written as
286
      //   friend (::B::C)();
287
      // we do need parentheses *somewhere* here.
288
      friend A (::B::C());
289
    };
290
  }
291
}
292

293
namespace rdar37099386 {
294
  class A typename A; // expected-error {{expected a qualified name after 'typename'}}
295
  // expected-error@-1 {{cannot combine with previous 'class' declaration specifier}}
296
}
297

298
// PR8380
299
extern ""      // expected-error {{unknown linkage language}}
300
test6a { ;// expected-error {{a type specifier is required for all declarations}}
301
#if __cplusplus <= 199711L
302
// expected-error@-2 {{expected ';' after top level declarator}}
303
#else
304
// expected-error@-4 {{expected expression}}
305
// expected-note@-5 {{to match this}}
306
#endif
307

308
  int test6b;
309
#if __cplusplus >= 201103L
310
// expected-error@+3 {{expected}}
311
// expected-error@-3 {{expected ';' after top level declarator}}
312
#endif
313

314