Home | History | Annotate | Download | only in FixIt 
      1 // RUN: %clang_cc1 -verify -std=c++11 -Wno-anonymous-pack-parens %s
      2 // RUN: cp %s %t
      3 // RUN: not %clang_cc1 -x c++ -std=c++11 -fixit %t
      4 // RUN: %clang_cc1 -Wall -pedantic -x c++ -std=c++11 %t
      5 
      6 /* This is a test of the various code modification hints that only
      7    apply in C++0x. */
      8 struct A {
      9   explicit operator int(); // expected-note{{conversion to integral type}}
     10 };
     11 
     12 void x() {
     13   switch(A()) { // expected-error{{explicit conversion to}}
     14   }
     15 }
     16 
     17 using ::T = void; // expected-error {{name defined in alias declaration must be an identifier}}
     18 using typename U = void; // expected-error {{name defined in alias declaration must be an identifier}}
     19 using typename ::V = void; // expected-error {{name defined in alias declaration must be an identifier}}
     20 
     21 namespace SemiCommaTypo {
     22   int m {},
     23   n [[]], // expected-error {{expected ';' at end of declaration}}
     24   int o;
     25 
     26   struct Base {
     27     virtual void f2(), f3();
     28   };
     29   struct MemberDeclarator : Base {
     30     int k : 4,
     31         //[[]] : 1, FIXME: test this once we support attributes here
     32         : 9, // expected-error {{expected ';' at end of declaration}}
     33     char c, // expected-error {{expected ';' at end of declaration}}
     34     typedef void F(), // expected-error {{expected ';' at end of declaration}}
     35     F f1,
     36       f2 final,
     37       f3 override, // expected-error {{expected ';' at end of declaration}}
     38   };
     39 }
     40 
     41 namespace ScopedEnum {
     42   enum class E { a };
     43 
     44   enum class E b = E::a; // expected-error {{must use 'enum' not 'enum class'}}
     45   struct S {
     46     friend enum class E; // expected-error {{must use 'enum' not 'enum class'}}
     47   };
     48 }
     49 
     50 struct S2 {
     51   void f(int i);
     52   void g(int i);
     53 };
     54 
     55 void S2::f(int i) {
     56   (void)[&, &i, &i]{}; // expected-error 2{{'&' cannot precede a capture when the capture default is '&'}}
     57   (void)[=, this]{ this->g(5); }; // expected-error{{'this' cannot be explicitly captured}}
     58   (void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
     59   (void)[&, i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
     60   (void)[] mutable { }; // expected-error{{lambda requires '()' before 'mutable'}}
     61   (void)[] -> int { }; // expected-error{{lambda requires '()' before return type}}
     62 }
     63 
     64 #define bar "bar"
     65 const char *p = "foo"bar; // expected-error {{requires a space between}}
     66 #define ord - '0'
     67 int k = '4'ord; // expected-error {{requires a space between}}
     68 
     69 void operator"x" _y(char); // expected-error {{must be '""'}}
     70 void operator L"" _z(char); // expected-error {{encoding prefix}}
     71 void operator "x" "y" U"z" ""_whoops "z" "y"(char); // expected-error {{must be '""'}}
     72 
     73 void f() {
     74   'b'_y;
     75   'c'_z;
     76   'd'_whoops;
     77 }
     78 
     79 template<typename ...Ts> struct MisplacedEllipsis {
     80   int a(Ts ...(x)); // expected-error {{'...' must immediately precede declared identifier}}
     81   int b(Ts ...&x); // expected-error {{'...' must immediately precede declared identifier}}
     82   int c(Ts ...&); // expected-error {{'...' must be innermost component of anonymous pack declaration}}
     83   int d(Ts ...(...&...)); // expected-error 2{{'...' must be innermost component of anonymous pack declaration}}
     84   int e(Ts ...*[]); // expected-error {{'...' must be innermost component of anonymous pack declaration}}
     85   int f(Ts ...(...*)()); // expected-error 2{{'...' must be innermost component of anonymous pack declaration}}
     86   int g(Ts ...()); // ok
     87 };
     88 namespace TestMisplacedEllipsisRecovery {
     89   MisplacedEllipsis<int, char> me;
     90   int i; char k;
     91   int *ip; char *kp;
     92   int ifn(); char kfn();
     93   int a = me.a(i, k);
     94   int b = me.b(i, k);
     95   int c = me.c(i, k);
     96   int d = me.d(i, k);
     97   int e = me.e(&ip, &kp);
     98   int f = me.f(ifn, kfn);
     99   int g = me.g(ifn, kfn);
    100 }
    101 
    102 template<template<typename> ...Foo, // expected-error {{template template parameter requires 'class' after the parameter list}}
    103          template<template<template<typename>>>> // expected-error 3 {{template template parameter requires 'class' after the parameter list}}
    104 void func();
    105 
    106 template<int *ip> struct IP { }; // expected-note{{declared here}}
    107 IP<0> ip0; // expected-error{{null non-type template argument must be cast to template parameter type 'int *'}}
    108 
    109 namespace MissingSemi {
    110   struct a // expected-error {{expected ';' after struct}}
    111   struct b // expected-error {{expected ';' after struct}}
    112   enum x : int { x1, x2, x3 } // expected-error {{expected ';' after enum}}
    113   struct c // expected-error {{expected ';' after struct}}
    114   enum x : int // expected-error {{expected ';' after enum}}
    115   // FIXME: The following gives a poor diagnostic (we parse the 'int' and the
    116   // 'struct' as part of the same enum-base.
    117   //   enum x : int
    118   //   struct y
    119   namespace N {
    120     struct d // expected-error {{expected ';' after struct}}
    121   }
    122 }
    123 
    124 namespace NonStaticConstexpr {
    125   struct foo {
    126     constexpr int i; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
    127     constexpr int j = 7; // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}}
    128     foo() : i(3) {
    129     }
    130     static int get_j() {
    131       return j;
    132     }
    133   };
    134 }
    135 
    136 int RegisterVariable() {
    137   register int n; // expected-warning {{'register' storage class specifier is deprecated}}
    138   return n;
    139 }
    140