clang/test/SemaCXX/class.cpp

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