Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -verify %s
      2 
      3 class Base { // expected-error {{cannot define the implicit copy assignment operator for 'Base', because non-static reference member 'ref' cannot use copy assignment operator}} \
      4   // expected-warning{{class 'Base' does not declare any constructor to initialize its non-modifiable members}}
      5   int &ref;  // expected-note {{declared here}} \
      6   // expected-note{{reference member 'ref' will never be initialized}}
      7 };
      8 
      9 class X  : Base {  // // expected-error {{cannot define the implicit copy assignment operator for 'X', because non-static const member 'cint' cannot use copy assignment operator}} \
     10 // expected-note{{assignment operator for 'Base' first required here}}
     11 public:
     12   X();
     13   const int cint;  // expected-note {{declared here}}
     14 };
     15 
     16 struct Y  : X {
     17   Y();
     18   Y& operator=(const Y&);
     19   Y& operator=(volatile Y&);
     20   Y& operator=(const volatile Y&);
     21   Y& operator=(Y&);
     22 };
     23 
     24 class Z : Y {};
     25 
     26 Z z1;
     27 Z z2;
     28 
     29 // Test1
     30 void f(X x, const X cx) {
     31   x = cx; // expected-note{{assignment operator for 'X' first required here}}
     32   x = cx;
     33   z1 = z2;
     34 }
     35 
     36 // Test2
     37 class T {};
     38 T t1;
     39 T t2;
     40 
     41 void g() {
     42   t1 = t2;
     43 }
     44 
     45 // Test3
     46 class V {
     47 public:
     48   V();
     49   V &operator = (V &b);
     50 };
     51 
     52 class W : V {};
     53 W w1, w2;
     54 
     55 void h() {
     56   w1 = w2;
     57 }
     58 
     59 // Test4
     60 
     61 class B1 {
     62 public:
     63   B1();
     64   B1 &operator = (B1 b);
     65 };
     66 
     67 class D1 : B1 {};
     68 D1 d1, d2;
     69 
     70 void i() {
     71   d1 = d2;
     72 }
     73 
     74 // Test5
     75 
     76 class E1 { // expected-error{{cannot define the implicit copy assignment operator for 'E1', because non-static const member 'a' cannot use copy assignment operator}}
     77 
     78 public:
     79   const int a; // expected-note{{declared here}}
     80   E1() : a(0) {}
     81 
     82 };
     83 
     84 E1 e1, e2;
     85 
     86 void j() {
     87   e1 = e2; // expected-note{{assignment operator for 'E1' first required here}}
     88 }
     89 
     90 namespace ProtectedCheck {
     91   struct X {
     92   protected:
     93     X &operator=(const X&); // expected-note{{declared protected here}}
     94   };
     95 
     96   struct Y : public X { };
     97 
     98   void f(Y y) { y = y; }
     99 
    100   struct Z { // expected-error{{'operator=' is a protected member of 'ProtectedCheck::X'}}
    101     X x;
    102   };
    103 
    104   void f(Z z) { z = z; }  // expected-note{{implicit copy assignment operator}}
    105 
    106 }
    107 
    108 namespace MultiplePaths {
    109   struct X0 {
    110     X0 &operator=(const X0&);
    111   };
    112 
    113   struct X1 : public virtual X0 { };
    114 
    115   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}}
    116 
    117   void f(X2 x2) { x2 = x2; }
    118 }
    119