1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef DEFINE_BASE
10#define DEFINE_BASE(Name) ::ArchetypeBases::NullBase
11#endif
12#ifndef DEFINE_EXPLICIT
13#define DEFINE_EXPLICIT
14#endif
15#ifndef DEFINE_NOEXCEPT
16#define DEFINE_NOEXCEPT
17#endif
18#ifndef DEFINE_CONSTEXPR
19#ifdef TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
20#define DEFINE_CONSTEXPR
21#else // TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
22#define DEFINE_CONSTEXPR constexpr
23#endif // TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
24#endif
25#ifndef DEFINE_ASSIGN_CONSTEXPR
26#if TEST_STD_VER >= 14
27#define DEFINE_ASSIGN_CONSTEXPR DEFINE_CONSTEXPR
28#else
29#define DEFINE_ASSIGN_CONSTEXPR
30#endif
31#endif
32#ifndef DEFINE_CTOR
33#define DEFINE_CTOR = default
34#endif
35#ifndef DEFINE_DEFAULT_CTOR
36#define DEFINE_DEFAULT_CTOR DEFINE_CTOR
37#endif
38#ifndef DEFINE_ASSIGN
39#define DEFINE_ASSIGN = default
40#endif
41#ifndef DEFINE_DTOR
42#define DEFINE_DTOR(Name)
43#endif
44
45struct AllCtors : DEFINE_BASE(AllCtors) {
46  using Base = DEFINE_BASE(AllCtors);
47  using Base::Base;
48  using Base::operator=;
49  DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
50  DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors(AllCtors const&) DEFINE_NOEXCEPT DEFINE_CTOR;
51  DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors(AllCtors &&) DEFINE_NOEXCEPT DEFINE_CTOR;
52  DEFINE_ASSIGN_CONSTEXPR AllCtors& operator=(AllCtors const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
53  DEFINE_ASSIGN_CONSTEXPR AllCtors& operator=(AllCtors &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
54  DEFINE_DTOR(AllCtors)
55};
56
57struct NoCtors : DEFINE_BASE(NoCtors) {
58  using Base = DEFINE_BASE(NoCtors);
59  DEFINE_EXPLICIT NoCtors() DEFINE_NOEXCEPT = delete;
60  DEFINE_EXPLICIT NoCtors(NoCtors const&) DEFINE_NOEXCEPT = delete;
61  NoCtors& operator=(NoCtors const&) DEFINE_NOEXCEPT = delete;
62  DEFINE_DTOR(NoCtors)
63};
64
65struct NoDefault : DEFINE_BASE(NoDefault) {
66  using Base = DEFINE_BASE(NoDefault);
67  using Base::Base;
68  DEFINE_EXPLICIT DEFINE_CONSTEXPR NoDefault() DEFINE_NOEXCEPT = delete;
69  DEFINE_DTOR(NoDefault)
70};
71
72struct DefaultOnly : DEFINE_BASE(DefaultOnly) {
73  using Base = DEFINE_BASE(DefaultOnly);
74  using Base::Base;
75  DEFINE_EXPLICIT DEFINE_CONSTEXPR DefaultOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
76  DefaultOnly(DefaultOnly const&) DEFINE_NOEXCEPT = delete;
77  DefaultOnly& operator=(DefaultOnly const&) DEFINE_NOEXCEPT = delete;
78  DEFINE_DTOR(DefaultOnly)
79};
80
81struct Copyable : DEFINE_BASE(Copyable) {
82  using Base = DEFINE_BASE(Copyable);
83  using Base::Base;
84  DEFINE_EXPLICIT DEFINE_CONSTEXPR Copyable() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
85  DEFINE_EXPLICIT DEFINE_CONSTEXPR Copyable(Copyable const &) DEFINE_NOEXCEPT DEFINE_CTOR;
86  Copyable &operator=(Copyable const &) DEFINE_NOEXCEPT DEFINE_ASSIGN;
87  DEFINE_DTOR(Copyable)
88};
89
90struct CopyOnly : DEFINE_BASE(CopyOnly) {
91  using Base = DEFINE_BASE(CopyOnly);
92  using Base::Base;
93  DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
94  DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly(CopyOnly const &) DEFINE_NOEXCEPT DEFINE_CTOR;
95  DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly(CopyOnly &&) DEFINE_NOEXCEPT = delete;
96  CopyOnly &operator=(CopyOnly const &) DEFINE_NOEXCEPT DEFINE_ASSIGN;
97  CopyOnly &operator=(CopyOnly &&) DEFINE_NOEXCEPT = delete;
98  DEFINE_DTOR(CopyOnly)
99};
100
101struct NonCopyable : DEFINE_BASE(NonCopyable) {
102  using Base = DEFINE_BASE(NonCopyable);
103  using Base::Base;
104  DEFINE_EXPLICIT DEFINE_CONSTEXPR NonCopyable() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
105  DEFINE_EXPLICIT DEFINE_CONSTEXPR NonCopyable(NonCopyable const &) DEFINE_NOEXCEPT = delete;
106  NonCopyable &operator=(NonCopyable const &) DEFINE_NOEXCEPT = delete;
107  DEFINE_DTOR(NonCopyable)
108};
109
110struct MoveOnly : DEFINE_BASE(MoveOnly) {
111  using Base = DEFINE_BASE(MoveOnly);
112  using Base::Base;
113  DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
114  DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveOnly(MoveOnly &&) DEFINE_NOEXCEPT DEFINE_CTOR;
115  MoveOnly &operator=(MoveOnly &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
116  DEFINE_DTOR(MoveOnly)
117};
118
119struct CopyAssignable : DEFINE_BASE(CopyAssignable) {
120  using Base = DEFINE_BASE(CopyAssignable);
121  using Base::Base;
122  DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyAssignable() DEFINE_NOEXCEPT = delete;
123  CopyAssignable& operator=(CopyAssignable const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
124  DEFINE_DTOR(CopyAssignable)
125};
126
127struct CopyAssignOnly : DEFINE_BASE(CopyAssignOnly) {
128  using Base = DEFINE_BASE(CopyAssignOnly);
129  using Base::Base;
130  DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyAssignOnly() DEFINE_NOEXCEPT = delete;
131  CopyAssignOnly& operator=(CopyAssignOnly const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
132  CopyAssignOnly& operator=(CopyAssignOnly &&) DEFINE_NOEXCEPT = delete;
133  DEFINE_DTOR(CopyAssignOnly)
134};
135
136struct MoveAssignOnly : DEFINE_BASE(MoveAssignOnly) {
137  using Base = DEFINE_BASE(MoveAssignOnly);
138  using Base::Base;
139  DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveAssignOnly() DEFINE_NOEXCEPT = delete;
140  MoveAssignOnly& operator=(MoveAssignOnly const&) DEFINE_NOEXCEPT = delete;
141  MoveAssignOnly& operator=(MoveAssignOnly &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
142  DEFINE_DTOR(MoveAssignOnly)
143};
144
145struct ConvertingType : DEFINE_BASE(ConvertingType) {
146  using Base = DEFINE_BASE(ConvertingType);
147  using Base::Base;
148  DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
149  DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(ConvertingType const&) DEFINE_NOEXCEPT DEFINE_CTOR;
150  DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(ConvertingType &&) DEFINE_NOEXCEPT DEFINE_CTOR;
151  ConvertingType& operator=(ConvertingType const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
152  ConvertingType& operator=(ConvertingType &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
153  template <class ...Args>
154  DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(Args&&...) DEFINE_NOEXCEPT {}
155  template <class Arg>
156  ConvertingType& operator=(Arg&&) DEFINE_NOEXCEPT { return *this; }
157  DEFINE_DTOR(ConvertingType)
158};
159
160template <template <class...> class List>
161using ApplyTypes = List<
162    AllCtors,
163    NoCtors,
164    NoDefault,
165    DefaultOnly,
166    Copyable,
167    CopyOnly,
168    NonCopyable,
169    MoveOnly,
170    CopyAssignable,
171    CopyAssignOnly,
172    MoveAssignOnly,
173    ConvertingType
174  >;
175
176#undef DEFINE_BASE
177#undef DEFINE_EXPLICIT
178#undef DEFINE_NOEXCEPT
179#undef DEFINE_CONSTEXPR
180#undef DEFINE_ASSIGN_CONSTEXPR
181#undef DEFINE_CTOR
182#undef DEFINE_DEFAULT_CTOR
183#undef DEFINE_ASSIGN
184#undef DEFINE_DTOR
185