Clang Project

clang_source_code/test/CXX/special/class.ctor/p5-0x.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -Wno-defaulted-function-deleted
2
3struct DefaultedDefCtor1 {};
4struct DefaultedDefCtor2 { DefaultedDefCtor2() = default; };
5struct DeletedDefCtor { DeletedDefCtor() = delete; DeletedDefCtor(int); }; // expected-note {{explicitly marked deleted here}}
6class PrivateDefCtor { PrivateDefCtor() = default; public: PrivateDefCtor(int); };
7struct DeletedDtor { ~DeletedDtor() = delete; }; // expected-note 4{{explicitly marked deleted here}}
8class PrivateDtor { ~PrivateDtor() = default; };
9class Friend {
10  Friend() = default; ~Friend() = default;
11  friend struct NotDeleted6c;
12  friend struct NotDeleted7i;
13  friend struct NotDeleted7j;
14  friend struct NotDeleted7k;
15};
16struct UserProvidedDefCtor { UserProvidedDefCtor() {} };
17int n;
18
19
20// A defaulted default constructor for a class X is defined as deleted if:
21
22// - X is a union-like class that has a variant member with a non-trivial
23// default constructor,
24union Deleted1a { UserProvidedDefCtor u; }; // expected-note {{default constructor of 'Deleted1a' is implicitly deleted because variant field 'u' has a non-trivial default constructor}}
25Deleted1a d1a; // expected-error {{implicitly-deleted default constructor}}
26union NotDeleted1a { DefaultedDefCtor1 nu; };
27NotDeleted1a nd1a;
28union NotDeleted1b { DefaultedDefCtor2 nu; };
29NotDeleted1b nd1b;
30
31// - any non-static data member with no brace-or-equal-initializer is of
32// reference type,
33class Deleted2a {
34  Deleted2a() = default;  // expected-note 4{{implicitly deleted here}}
35  int &a; // expected-note 4{{because field 'a' of reference type 'int &' would not be initialized}}
36};
37Deleted2a d2a; // expected-error {{implicitly-deleted default constructor}}
38struct Deleted2b {
39  int &&b; // expected-note {{default constructor of 'Deleted2b' is implicitly deleted because field 'b' of reference type 'int &&' would not be initialized}}
40};
41Deleted2b d2b; // expected-error {{deleted default constructor}}
42class NotDeleted2a { int &a = n; };
43NotDeleted2a nd2a;
44class NotDeleted2b { int &a = error; }; // expected-error {{undeclared identifier}}
45NotDeleted2b nd2b;
46class NotDeleted2c { int &&a = static_cast<int&&>(n); };
47NotDeleted2c nd2c;
48// Note: this one does not have a deleted default constructor even though the
49// implicit default constructor is ill-formed!
50class NotDeleted2d { int &&a = 0; }; // expected-error {{reference member 'a' binds to a temporary object}} expected-note {{default member init}}
51NotDeleted2d nd2d; // expected-note {{first required here}}
52
53// - any non-variant non-static data member of const qualified type (or array
54// thereof) with no brace-or-equal-initializer does not have a user-provided
55// default constructor,
56class Deleted3a { const int a; }; // expected-note {{because field 'a' of const-qualified type 'const int' would not be initialized}} \
57                                     expected-warning {{does not declare any constructor}} \
58                                     expected-note {{will never be initialized}}
59Deleted3a d3a; // expected-error {{implicitly-deleted default constructor}}
60class Deleted3b { const DefaultedDefCtor1 a[42]; }; // expected-note {{because field 'a' of const-qualified type 'const DefaultedDefCtor1 [42]' would not be initialized}}
61Deleted3b d3b; // expected-error {{implicitly-deleted default constructor}}
62class Deleted3c { const DefaultedDefCtor2 a; }; // expected-note {{because field 'a' of const-qualified type 'const DefaultedDefCtor2' would not be initialized}}
63Deleted3c d3c; // expected-error {{implicitly-deleted default constructor}}
64class NotDeleted3a { const int a = 0; };
65NotDeleted3a nd3a;
66class NotDeleted3b { const DefaultedDefCtor1 a[42] = {}; };
67NotDeleted3b nd3b;
68class NotDeleted3c { const DefaultedDefCtor2 a = DefaultedDefCtor2(); };
69NotDeleted3c nd3c;
70union NotDeleted3d { const int a; int b; };
71NotDeleted3d nd3d;
72union NotDeleted3e { const DefaultedDefCtor1 a[42]; int b; };
73NotDeleted3e nd3e;
74union NotDeleted3f { const DefaultedDefCtor2 a; int b; };
75NotDeleted3f nd3f;
76struct NotDeleted3g { union { const int a; int b; }; };
77NotDeleted3g nd3g;
78
79// - X is a union and all of its variant members are of const-qualified type (or
80// array thereof),
81union Deleted4a {
82  const int a;
83  const int b;
84  const UserProvidedDefCtor c; // expected-note {{because variant field 'c' has a non-trivial default constructor}}
85};
86Deleted4a d4a; // expected-error {{implicitly-deleted default constructor}}
87union NotDeleted4a { const int a; int b; };
88NotDeleted4a nd4a;
89
90// - X is a non-union class and all members of any anonymous union member are of
91// const-qualified type (or array thereof),
92struct Deleted5a {
93  union { const int a; }; // expected-note {{because all data members of an anonymous union member are const-qualified}}
94  union { int b; };
95};
96Deleted5a d5a; // expected-error {{implicitly-deleted default constructor}}
97struct NotDeleted5a { union { const int a; int b; }; union { const int c; int d; }; };
98NotDeleted5a nd5a;
99
100// - any direct or virtual base class, or non-static data member with no
101// brace-or-equal-initializer, has class type M (or array thereof) and either
102// M has no default constructor or overload resolution as applied to M's default
103// constructor results in an ambiguity or in a function that is deleted or
104// inaccessible from the defaulted default constructor, or
105struct Deleted6a : Deleted2a {}; // expected-note {{because base class 'Deleted2a' has a deleted default constructor}}
106Deleted6a d6a; // expected-error {{implicitly-deleted default constructor}}
107struct Deleted6b : virtual Deleted2a {}; // expected-note {{because base class 'Deleted2a' has a deleted default constructor}}
108Deleted6b d6b; // expected-error {{implicitly-deleted default constructor}}
109struct Deleted6c { Deleted2a a; }; // expected-note {{because field 'a' has a deleted default constructor}}
110Deleted6c d6c; // expected-error {{implicitly-deleted default constructor}}
111struct Deleted6d { DeletedDefCtor a; }; // expected-note {{because field 'a' has a deleted default constructor}}
112Deleted6d d6d; // expected-error {{implicitly-deleted default constructor}}
113struct NotDeleted6a { DeletedDefCtor a = 0; };
114NotDeleted6a nd6a;
115struct Deleted6e { PrivateDefCtor a; }; // expected-note {{because field 'a' has an inaccessible default constructor}}
116Deleted6e d6e; // expected-error {{implicitly-deleted default constructor}}
117struct NotDeleted6b { PrivateDefCtor a = 0; };
118NotDeleted6b nd6b;
119struct NotDeleted6c { Friend a; };
120NotDeleted6c nd6c;
121
122// - any direct or virtual base class or non-static data member has a type with
123// a destructor that is deleted or inaccessible from the defaulted default
124// constructor.
125struct Deleted7a : DeletedDtor {}; // expected-note {{because base class 'DeletedDtor' has a deleted destructor}}
126Deleted7a d7a; // expected-error {{implicitly-deleted default constructor}}
127struct Deleted7b : virtual DeletedDtor {}; // expected-note {{because base class 'DeletedDtor' has a deleted destructor}}
128Deleted7b d7b; // expected-error {{implicitly-deleted default constructor}}
129struct Deleted7c { DeletedDtor a; }; // expected-note {{because field 'a' has a deleted destructor}}
130Deleted7c d7c; // expected-error {{implicitly-deleted default constructor}}
131struct Deleted7d { DeletedDtor a = {}; }; // expected-note {{because field 'a' has a deleted destructor}}
132Deleted7d d7d; // expected-error {{implicitly-deleted default constructor}}
133struct Deleted7e : PrivateDtor {}; // expected-note {{base class 'PrivateDtor' has an inaccessible destructor}}
134Deleted7e d7e; // expected-error {{implicitly-deleted default constructor}}
135struct Deleted7f : virtual PrivateDtor {}; // expected-note {{base class 'PrivateDtor' has an inaccessible destructor}}
136Deleted7f d7f; // expected-error {{implicitly-deleted default constructor}}
137struct Deleted7g { PrivateDtor a; }; // expected-note {{field 'a' has an inaccessible destructor}}
138Deleted7g d7g; // expected-error {{implicitly-deleted default constructor}}
139struct Deleted7h { PrivateDtor a = {}; }; // expected-note {{field 'a' has an inaccessible destructor}}
140Deleted7h d7h; // expected-error {{implicitly-deleted default constructor}}
141struct NotDeleted7i : Friend {};
142NotDeleted7i d7i;
143struct NotDeleted7j : virtual Friend {};
144NotDeleted7j d7j;
145struct NotDeleted7k { Friend a; };
146NotDeleted7k d7k;
147
148
149class Trivial { static const int n = 42; };
150static_assert(__has_trivial_constructor(Trivial), "Trivial is nontrivial");
151
152// A default constructor is trivial if it is not user-provided and if:
153class NonTrivialDefCtor1 { NonTrivialDefCtor1(); };
154static_assert(!__has_trivial_constructor(NonTrivialDefCtor1), "NonTrivialDefCtor1 is trivial");
155
156#define ASSERT_NONTRIVIAL_IMPL(Class, Bases, Body) \
157  class Class Bases { Body }; \
158  static_assert(!__has_trivial_constructor(Class), "");
159#define ASSERT_NONTRIVIAL(Class, Bases, Body) \
160  ASSERT_NONTRIVIAL_IMPL(Class, Bases, Body) \
161  ASSERT_NONTRIVIAL_IMPL(Def ## Class, Bases, Def ## Class() = default; Body) \
162  ASSERT_NONTRIVIAL_IMPL(Del ## Class, Bases, Del ## Class() = delete; Body)
163
164// - its class has no virtual functions (10.3) and no virtual base classes (10.1), and
165ASSERT_NONTRIVIAL(NonTrivialDefCtor2, , virtual void f();)
166ASSERT_NONTRIVIAL(NonTrivialDefCtor3, : virtual Trivial, )
167
168// - no non-static data member of its class has a brace-or-equal-initializer, and
169ASSERT_NONTRIVIAL(NonTrivialDefCtor4, , int m = 52;)
170
171// - all the direct base classes of its class have trivial default constructors, and
172ASSERT_NONTRIVIAL(NonTrivialDefCtor5, : NonTrivialDefCtor1, )
173
174// - for all the non-static data members of its class that are of class type (or array thereof), each such class
175// has a trivial default constructor.
176ASSERT_NONTRIVIAL(NonTrivialDefCtor6, , NonTrivialDefCtor1 t;)
177
178// FIXME: No core issue number yet.
179// - its parameter-declaration-clause is equivalent to that of an implicit declaration.
180struct NonTrivialDefCtor7 {
181  NonTrivialDefCtor7(...) = delete;
182};
183static_assert(!__has_trivial_constructor(NonTrivialDefCtor7), "");
184struct NonTrivialDefCtor8 {
185  NonTrivialDefCtor8(int = 0) = delete;
186};
187static_assert(!__has_trivial_constructor(NonTrivialDefCtor8), "");
188
189// Otherwise, the default constructor is non-trivial.
190
191class Trivial2 { Trivial2() = delete; };
192static_assert(__has_trivial_constructor(Trivial2), "Trivial2 is trivial");
193
194class Trivial3 { Trivial3() = default; };
195static_assert(__has_trivial_constructor(Trivial3), "Trivial3 is trivial");
196
197template<typename T> class Trivial4 { Trivial4() = default; };
198static_assert(__has_trivial_constructor(Trivial4<int>), "Trivial4 is trivial");
199
200template<typename T> class Trivial5 { Trivial5() = delete; };
201static_assert(__has_trivial_constructor(Trivial5<int>), "Trivial5 is trivial");
202
203namespace PR14558 {
204  // Ensure we determine whether an explicitly-defaulted or deleted special
205  // member is trivial before we return to parsing the containing class.
206  struct A {
207    struct B { B() = default; } b;
208    struct C { C() = delete; } c;
209  };
210
211  static_assert(__has_trivial_constructor(A), "");
212  static_assert(__has_trivial_constructor(A::B), "");
213}
214
CodeThinker, Enjoy your reading code