Clang Project

clang_source_code/test/FixIt/fixit.cpp
1// RUN: %clang_cc1 -pedantic -Wall -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++98 %s
2// RUN: cp %s %t-98
3// RUN: not %clang_cc1 -pedantic -Wall -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++98 %t-98
4// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-comment -fcxx-exceptions -x c++ -std=c++98 %t-98
5// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -x c++ -std=c++11 %s 2>&1 | FileCheck %s
6// RUN: %clang_cc1 -pedantic -Wall -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++11 %s
7// RUN: cp %s %t-11
8// RUN: not %clang_cc1 -pedantic -Wall -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++11 %t-11
9// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-comment -fcxx-exceptions -x c++ -std=c++11 %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
16struct C1 {
17  virtual void f();
18  static void g();
19};
20struct C2 : virtual public virtual C1 { }; // expected-error{{duplicate}}
21
22virtual void C1::f() { } // expected-error{{'virtual' can only be specified inside the class definition}}
23
24static void C1::g() { } // expected-error{{'static' can only be specified inside the class definition}}
25
26template<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
31CT<10 >> 2> ct; // expected-warning{{require parentheses}}
32#endif
33
34class C3 {
35public:
36  C3(C3, int i = 0); // expected-error{{copy constructor must pass its first argument by reference}}
37};
38
39struct CT<0> { }; // expected-error{{'template<>'}}
40
41template<> union CT<1> { }; // expected-error{{tag type}}
42
43struct CT<2>::Inner<int> { }; // expected-error 2{{'template<>'}}
44
45// Access declarations
46class A {
47protected:
48  int foo();
49};
50
51class 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
59void f() throw(); // expected-note{{previous}}
60void f(); // expected-error{{missing exception specification}}
61
62namespace 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
71namespace 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
81class C {
82  int C::foo(); // expected-error {{extra qualification}}
83};
84
85namespace rdar8488464 {
86int x = 0;
87int x1 &= 0; // expected-error {{invalid '&=' at end of declaration; did you mean '='?}}
88int x2 *= 0; // expected-error {{invalid '*=' at end of declaration; did you mean '='?}}
89int x3 += 0; // expected-error {{invalid '+=' at end of declaration; did you mean '='?}}
90int x4 -= 0; // expected-error {{invalid '-=' at end of declaration; did you mean '='?}}
91int x5 != 0; // expected-error {{invalid '!=' at end of declaration; did you mean '='?}}
92int x6 /= 0; // expected-error {{invalid '/=' at end of declaration; did you mean '='?}}
93int x7 %= 0; // expected-error {{invalid '%=' at end of declaration; did you mean '='?}}
94int x8 <= 0; // expected-error {{invalid '<=' at end of declaration; did you mean '='?}}
95int x9 <<= 0; // expected-error {{invalid '<<=' at end of declaration; did you mean '='?}}
96int x10 >= 0; // expected-error {{invalid '>=' at end of declaration; did you mean '='?}}
97int x11 >>= 0; // expected-error {{invalid '>>=' at end of declaration; did you mean '='?}}
98int x12 ^= 0; // expected-error {{invalid '^=' at end of declaration; did you mean '='?}}
99int x13 |= 0; // expected-error {{invalid '|=' at end of declaration; did you mean '='?}}
100int x14 == 0; // expected-error {{invalid '==' at end of declaration; did you mean '='?}}
101
102void 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
151template <class A>
152class F1 {
153public:
154  template <int B>
155  class Iterator {
156  };
157};
158 
159template<class T>
160class F2  {
161  typename F1<T>:: /*template*/  Iterator<0> Mypos; // expected-error {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
162};
163
164template <class T>
165void 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.
170class AD {};
171class BD: public AD {};
172
173void 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
180void foo1() const {} // expected-error {{non-member function cannot have 'const' qualifier}}
181void foo2() volatile {} // expected-error {{non-member function cannot have 'volatile' qualifier}}
182void foo3() const volatile {} // expected-error {{non-member function cannot have 'const volatile' qualifier}}
183
184struct S { void f(int, char); };
185int itsAComma,
186itsAComma2 = 0,
187oopsAComma(42), // expected-error {{expected ';' at end of declaration}}
188AD 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}
197struct 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}}
204public:
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
211template<class T> struct Mystery;
212template<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
218template<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}}
221void func();
222
223namespace ShadowedTagType {
224class 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};
232void 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
236char c = NULL; // expected-warning {{implicit conversion of NULL constant to 'char'}}
237double dbl = NULL; // expected-warning {{implicit conversion of NULL constant to 'double'}}
238
239namespace arrow_suggest {
240
241template <typename T>
242class wrapped_ptr {
243 public:
244  wrapped_ptr(T* ptr) : ptr_(ptr) {}
245  T* operator->() { return ptr_; }
246 private:
247  T *ptr_;
248};
249
250class Worker {
251 public:
252  void DoSomething();
253};
254
255void 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/
264namespace redecl_typo {
265namespace Foo {
266  void BeEvil(); // expected-note {{'BeEvil' declared here}}
267}
268namespace Bar {
269  namespace Foo {
270    bool isGood(); // expected-note {{'Bar::Foo::isGood' declared here}}
271    void beEvil();
272  }
273}
274bool 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}
277void 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 '>'.
281namespace 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> void t();
296  void g() {
297    void (*p)() = &t<int>;
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
313class 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
320namespace dtor_fixit {
321  class foo {
322    ~bar() { }  // expected-error {{expected the class name after '~' to name a destructor}}
323    // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:6-[[@LINE-1]]:9}:"foo"
324  };
325
326  class bar {
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
334namespace PR5066 {
335  template<typename T> struct X {};
336  X<int *p> x; // expected-error {{type-id cannot have a name}}
337}
338
339namespace PR5898 {
340  class A {
341  public:
342    const char *str();
343  };
344  const char* foo(A &x)
345  {
346    return x.str.();  // expected-error {{unexpected '.' in function call; perhaps remove the '.'?}}
347  }
348  bool bar(A x, const char *y) {
349    return foo->(x) == y;  // expected-error {{unexpected '->' in function call; perhaps remove the '->'?}}
350  }
351}
352
353namespace PR15045 {
354  class Cl0 {
355  public:
356    int a;
357  };
358
359  int f() {
360    Cl0 c;
361    return c->a;  // expected-error {{member reference type 'PR15045::Cl0' is not a pointer; did you mean to use '.'?}}
362  }
363}
364
365namespace curly_after_base_clause {
366struct A { void f(); };
367struct B : A // expected-error{{expected '{' after base class list}}
368  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
369  int i;
370};
371struct C : A // expected-error{{expected '{' after base class list}}
372  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
373  using A::f;
374};
375struct D : A // expected-error{{expected '{' after base class list}}
376  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
377    protected:
378};
379struct E : A  // expected-error{{expected '{' after base class list}}
380  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
381  template<typename T> struct inner { };
382};
383struct F : A  // expected-error{{expected '{' after base class list}}
384  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
385  F() { }
386};
387#if __cplusplus >= 201103L
388struct G : A  // expected-error{{expected '{' after base class list}}
389  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
390  constexpr G(int) { }
391};
392struct H : A  // expected-error{{expected '{' after base class list}}
393  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {"
394  static_assert(true, "");
395};
396#endif
397}
398
399struct conversion_operator {
400  conversion_operator::* const operator int(); // expected-error {{put the complete type after 'operator'}}
401  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:32}:""
402  // CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:44-[[@LINE-2]]:44}:" conversion_operator::* const"
403};
404
405struct const_zero_init {
406  int a;
407};
408const const_zero_init czi; // expected-error {{default initialization of an object of const type 'const const_zero_init'}}
409// CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:26-[[@LINE-1]]:26}:"{}"
410int use_czi = czi.a;
411
412namespace dotPointerDestructor {
413
414struct Bar {
415  ~Bar();
416};
417
418void bar(Bar *o) {
419  o.~Bar(); // expected-error {{member reference type 'dotPointerDestructor::Bar *' is a pointer; did you mean to use '->'}}
420}  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:4-[[@LINE-1]]:5}:"->"
421
422}
423
CodeThinker, Enjoy your reading code