1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s 2 3 struct Trivial {}; 4 struct NonTrivial { 5 NonTrivial(const NonTrivial&); 6 }; 7 8 // A defaulted copy constructor for a class X is defined as deleted if X has: 9 10 // -- a variant member with a non-trivial corresponding constructor 11 union DeletedNTVariant { 12 NonTrivial NT; // expected-note{{copy constructor of 'DeletedNTVariant' is implicitly deleted because variant field 'NT' has a non-trivial copy constructor}} 13 DeletedNTVariant(); 14 }; 15 DeletedNTVariant DVa; 16 DeletedNTVariant DVb(DVa); // expected-error{{call to implicitly-deleted copy constructor}} 17 18 struct DeletedNTVariant2 { 19 union { 20 NonTrivial NT; // expected-note{{copy constructor of 'DeletedNTVariant2' is implicitly deleted because variant field 'NT' has a non-trivial copy constructor}} 21 }; 22 DeletedNTVariant2(); 23 }; 24 DeletedNTVariant2 DV2a; 25 DeletedNTVariant2 DV2b(DV2a); // expected-error{{call to implicitly-deleted copy constructor}} 26 27 // -- a non-static data member of class type M (or array thereof) that cannot be 28 // copied because overload resolution results in an ambiguity or a function 29 // that is deleted or inaccessible 30 struct NoAccess { 31 NoAccess() = default; 32 private: 33 NoAccess(const NoAccess&); 34 35 friend struct HasAccess; 36 }; 37 38 struct HasNoAccess { 39 NoAccess NA; // expected-note{{copy constructor of 'HasNoAccess' is implicitly deleted because field 'NA' has an inaccessible copy constructor}} 40 }; 41 HasNoAccess HNAa; 42 HasNoAccess HNAb(HNAa); // expected-error{{call to implicitly-deleted copy constructor}} 43 44 struct HasAccess { 45 NoAccess NA; 46 }; 47 48 HasAccess HAa; 49 HasAccess HAb(HAa); 50 51 struct NonConst { 52 NonConst(NonConst&); 53 }; 54 struct Ambiguity { 55 Ambiguity(const Ambiguity&); 56 Ambiguity(volatile Ambiguity&); 57 }; 58 59 struct IsAmbiguous { 60 NonConst NC; 61 Ambiguity A; // expected-note 2{{copy constructor of 'IsAmbiguous' is implicitly deleted because field 'A' has multiple copy constructors}} 62 IsAmbiguous(); 63 }; 64 IsAmbiguous IAa; 65 IsAmbiguous IAb(IAa); // expected-error{{call to implicitly-deleted copy constructor}} 66 67 struct Deleted { 68 IsAmbiguous IA; // expected-note{{copy constructor of 'Deleted' is implicitly deleted because field 'IA' has a deleted copy constructor}} 69 }; 70 Deleted Da; 71 Deleted Db(Da); // expected-error{{call to implicitly-deleted copy constructor}} 72 73 // It's implied (but not stated) that this also applies in the case where 74 // overload resolution would fail. 75 struct VolatileMember { 76 volatile Trivial vm; // expected-note {{has no copy}} 77 } vm1, vm2(vm1); // expected-error {{deleted}} 78 79 // -- a direct or virtual base class B that cannot be copied because overload 80 // resolution results in an ambiguity or a function that is deleted or 81 // inaccessible 82 struct AmbiguousCopyBase : Ambiguity { // expected-note 2{{copy constructor of 'AmbiguousCopyBase' is implicitly deleted because base class 'Ambiguity' has multiple copy constructors}} 83 NonConst NC; 84 }; 85 extern AmbiguousCopyBase ACBa; 86 AmbiguousCopyBase ACBb(ACBa); // expected-error {{deleted copy constructor}} 87 88 struct DeletedCopyBase : AmbiguousCopyBase {}; // expected-note {{copy constructor of 'DeletedCopyBase' is implicitly deleted because base class 'AmbiguousCopyBase' has a deleted copy constructor}} 89 extern DeletedCopyBase DCBa; 90 DeletedCopyBase DCBb(DCBa); // expected-error {{deleted copy constructor}} 91 92 struct InaccessibleCopyBase : NoAccess {}; // expected-note {{copy constructor of 'InaccessibleCopyBase' is implicitly deleted because base class 'NoAccess' has an inaccessible copy constructor}} 93 extern InaccessibleCopyBase ICBa; 94 InaccessibleCopyBase ICBb(ICBa); // expected-error {{deleted copy constructor}} 95 96 // -- any direct or virtual base class or non-static data member of a type with 97 // a destructor that is deleted or inaccessible 98 struct NoAccessDtor { 99 private: 100 ~NoAccessDtor(); 101 friend struct HasAccessDtor; 102 }; 103 104 struct HasNoAccessDtor { 105 NoAccessDtor NAD; // expected-note{{copy constructor of 'HasNoAccessDtor' is implicitly deleted because field 'NAD' has an inaccessible destructor}} 106 HasNoAccessDtor(); 107 ~HasNoAccessDtor(); 108 }; 109 HasNoAccessDtor HNADa; 110 HasNoAccessDtor HNADb(HNADa); // expected-error{{call to implicitly-deleted copy constructor}} 111 112 struct HasAccessDtor { 113 NoAccessDtor NAD; 114 }; 115 HasAccessDtor HADa; 116 HasAccessDtor HADb(HADa); 117 118 struct HasNoAccessDtorBase : NoAccessDtor { // expected-note{{copy constructor of 'HasNoAccessDtorBase' is implicitly deleted because base class 'NoAccessDtor' has an inaccessible destructor}} 119 }; 120 extern HasNoAccessDtorBase HNADBa; 121 HasNoAccessDtorBase HNADBb(HNADBa); // expected-error{{implicitly-deleted copy constructor}} 122 123 // -- a non-static data member of rvalue reference type 124 struct RValue { 125 int && ri = 1; // expected-note{{copy constructor of 'RValue' is implicitly deleted because field 'ri' is of rvalue reference type 'int &&'}} 126 // expected-warning@-1{{binding reference member 'ri' to a temporary}} expected-note@-1 {{here}} 127 }; 128 RValue RVa; 129 RValue RVb(RVa); // expected-error{{call to implicitly-deleted copy constructor}} 130 131 namespace PR13381 { 132 struct S { 133 S(const S&); 134 S(const volatile S&) = delete; // expected-note{{deleted here}} 135 }; 136 struct T { 137 volatile S s; // expected-note{{field 's' has a deleted copy constructor}} 138 }; 139 T &f(); 140 T t = f(); // expected-error{{call to implicitly-deleted copy constructor}} 141 } 142 143 namespace Mutable { 144 struct A { 145 A(const A &); 146 A(A &) = delete; // expected-note {{deleted here}} 147 }; 148 149 struct B { 150 A a; 151 B(const B &); 152 }; 153 B::B(const B &) = default; 154 155 struct C { 156 mutable A a; // expected-note {{deleted because field 'a' has a deleted copy constructor}} 157 C(const C &); 158 }; 159 C::C(const C &) = default; // expected-error{{would delete}} 160 } 161