clang/test/SemaCXX/default-assignment-operator.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
   3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   4
   5 class Base { // expected-warning{{class 'Base' does not declare any constructor to initialize its non-modifiable members}}
   6 #if __cplusplus <= 199711L
   7 // expected-error@-2 {{cannot define the implicit copy assignment operator for 'Base', because non-static reference member 'ref' cannot use copy assignment operator}}
   8 #endif
   9
  10   int &ref; // expected-note{{reference member 'ref' will never be initialized}}
  11 #if __cplusplus <= 199711L
  12   // expected-note@-2 {{declared here}}
  13 #else
  14   // expected-note@-4 2 {{copy assignment operator of 'Base' is implicitly deleted because field 'ref' is of reference type 'int &'}}
  15 #endif
  16 };
  17
  18 class X  : Base {
  19 #if __cplusplus <= 199711L
  20 // expected-note@-2 {{assignment operator for 'Base' first required here}}
  21 // expected-error@-3 {{cannot define the implicit copy assignment operator for 'X', because non-static const member 'cint' cannot use copy assignment operator}}
  22 #else
  23 // expected-note@-5 2 {{copy assignment operator of 'X' is implicitly deleted because base class 'Base' has a deleted copy assignment operator}}
  24 #endif
  25
  26 public:
  27   X();
  28   const int cint;
  29 #if __cplusplus <= 199711L
  30 // expected-note@-2 {{declared here}}
  31 #endif
  32 };
  33
  34 struct Y  : X {
  35   Y();
  36   Y& operator=(const Y&);
  37   Y& operator=(volatile Y&);
  38   Y& operator=(const volatile Y&);
  39   Y& operator=(Y&);
  40 };
  41
  42 class Z : Y {};
  43
  44 Z z1;
  45 Z z2;
  46
  47 // Test1
  48 void f(X x, const X cx) {
  49   x = cx;
  50 #if __cplusplus <= 199711L
  51   // expected-note@-2 2{{assignment operator for 'X' first required here}}
  52 #else
  53   // expected-error@-4 {{object of type 'X' cannot be assigned because its copy assignment operator is implicitly deleted}}
  54 #endif
  55
  56   x = cx;
  57 #if __cplusplus >= 201103L
  58   // expected-error@-2 {{object of type 'X' cannot be assigned because its copy assignment operator is implicitly deleted}}
  59 #endif
  60   z1 = z2;
  61 }
  62
  63 // Test2
  64 class T {};
  65 T t1;
  66 T t2;
  67
  68 void g() {
  69   t1 = t2;
  70 }
  71
  72 // Test3
  73 class V {
  74 public:
  75   V();
  76   V &operator = (V &b);
  77 };
  78
  79 class W : V {};
  80 W w1, w2;
  81
  82 void h() {
  83   w1 = w2;
  84 }
  85
  86 // Test4
  87
  88 class B1 {
  89 public:
  90   B1();
  91   B1 &operator = (B1 b);
  92 };
  93
  94 class D1 : B1 {};
  95 D1 d1, d2;
  96
  97 void i() {
  98   d1 = d2;
  99 }
 100
 101 // Test5
 102
 103 class E1 {
 104 #if __cplusplus <= 199711L
 105 // expected-error@-2 {{cannot define the implicit copy assignment operator for 'E1', because non-static const member 'a' cannot use copy assignment operator}}
 106 #endif
 107
 108 public:
 109   const int a;
 110 #if __cplusplus <= 199711L
 111 // expected-note@-2 {{declared here}}
 112 #else
 113 // expected-note@-4 {{copy assignment operator of 'E1' is implicitly deleted because field 'a' is of const-qualified type 'const int'}}
 114 #endif
 115   E1() : a(0) {}
 116
 117 };
 118
 119 E1 e1, e2;
 120
 121 void j() {
 122   e1 = e2;
 123 #if __cplusplus <= 199711L
 124   // expected-note@-2 {{assignment operator for 'E1' first required here}}
 125 #else
 126   // expected-error@-4 {{object of type 'E1' cannot be assigned because its copy assignment operator is implicitly deleted}}
 127 #endif
 128 }
 129
 130 namespace ProtectedCheck {
 131   struct X {
 132   protected:
 133     X &operator=(const X&);
 134 #if __cplusplus <= 199711L
 135     // expected-note@-2 {{declared protected here}}
 136 #endif
 137   };
 138
 139   struct Y : public X { };
 140
 141   void f(Y y) { y = y; }
 142
 143   struct Z {
 144 #if __cplusplus <= 199711L
 145   // expected-error@-2 {{'operator=' is a protected member of 'ProtectedCheck::X'}}
 146 #endif
 147     X x;
 148 #if __cplusplus >= 201103L
 149     // expected-note@-2 {{copy assignment operator of 'Z' is implicitly deleted because field 'x' has an inaccessible copy assignment operator}}
 150 #endif
 151   };
 152
 153   void f(Z z) { z = z; }
 154 #if __cplusplus <= 199711L
 155   // expected-note@-2 {{implicit copy assignment operator}}
 156 #else
 157   // expected-error@-4 {{object of type 'ProtectedCheck::Z' cannot be assigned because its copy assignment operator is implicitly deleted}}
 158 #endif
 159 }
 160
 161 namespace MultiplePaths {
 162   struct X0 {
 163     X0 &operator=(const X0&);
 164   };
 165
 166   struct X1 : public virtual X0 { };
 167
 168   struct X2 : X0, X1 { }; // expected-warning{{direct base 'MultiplePaths::X0' is inaccessible due to ambiguity:\n    struct MultiplePaths::X2 -> struct MultiplePaths::X0\n    struct MultiplePaths::X2 -> struct MultiplePaths::X1 -> struct MultiplePaths::X0}}
 169
 170   void f(X2 x2) { x2 = x2; }
 171 }