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 int some_int;
125 struct RValue {
126   int && ri = static_cast<int&&>(some_int); // expected-note{{copy constructor of 'RValue' is implicitly deleted because field 'ri' is of rvalue reference type 'int &&'}}
127 };
128 RValue RVa;
129 RValue RVb(RVa); // expected-error{{call to implicitly-deleted copy constructor}}
130 
131 // FIXME: The error on the class-name is attached to the location of the
132 // constructor. This is not especially clear.
133 struct RValueTmp { // expected-error {{reference member 'ri' binds to a temporary}}
134   int && ri = 1; // expected-note{{copy constructor of 'RValueTmp' is implicitly deleted because field 'ri' is of rvalue reference type 'int &&'}} // expected-note {{default member init}}
135 };
136 RValueTmp RVTa; // expected-note {{implicit default constructor for 'RValueTmp' first required here}}
137 RValueTmp RVTb(RVTa); // expected-error{{call to implicitly-deleted copy constructor}}
138 
139 namespace PR13381 {
140   struct S {
141     S(const S&);
142     S(const volatile S&) = delete; // expected-note{{deleted here}}
143   };
144   struct T {
145     volatile S s; // expected-note{{field 's' has a deleted copy constructor}}
146   };
147   T &f();
148   T t = f(); // expected-error{{call to implicitly-deleted copy constructor}}
149 }
150 
151 namespace Mutable {
152   struct A {
153     A(const A &);
154     A(A &) = delete; // expected-note {{deleted here}}
155   };
156 
157   struct B {
158     A a;
159     B(const B &);
160   };
161   B::B(const B &) = default;
162 
163   struct C {
164     mutable A a; // expected-note {{deleted because field 'a' has a deleted copy constructor}}
165     C(const C &);
166   };
167   C::C(const C &) = default; // expected-error{{would delete}}
168 }
169