Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -verify -Wc++11-compat %s
      2 class C {
      3 public:
      4   auto int errx; // expected-error {{storage class specified for a member declaration}}
      5 #if __cplusplus <= 199711L
      6   // expected-warning@-2 {{'auto' storage class specifier is redundant}}
      7 #else
      8   // expected-warning@-4 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
      9 #endif
     10   register int erry; // expected-error {{storage class specified for a member declaration}}
     11   extern int errz; // expected-error {{storage class specified for a member declaration}}
     12 
     13   static void sm() {
     14     sx = 0;
     15     this->x = 0; // expected-error {{invalid use of 'this' outside of a non-static member function}}
     16     x = 0; // expected-error {{invalid use of member 'x' in static member function}}
     17   }
     18 
     19   class NestedC {
     20   public:
     21     NestedC(int);
     22     void f() {
     23       sx = 0;
     24       x = 0; // expected-error {{use of non-static data member 'x' of 'C' from nested type 'NestedC'}}
     25       sm();
     26       m(); // expected-error {{call to non-static member function 'm' of 'C' from nested type 'NestedC'}}
     27     }
     28   };
     29 
     30   int b : 1, w : 2;
     31   int : 1, : 2;
     32   typedef int E : 1; // expected-error {{typedef member 'E' cannot be a bit-field}}
     33   static int sb : 1; // expected-error {{static member 'sb' cannot be a bit-field}}
     34   static int vs;
     35 
     36   typedef int func();
     37   func tm;
     38   func *ptm;
     39   func btm : 1; // expected-error {{bit-field 'btm' has non-integral type}}
     40   NestedC bc : 1; // expected-error {{bit-field 'bc' has non-integral type}}
     41 
     42   enum E1 { en1, en2 };
     43 
     44   int i = 0;
     45 #if __cplusplus <= 199711L
     46   // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
     47 #endif
     48   static int si = 0; // expected-error {{non-const static data member must be initialized out of line}}
     49   static const NestedC ci = 0; // expected-error {{static data member of type 'const C::NestedC' must be initialized out of line}}
     50   static const int nci = vs; // expected-error {{in-class initializer for static data member is not a constant expression}}
     51   static const int vi = 0;
     52   static const volatile int cvi = 0; // ok, illegal in C++11
     53 #if __cplusplus >= 201103L
     54   // expected-error@-2 {{static const volatile data member must be initialized out of line}}
     55 #endif
     56   static const E evi = 0;
     57 
     58   void m() {
     59     sx = 0;
     60     this->x = 0;
     61     y = 0;
     62     this = 0; // expected-error {{expression is not assignable}}
     63   }
     64 
     65   int f1(int p) {
     66     A z = 6;
     67     return p + x + this->y + z;
     68   }
     69 
     70   typedef int A;
     71 
     72   virtual int viv; // expected-error {{'virtual' can only appear on non-static member functions}}
     73   virtual static int vsif(); // expected-error {{'virtual' can only appear on non-static member functions}}
     74   virtual int vif();
     75 
     76 private:
     77   int x,y;
     78   static int sx;
     79 
     80   mutable int mi;
     81   mutable int &mir; // expected-error {{'mutable' cannot be applied to references}}
     82   mutable void mfn(); // expected-error {{'mutable' cannot be applied to functions}}
     83   mutable const int mci; // expected-error {{'mutable' and 'const' cannot be mixed}}
     84 
     85   static const int number = 50;
     86   static int arr[number];
     87 };
     88 
     89 class C2 {
     90   void f() {
     91     static int lx;
     92     class LC1 {
     93       int m() { return lx; }
     94     };
     95     class LC2 {
     96       int m() { return lx; }
     97     };
     98   }
     99 };
    100 
    101 struct C3 {
    102   int i;
    103   mutable int j;
    104 };
    105 void f()
    106 {
    107   const C3 c3 = { 1, 2 };
    108   (void)static_cast<int*>(&c3.i); // expected-error {{static_cast from 'const int *' to 'int *' is not allowed}}
    109   // but no error here
    110   (void)static_cast<int*>(&c3.j);
    111 }
    112 
    113 // Play with mutable a bit more, to make sure it doesn't crash anything.
    114 mutable int gi; // expected-error {{'mutable' can only be applied to member variables}}
    115 mutable void gfn(); // expected-error {{illegal storage class on function}}
    116 void ogfn()
    117 {
    118   mutable int ml; // expected-error {{'mutable' can only be applied to member variables}}
    119 
    120   // PR3020: This used to crash due to double ownership of C4.
    121   struct C4;
    122   C4; // expected-warning {{declaration does not declare anything}}
    123 }
    124 
    125 struct C4 {
    126   void f(); // expected-note{{previous declaration is here}}
    127   int f; // expected-error{{duplicate member 'f'}}
    128 };
    129 
    130 // PR5415 - don't hang!
    131 struct S
    132 {
    133   void f(); // expected-note 1 {{previous declaration}} expected-note {{previous declaration}}
    134   void S::f() {} // expected-error {{extra qualification on member}} expected-error {{class member cannot be redeclared}}
    135   void f() {} // expected-error {{class member cannot be redeclared}}
    136 };
    137 
    138 // Don't crash on this bogus code.
    139 namespace pr6629 {
    140   template<class T1, class T2> struct foo :
    141     bogus<foo<T1,T2> > // expected-error {{unknown template name 'bogus'}}
    142   { };
    143 
    144   template<> struct foo<unknown,unknown> { // expected-error {{undeclared identifier 'unknown'}}
    145     template <typename U1, typename U2> struct bar {
    146       typedef bar type;
    147       static const int value = 0;
    148     };
    149   };
    150 }
    151 
    152 namespace PR7153 {
    153   class EnclosingClass {
    154   public:
    155     struct A { } mutable *member;
    156   };
    157 
    158   void f(const EnclosingClass &ec) {
    159     ec.member = 0;
    160   }
    161 }
    162 
    163 namespace PR7196 {
    164   struct A {
    165     int a;
    166 
    167     void f() {
    168       char i[sizeof(a)];
    169       enum { x = sizeof(i) };
    170       enum { y = sizeof(a) };
    171     }
    172   };
    173 }
    174 
    175 namespace rdar8066414 {
    176   class C {
    177     C() {}
    178   } // expected-error{{expected ';' after class}}
    179 }
    180 
    181 namespace rdar8367341 {
    182   float foo();
    183 #if __cplusplus >= 201103L
    184   // expected-note@-2 {{declared here}}
    185 #endif
    186 
    187   struct A {
    188 #if __cplusplus <= 199711L
    189     static const float x = 5.0f; // expected-warning {{in-class initializer for static data member of type 'const float' is a GNU extension}}
    190     static const float y = foo(); // expected-warning {{in-class initializer for static data member of type 'const float' is a GNU extension}} expected-error {{in-class initializer for static data member is not a constant expression}}
    191 #else
    192     static constexpr float x = 5.0f;
    193     static constexpr float y = foo(); // expected-error {{constexpr variable 'y' must be initialized by a constant expression}} expected-note {{non-constexpr function 'foo' cannot be used in a constant expression}}
    194 #endif
    195   };
    196 }
    197 
    198 namespace with_anon {
    199 struct S {
    200   union {
    201     char c;
    202   };
    203 };
    204 
    205 void f() {
    206     S::c; // expected-error {{invalid use of non-static data member}}
    207 }
    208 }
    209 
    210 struct PR9989 {
    211   static int const PR9989_Member = sizeof PR9989_Member;
    212 };
    213