1 // RUN: %clang_cc1 -pedantic -Wall -Wno-unused-but-set-variable -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++98 -Wno-c++14-extensions %s
2 // RUN: cp %s %t-98
3 // RUN: not %clang_cc1 -pedantic -Wall -Wno-unused-but-set-variable -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++98 -Wno-c++14-extensions %t-98
4 // RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Wno-unused-but-set-variable -Werror -Wno-comment -fcxx-exceptions -x c++ -std=c++98 -Wno-c++14-extensions %t-98
5 // RUN: not %clang_cc1 -fsyntax-only -pedantic -fdiagnostics-parseable-fixits -x c++ -std=c++11 -Wno-c++14-extensions %s 2>&1 | FileCheck %s
6 // RUN: %clang_cc1 -pedantic -Wall -Wno-unused-but-set-variable -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++11 -Wno-c++14-extensions %s
7 // RUN: cp %s %t-11
8 // RUN: not %clang_cc1 -pedantic -Wall -Wno-unused-but-set-variable -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++11 -Wno-c++14-extensions %t-11
9 // RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Wno-unused-but-set-variable -Werror -Wno-comment -fcxx-exceptions -x c++ -std=c++11 -Wno-c++14-extensions %t-11
10 
11 /* This is a test of the various code modification hints that are
12    provided as part of warning or extension diagnostics. All of the
13    warnings will be fixed by -fixit, and the resulting file should
14    compile cleanly with -Werror -pedantic. */
15 
16 struct C1 {
17   virtual void f();
18   static void g();
19 };
20 struct C2 : virtual public virtual C1 { }; // expected-error{{duplicate}}
21 
22 virtual void C1::f() { } // expected-error{{'virtual' can only be specified inside the class definition}}
23 
24 static void C1::g() { } // expected-error{{'static' can only be specified inside the class definition}}
25 
26 template<int Value> struct CT { template<typename> struct Inner; }; // expected-note{{previous use is here}}
27 
28 // FIXME: In C++11 this gets 'expected unqualified-id' which fixit can't fix.
29 // Probably parses as `CT<10> > 2 > ct;` rather than `CT<(10 >> 2)> ct;`.
30 #if __cplusplus < 201103L
31 CT<10 >> 2> ct; // expected-warning{{require parentheses}}
32 #endif
33 
34 class C3 {
35 public:
36   C3(C3, int i = 0); // expected-error{{copy constructor must pass its first argument by reference}}
37 };
38 
39 struct CT<0> { }; // expected-error{{'template<>'}}
40 
41 template<> union CT<1> { }; // expected-error{{tag type}}
42 
43 struct CT<2>::Inner<int> { }; // expected-error 2{{'template<>'}}
44 
45 // Access declarations
46 class A {
47 protected:
48   int foo();
49 };
50 
51 class B : public A {
52 #if __cplusplus >= 201103L
53   A::foo; // expected-error{{ISO C++11 does not allow access declarations}}
54 #else
55   A::foo; // expected-warning{{access declarations are deprecated}}
56 #endif
57 };
58 
59 void f() throw(); // expected-note{{previous}}
60 void f(); // expected-error{{missing exception specification}}
61 
62 namespace rdar7853795 {
63   struct A {
64     bool getNumComponents() const; // expected-note{{declared here}}
65     void dump() const {
66       getNumComponenets(); // expected-error{{use of undeclared identifier 'getNumComponenets'; did you mean 'getNumComponents'?}}
67     }
68   };
69 }
70 
71 namespace rdar7796492 {
72   struct A { int x, y; A(); };
73 
74   A::A()
75     : x(1) y(2) { // expected-error{{missing ',' between base or member initializers}}
76   }
77 
78 }
79 
80 // extra qualification on member
81 class C {
82   int C::foo(); // expected-error {{extra qualification}}
83 };
84 
85 namespace rdar8488464 {
86 int x = 0;
87 int x1 &= 0; // expected-error {{invalid '&=' at end of declaration; did you mean '='?}}
88 int x2 *= 0; // expected-error {{invalid '*=' at end of declaration; did you mean '='?}}
89 int x3 += 0; // expected-error {{invalid '+=' at end of declaration; did you mean '='?}}
90 int x4 -= 0; // expected-error {{invalid '-=' at end of declaration; did you mean '='?}}
91 int x5 != 0; // expected-error {{invalid '!=' at end of declaration; did you mean '='?}}
92 int x6 /= 0; // expected-error {{invalid '/=' at end of declaration; did you mean '='?}}
93 int x7 %= 0; // expected-error {{invalid '%=' at end of declaration; did you mean '='?}}
94 int x8 <= 0; // expected-error {{invalid '<=' at end of declaration; did you mean '='?}}
95 int x9 <<= 0; // expected-error {{invalid '<<=' at end of declaration; did you mean '='?}}
96 int x10 >= 0; // expected-error {{invalid '>=' at end of declaration; did you mean '='?}}
97 int x11 >>= 0; // expected-error {{invalid '>>=' at end of declaration; did you mean '='?}}
98 int x12 ^= 0; // expected-error {{invalid '^=' at end of declaration; did you mean '='?}}
99 int x13 |= 0; // expected-error {{invalid '|=' at end of declaration; did you mean '='?}}
100 int x14 == 0; // expected-error {{invalid '==' at end of declaration; did you mean '='?}}
101 
102 void f() {
103     int x = 0;
104     (void)x;
105     int x1 &= 0; // expected-error {{invalid '&=' at end of declaration; did you mean '='?}}
106     (void)x1;
107     int x2 *= 0; // expected-error {{invalid '*=' at end of declaration; did you mean '='?}}
108     (void)x2;
109     int x3 += 0; // expected-error {{invalid '+=' at end of declaration; did you mean '='?}}
110     (void)x3;
111     int x4 -= 0; // expected-error {{invalid '-=' at end of declaration; did you mean '='?}}
112     (void)x4;
113     int x5 != 0; // expected-error {{invalid '!=' at end of declaration; did you mean '='?}}
114     (void)x5;
115     int x6 /= 0; // expected-error {{invalid '/=' at end of declaration; did you mean '='?}}
116     (void)x6;
117     int x7 %= 0; // expected-error {{invalid '%=' at end of declaration; did you mean '='?}}
118     (void)x7;
119     int x8 <= 0; // expected-error {{invalid '<=' at end of declaration; did you mean '='?}}
120     (void)x8;
121     int x9 <<= 0; // expected-error {{invalid '<<=' at end of declaration; did you mean '='?}}
122     (void)x9;
123     int x10 >= 0; // expected-error {{invalid '>=' at end of declaration; did you mean '='?}}
124     (void)x10;
125     int x11 >>= 0; // expected-error {{invalid '>>=' at end of declaration; did you mean '='?}}
126     (void)x11;
127     int x12 ^= 0; // expected-error {{invalid '^=' at end of declaration; did you mean '='?}}
128     (void)x12;
129     int x13 |= 0; // expected-error {{invalid '|=' at end of declaration; did you mean '='?}}
130     (void)x13;
131     int x14 == 0; // expected-error {{invalid '==' at end of declaration; did you mean '='?}}
132     (void)x14;
133     if (int x = 0)  { (void)x; }
134     if (int x1 &= 0) { (void)x1; } // expected-error {{invalid '&=' at end of declaration; did you mean '='?}}
135     if (int x2 *= 0) { (void)x2; } // expected-error {{invalid '*=' at end of declaration; did you mean '='?}}
136     if (int x3 += 0) { (void)x3; } // expected-error {{invalid '+=' at end of declaration; did you mean '='?}}
137     if (int x4 -= 0) { (void)x4; } // expected-error {{invalid '-=' at end of declaration; did you mean '='?}}
138     if (int x5 != 0) { (void)x5; } // expected-error {{invalid '!=' at end of declaration; did you mean '='?}}
139     if (int x6 /= 0) { (void)x6; } // expected-error {{invalid '/=' at end of declaration; did you mean '='?}}
140     if (int x7 %= 0) { (void)x7; } // expected-error {{invalid '%=' at end of declaration; did you mean '='?}}
141     if (int x8 <= 0) { (void)x8; } // expected-error {{invalid '<=' at end of declaration; did you mean '='?}}
142     if (int x9 <<= 0) { (void)x9; } // expected-error {{invalid '<<=' at end of declaration; did you mean '='?}}
143     if (int x10 >= 0) { (void)x10; } // expected-error {{invalid '>=' at end of declaration; did you mean '='?}}
144     if (int x11 >>= 0) { (void)x11; } // expected-error {{invalid '>>=' at end of declaration; did you mean '='?}}
145     if (int x12 ^= 0) { (void)x12; } // expected-error {{invalid '^=' at end of declaration; did you mean '='?}}
146     if (int x13 |= 0) { (void)x13; } // expected-error {{invalid '|=' at end of declaration; did you mean '='?}}
147     if (int x14 == 0) { (void)x14; } // expected-error {{invalid '==' at end of declaration; did you mean '='?}}
148 }
149 }
150 
151 template <class A>
152 class F1 {
153 public:
154   template <int B>
155   class Iterator {
156   };
157 };
158 
159 template<class T>
160 class F2  {
161   typename F1<T>:: /*template*/  Iterator<0> Mypos; // expected-error {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
162 };
163 
164 template <class T>
165 void f(){
166   typename F1<T>:: /*template*/ Iterator<0> Mypos; // expected-error {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
167 }
168 
169 // Tests for &/* fixits radar 7113438.
170 class AD {};
171 class BD: public AD {};
172 
173 void test (BD &br) {
174   AD* aPtr;
175   BD b;
176   aPtr = b; // expected-error {{assigning to 'AD *' from incompatible type 'BD'; take the address with &}}
177   aPtr = br; // expected-error {{assigning to 'AD *' from incompatible type 'BD'; take the address with &}}
178 }
179 
180 void foo1() const {} // expected-error {{non-member function cannot have 'const' qualifier}}
181 void foo2() volatile {} // expected-error {{non-member function cannot have 'volatile' qualifier}}
182 void foo3() const volatile {} // expected-error {{non-member function cannot have 'const volatile' qualifier}}
183 
184 struct S { void f(int, char); };
185 int itsAComma,
186 itsAComma2 = 0,
187 oopsAComma(42), // expected-error {{expected ';' at end of declaration}}
188 AD oopsMoreCommas() {
189   static int n = 0, // expected-error {{expected ';' at end of declaration}}
190   static char c,
191   &d = c, // expected-error {{expected ';' at end of declaration}}
192   S s, // expected-error {{expected ';' at end of declaration}}
193   s.f(n, d);
194   AD ad, // expected-error {{expected ';' at end of declaration}}
195   return ad;
196 }
197 struct MoreAccidentalCommas {
198   int a : 5,
199       b : 7,
200         : 4, // expected-error {{expected ';' at end of declaration}}
201   char c, // expected-error {{expected ';' at end of declaration}}
202   double d, // expected-error {{expected ';' at end of declaration}}
203   MoreAccidentalCommas *next, // expected-error {{expected ';' at end of declaration}}
204 public:
205   int k, // expected-error {{expected ';' at end of declaration}}
206   friend void f(MoreAccidentalCommas) {}
207   int k2, // expected-error {{expected ';' at end of declaration}}
208   virtual void g(), // expected-error {{expected ';' at end of declaration}}
209 };
210 
211 template<class T> struct Mystery;
212 template<class T> typedef Mystery<T>::type getMysteriousThing() { // \
213   expected-error {{function definition declared 'typedef'}} \
214   expected-error {{missing 'typename' prior to dependent}}
215   return Mystery<T>::get();
216 }
217 
218 template<template<typename> Foo, // expected-error {{template template parameter requires 'class' after the parameter list}}
219          template<typename> typename Bar, // expected-warning {{template template parameter using 'typename' is a C++17 extension}}
220          template<typename> struct Baz> // expected-error {{template template parameter requires 'class' after the parameter list}}
221 void func();
222 
223 namespace ShadowedTagType {
224 class Foo {
225  public:
226   enum Bar { X, Y };
227   void SetBar(Bar bar);
228   Bar Bar(); // expected-note 2 {{enum 'Bar' is hidden by a non-type declaration of 'Bar' here}}
229  private:
230   Bar bar_; // expected-error {{must use 'enum' tag to refer to type 'Bar' in this scope}}
231 };
232 void Foo::SetBar(Bar bar) { bar_ = bar; } // expected-error {{must use 'enum' tag to refer to type 'Bar' in this scope}}
233 }
234 
235 #define NULL __null
236 char c = NULL; // expected-warning {{implicit conversion of NULL constant to 'char'}}
237 double dbl = NULL; // expected-warning {{implicit conversion of NULL constant to 'double'}}
238 
239 namespace arrow_suggest {
240 
241 template <typename T>
242 class wrapped_ptr {
243  public:
244   wrapped_ptr(T* ptr) : ptr_(ptr) {}
245   T* operator->() { return ptr_; }
246  private:
247   T *ptr_;
248 };
249 
250 class Worker {
251  public:
252   void DoSomething();
253 };
254 
255 void test() {
256   wrapped_ptr<Worker> worker(new Worker);
257   worker.DoSomething(); // expected-error {{no member named 'DoSomething' in 'arrow_suggest::wrapped_ptr<arrow_suggest::Worker>'; did you mean to use '->' instead of '.'?}}
258 }
259 
260 } // namespace arrow_suggest
261 
262 // Make sure fixing namespace-qualified identifiers functions properly with
263 // namespace-aware typo correction/
264 namespace redecl_typo {
265 namespace Foo {
266   void BeEvil(); // expected-note {{'BeEvil' declared here}}
267 }
268 namespace Bar {
269   namespace Foo {
270     bool isGood(); // expected-note {{'Bar::Foo::isGood' declared here}}
271     void beEvil();
272   }
273 }
274 bool Foo::isGood() { // expected-error {{out-of-line definition of 'isGood' does not match any declaration in namespace 'redecl_typo::Foo'; did you mean 'Bar::Foo::isGood'?}}
275   return true;
276 }
277 void Foo::beEvil() {} // expected-error {{out-of-line definition of 'beEvil' does not match any declaration in namespace 'redecl_typo::Foo'; did you mean 'BeEvil'?}}
278 }
279 
280 // Test behavior when a template-id is ended by a token which starts with '>'.
281 namespace greatergreater {
282   template<typename T> struct S { S(); S(T); };
283   void f(S<int>=0); // expected-error {{a space is required between a right angle bracket and an equals sign (use '> =')}}
284 
285   // FIXME: The fix-its here overlap so -fixit mode can't apply the second one.
286   //void f(S<S<int>>=S<int>());
287 
288   struct Shr {
289     template<typename T> Shr(T);
290     template<typename T> void operator >>=(T);
291   };
292 
293   template<template<typename>> struct TemplateTemplateParam; // expected-error {{requires 'class'}}
294 
295   template <typename T> int t = 0;
296   void g() {
297     int p = 0;
298     (void)(t<int>==p); // expected-error {{use '> ='}}
299     (void)(t<int>>=p); // expected-error {{use '> >'}}
300 #if __cplusplus < 201103L
301     (void)(t<S<int>>>=p); // expected-error {{use '> >'}}
302     (Shr)t<S<int>>>>=p; // expected-error {{use '> >'}}
303 #endif
304 
305     // FIXME: We correct this to 't<int> > >= p;' not 't<int> >>= p;'
306     //(Shr)t<int>>>=p;
307 
308     // FIXME: The fix-its here overlap.
309     //(void)(t<S<int>>==p);
310   }
311 }
312 
313 class foo {
314   static void test() {
315     (void)&i; // expected-error{{must explicitly qualify name of member function when taking its address}}
316   }
317   int i();
318 };
319 
320 namespace dtor_fixit {
321   struct foo {
322     ~bar() { }  // expected-error {{undeclared identifier 'bar' in destructor name}}
323     // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:6-[[@LINE-1]]:9}:"foo"
324   };
325 
326   class bar { // expected-note {{found}}
327     ~bar();
328   };
329   ~bar::bar() {} // expected-error {{'~' in destructor name should be after nested name specifier}}
330   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:4}:""
331   // CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:9-[[@LINE-2]]:9}:"~"
332 
333   namespace N {
334     typedef foo T;
335     template <typename T> struct X {};
336   }
337   void f(foo *p, N::X<int> *x) {
338     p->~undeclared(); // expected-error {{undeclared}}
339     // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:19}:"foo"
340 
341     p->~bar(); // expected-error {{does not match}}
342     // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:12}:"foo"
343 
344     // FIXME: This is a bad fixit; it'd be better to suggest replacing 'foo'
345     // with 'T'.
346     p->N::T::~foo(); // expected-warning {{requires the name after '::~' to be found in the same scope as the name before}}
347     // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:12-[[@LINE-1]]:12}:"::foo"
348 
349     typedef foo baz; // expected-note {{found}}
350     p->dtor_fixit::foo::~baz(); // expected-warning {{only found in lexical scope}}
351     // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:8-[[@LINE-1]]:25}:""
352 
353     // FIXME: This is a bad fixit; it'd be better to suggest adding the
354     // template arguments.
355     x->N::X<int>::~X(); // expected-warning {{same scope}}
356     // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:17-[[@LINE-1]]:17}:"::X"
357   }
358 }
359 
360 namespace PR5066 {
361   template<typename T> struct X {};
362   X<int *p> x; // expected-error {{type-id cannot have a name}}
363 }
364 
365 namespace PR5898 {
366   class A {
367   public:
368     const char *str();
369   };
370   const char* foo(A &x)
371   {
372     return x.str.();  // expected-error {{unexpected '.' in function call; perhaps remove the '.'?}}
373   }
374   bool bar(A x, const char *y) {
375     return foo->(x) == y;  // expected-error {{unexpected '->' in function call; perhaps remove the '->'?}}
376   }
377 }
378 
379 namespace PR15045 {
380   class Cl0 {
381   public:
382     int a;
383   };
384 
385   int f() {
386     Cl0 c;
387     return c->a;  // expected-error {{member reference type 'PR15045::Cl0' is not a pointer; did you mean to use '.'?}}
388   }
389 }
390 
391 namespace curly_after_base_clause {
392 struct A { void f(); };
393 struct B : A // expected-error{{expected '{' after base class list}}
394   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
395   int i;
396 };
397 struct C : A // expected-error{{expected '{' after base class list}}
398   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
399   using A::f;
400 };
401 struct D : A // expected-error{{expected '{' after base class list}}
402   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
403     protected:
404 };
405 struct E : A  // expected-error{{expected '{' after base class list}}
406   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
407   template<typename T> struct inner { };
408 };
409 struct F : A  // expected-error{{expected '{' after base class list}}
410   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
411   F() { }
412 };
413 #if __cplusplus >= 201103L
414 struct G : A  // expected-error{{expected '{' after base class list}}
415   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
416   constexpr G(int) { }
417 };
418 struct H : A  // expected-error{{expected '{' after base class list}}
419   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
420   static_assert(true, "");
421 };
422 #endif
423 }
424 
425 struct conversion_operator {
426   conversion_operator::* const operator int(); // expected-error {{put the complete type after 'operator'}}
427   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:32}:""
428   // CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:44-[[@LINE-2]]:44}:" conversion_operator::* const"
429 };
430 
431 struct const_zero_init {
432   int a;
433 };
434 const const_zero_init czi; // expected-error {{default initialization of an object of const type 'const const_zero_init'}}
435 // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:26-[[@LINE-1]]:26}:"{}"
436 int use_czi = czi.a;
437 
438 namespace dotPointerDestructor {
439 
440 struct Bar {
441   ~Bar();
442 };
443 
444 void bar(Bar *o) {
445   o.~Bar(); // expected-error {{member reference type 'dotPointerDestructor::Bar *' is a pointer; did you mean to use '->'}}
446 }  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:4-[[@LINE-1]]:5}:"->"
447 
448 }
449