external/bsd/llvm/dist/clang/test/FixIt/fixit.cpp

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