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 // UNSUPPORTED: c++03, c++11, c++14, c++17
10 // UNSUPPORTED: libcpp-no-concepts
11 
12 // template<class From, class To>
13 // concept assignable_from;
14 
15 #include <concepts>
16 
17 #include <deque>
18 #include <forward_list>
19 #include <list>
20 #include <map>
21 #include <memory>
22 #include <mutex>
23 #include <optional>
24 #include <string>
25 #include <string_view>
26 #include <unordered_map>
27 #include <vector>
28 
29 #include "../support/allocators.h"
30 
31 // Note: is_lvalue_reference is checked in all ModelsAssignableFrom calls.
32 template <typename T1, typename T2>
33 constexpr void NeverAssignableFrom() {
34   static_assert(!std::assignable_from<T1, T2>);
35   static_assert(!std::assignable_from<T1, const T2>);
36   static_assert(!std::assignable_from<T1, T2&>);
37   static_assert(!std::assignable_from<T1, const T2&>);
38   static_assert(!std::assignable_from<T1, volatile T2&>);
39   static_assert(!std::assignable_from<T1, const volatile T2&>);
40   static_assert(!std::assignable_from<T1, T2&&>);
41   static_assert(!std::assignable_from<T1, const T2&&>);
42   static_assert(!std::assignable_from<T1, volatile T2&&>);
43   static_assert(!std::assignable_from<T1, const volatile T2&&>);
44 
45   static_assert(!std::assignable_from<const volatile T1&, T2>);
46   static_assert(!std::assignable_from<const volatile T1&, const T2>);
47   static_assert(!std::assignable_from<const volatile T1&, T2&>);
48   static_assert(!std::assignable_from<const volatile T1&, const T2&>);
49   static_assert(!std::assignable_from<const volatile T1&, volatile T2&>);
50   static_assert(!std::assignable_from<const volatile T1&, const volatile T2&>);
51   static_assert(!std::assignable_from<const volatile T1&, T2&&>);
52   static_assert(!std::assignable_from<const volatile T1&, const T2&&>);
53   static_assert(!std::assignable_from<const volatile T1&, volatile T2&&>);
54   static_assert(!std::assignable_from<const volatile T1&, const volatile T2&&>);
55 
56   static_assert(!std::assignable_from<T1&&, T2>);
57   static_assert(!std::assignable_from<T1&&, const T2>);
58   static_assert(!std::assignable_from<T1&&, T2&>);
59   static_assert(!std::assignable_from<T1&&, const T2&>);
60   static_assert(!std::assignable_from<T1&&, volatile T2&>);
61   static_assert(!std::assignable_from<T1&&, const volatile T2&>);
62   static_assert(!std::assignable_from<T1&&, T2&&>);
63   static_assert(!std::assignable_from<T1&&, const T2&&>);
64   static_assert(!std::assignable_from<T1&&, volatile T2&&>);
65   static_assert(!std::assignable_from<T1&&, const volatile T2&&>);
66 
67   static_assert(!std::assignable_from<const T1&&, T2>);
68   static_assert(!std::assignable_from<const T1&&, const T2>);
69   static_assert(!std::assignable_from<const T1&&, T2&>);
70   static_assert(!std::assignable_from<const T1&&, const T2&>);
71   static_assert(!std::assignable_from<const T1&&, volatile T2&>);
72   static_assert(!std::assignable_from<const T1&&, const volatile T2&>);
73   static_assert(!std::assignable_from<const T1&&, T2&&>);
74   static_assert(!std::assignable_from<const T1&&, const T2&&>);
75   static_assert(!std::assignable_from<const T1&&, volatile T2&&>);
76   static_assert(!std::assignable_from<const T1&&, const volatile T2&&>);
77 
78   static_assert(!std::assignable_from<volatile T1&&, T2>);
79   static_assert(!std::assignable_from<volatile T1&&, const T2>);
80   static_assert(!std::assignable_from<volatile T1&&, T2&>);
81   static_assert(!std::assignable_from<volatile T1&&, const T2&>);
82   static_assert(!std::assignable_from<volatile T1&&, volatile T2&>);
83   static_assert(!std::assignable_from<volatile T1&&, const volatile T2&>);
84   static_assert(!std::assignable_from<volatile T1&&, T2&&>);
85   static_assert(!std::assignable_from<volatile T1&&, const T2&&>);
86   static_assert(!std::assignable_from<volatile T1&&, volatile T2&&>);
87   static_assert(!std::assignable_from<volatile T1&&, const volatile T2&&>);
88 
89   static_assert(!std::assignable_from<const volatile T1&&, T2>);
90   static_assert(!std::assignable_from<const volatile T1&&, const T2>);
91   static_assert(!std::assignable_from<const volatile T1&&, T2&>);
92   static_assert(!std::assignable_from<const volatile T1&&, const T2&>);
93   static_assert(!std::assignable_from<const volatile T1&&, volatile T2&>);
94   static_assert(!std::assignable_from<const volatile T1&&, const volatile T2&>);
95   static_assert(!std::assignable_from<const volatile T1&&, T2&&>);
96   static_assert(!std::assignable_from<const volatile T1&&, const T2&&>);
97   static_assert(!std::assignable_from<const volatile T1&&, volatile T2&&>);
98   static_assert(
99       !std::assignable_from<const volatile T1&&, const volatile T2&&>);
100 
101   static_assert(!std::assignable_from<const T1&, T2>);
102   static_assert(!std::assignable_from<const T1&, const T2>);
103   static_assert(!std::assignable_from<const T1&, T2&>);
104   static_assert(!std::assignable_from<const T1&, const T2&>);
105   static_assert(!std::assignable_from<const T1&, volatile T2&>);
106   static_assert(!std::assignable_from<const T1&, const volatile T2&>);
107   static_assert(!std::assignable_from<const T1&, T2&&>);
108   static_assert(!std::assignable_from<const T1&, const T2&&>);
109   static_assert(!std::assignable_from<const T1&, volatile T2&&>);
110   static_assert(!std::assignable_from<const T1&, const volatile T2&&>);
111 
112   static_assert(!std::assignable_from<const volatile T1&, T2>);
113   static_assert(!std::assignable_from<const volatile T1&, const T2>);
114   static_assert(!std::assignable_from<const volatile T1&, T2&>);
115   static_assert(!std::assignable_from<const volatile T1&, const T2&>);
116   static_assert(!std::assignable_from<const volatile T1&, volatile T2&>);
117   static_assert(!std::assignable_from<const volatile T1&, const volatile T2&>);
118   static_assert(!std::assignable_from<const volatile T1&, T2&&>);
119   static_assert(!std::assignable_from<const volatile T1&, const T2&&>);
120   static_assert(!std::assignable_from<const volatile T1&, volatile T2&&>);
121   static_assert(!std::assignable_from<const volatile T1&, const volatile T2&&>);
122 }
123 
124 template <typename T1, typename T2>
125 constexpr bool CheckAssignableFromRvalues() {
126   NeverAssignableFrom<T1, T2>();
127 
128   constexpr bool Result = std::assignable_from<T1&, T2>;
129   static_assert(std::assignable_from<T1&, T2&&> == Result);
130 
131   return Result;
132 }
133 
134 template <typename T1, typename T2>
135 constexpr bool CheckAssignableFromLvalues() {
136   NeverAssignableFrom<T1, T2>();
137 
138   constexpr bool Result = std::assignable_from<T1&, const T2&>;
139   static_assert(std::assignable_from<T1&, T2&> == Result);
140   static_assert(std::assignable_from<T1&, const T2&> == Result);
141 
142   return Result;
143 }
144 
145 template <typename T1, typename T2>
146 constexpr bool CheckAssignableFromLvaluesAndRvalues() {
147   return CheckAssignableFromLvalues<T1, T2>() &&
148          CheckAssignableFromRvalues<T1, T2>();
149 }
150 
151 namespace BuiltinTypes {
152 static_assert(CheckAssignableFromLvaluesAndRvalues<int, int>());
153 static_assert(CheckAssignableFromLvaluesAndRvalues<int, double>());
154 static_assert(CheckAssignableFromLvaluesAndRvalues<double, int>());
155 static_assert(CheckAssignableFromLvaluesAndRvalues<int*, int*>());
156 static_assert(!CheckAssignableFromLvaluesAndRvalues<int*, const int*>());
157 static_assert(!CheckAssignableFromLvaluesAndRvalues<int*, volatile int*>());
158 static_assert(
159     !CheckAssignableFromLvaluesAndRvalues<int*, const volatile int*>());
160 static_assert(CheckAssignableFromLvaluesAndRvalues<const int*, int*>());
161 static_assert(CheckAssignableFromLvaluesAndRvalues<const int*, const int*>());
162 static_assert(
163     !CheckAssignableFromLvaluesAndRvalues<const int*, volatile int*>());
164 static_assert(
165     !CheckAssignableFromLvaluesAndRvalues<const int*, const volatile int*>());
166 static_assert(CheckAssignableFromLvaluesAndRvalues<volatile int*, int*>());
167 static_assert(
168     !CheckAssignableFromLvaluesAndRvalues<volatile int*, const int*>());
169 static_assert(
170     CheckAssignableFromLvaluesAndRvalues<volatile int*, volatile int*>());
171 static_assert(!CheckAssignableFromLvaluesAndRvalues<volatile int*,
172                                                     const volatile int*>());
173 static_assert(
174     CheckAssignableFromLvaluesAndRvalues<const volatile int*, int*>());
175 static_assert(
176     CheckAssignableFromLvaluesAndRvalues<const volatile int*, const int*>());
177 static_assert(
178     CheckAssignableFromLvaluesAndRvalues<const volatile int*, volatile int*>());
179 static_assert(CheckAssignableFromLvaluesAndRvalues<const volatile int*,
180                                                    const volatile int*>());
181 
182 static_assert(CheckAssignableFromLvaluesAndRvalues<int (*)(), int (*)()>());
183 static_assert(
184     CheckAssignableFromLvaluesAndRvalues<int (*)(), int (*)() noexcept>());
185 static_assert(
186     !CheckAssignableFromLvaluesAndRvalues<int (*)() noexcept, int (*)()>());
187 
188 struct S {};
189 static_assert(CheckAssignableFromLvaluesAndRvalues<int S::*, int S::*>());
190 static_assert(CheckAssignableFromLvaluesAndRvalues<const int S::*, int S::*>());
191 static_assert(
192     CheckAssignableFromLvaluesAndRvalues<int (S::*)(), int (S::*)()>());
193 static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)(),
194                                                    int (S::*)() noexcept>());
195 static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)() const,
196                                                    int (S::*)() const>());
197 static_assert(CheckAssignableFromLvaluesAndRvalues<
198               int (S::*)() const, int (S::*)() const noexcept>());
199 static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)() volatile,
200                                                    int (S::*)() volatile>());
201 static_assert(CheckAssignableFromLvaluesAndRvalues<
202               int (S::*)() volatile, int (S::*)() volatile noexcept>());
203 static_assert(CheckAssignableFromLvaluesAndRvalues<
204               int (S::*)() const volatile, int (S::*)() const volatile>());
205 static_assert(
206     CheckAssignableFromLvaluesAndRvalues<
207         int (S::*)() const volatile, int (S::*)() const volatile noexcept>());
208 
209 static_assert(!std::assignable_from<void, int>);
210 static_assert(!std::assignable_from<void, void>);
211 static_assert(!std::assignable_from<int*&, long*>);
212 static_assert(!std::assignable_from<int (&)[5], int[5]>);
213 static_assert(!std::assignable_from<int (S::*&)(), int (S::*)() const>);
214 static_assert(!std::assignable_from<int (S::*&)() const, int (S::*)()>);
215 static_assert(!std::assignable_from<int (S::*&)(), int (S::*)() volatile>);
216 static_assert(!std::assignable_from<int (S::*&)() volatile, int (S::*)()>);
217 static_assert(
218     !std::assignable_from<int (S::*&)(), int (S::*)() const volatile>);
219 static_assert(
220     !std::assignable_from<int (S::*&)() const volatile, int (S::*)()>);
221 static_assert(!std::assignable_from<int (S::*&)() noexcept, int (S::*)()>);
222 static_assert(
223     !std::assignable_from<int (S::*&)() const noexcept, int (S::*)() const>);
224 static_assert(!std::assignable_from<int (S::*&)() volatile noexcept,
225                                     int (S::*)() volatile>);
226 static_assert(!std::assignable_from<int (S::*&)() const volatile noexcept,
227                                     int (S::*)() const volatile>);
228 } // namespace BuiltinTypes
229 
230 namespace TypesFitForPurpose {
231 struct T1 {};
232 
233 struct NoCommonReference {};
234 static_assert(!std::common_reference_with<const T1&, const NoCommonReference&>);
235 static_assert(!std::assignable_from<NoCommonReference&, T1>);
236 
237 struct AssignmentReturnsNonReference {
238   AssignmentReturnsNonReference operator=(T1);
239   operator T1() const;
240 };
241 static_assert(std::common_reference_with<const T1&,
242                                          const AssignmentReturnsNonReference&>);
243 static_assert(!std::assignable_from<AssignmentReturnsNonReference&, T1>);
244 
245 struct NonCVAssignmentOnly {
246   NonCVAssignmentOnly& operator=(T1);
247   operator T1() const;
248 };
249 static_assert(
250     std::common_reference_with<const T1&, const NonCVAssignmentOnly&>);
251 static_assert(std::assignable_from<NonCVAssignmentOnly&, T1>);
252 static_assert(!std::assignable_from<const NonCVAssignmentOnly&, T1>);
253 static_assert(!std::assignable_from<volatile NonCVAssignmentOnly&, T1>);
254 static_assert(!std::assignable_from<const volatile NonCVAssignmentOnly&, T1>);
255 
256 struct NonCVAssignmentOnlyConstQualified {
257   NonCVAssignmentOnlyConstQualified& operator=(T1) const;
258   operator T1() const;
259 };
260 static_assert(std::common_reference_with<
261               const T1&, const NonCVAssignmentOnlyConstQualified&>);
262 static_assert(std::assignable_from<NonCVAssignmentOnlyConstQualified&, T1>);
263 static_assert(
264     !std::assignable_from<const NonCVAssignmentOnlyConstQualified&, T1>);
265 static_assert(
266     !std::assignable_from<volatile NonCVAssignmentOnlyConstQualified&, T1>);
267 static_assert(!std::assignable_from<
268               const volatile NonCVAssignmentOnlyConstQualified&, T1>);
269 
270 struct NonCVAssignmentVolatileQualified {
271   NonCVAssignmentVolatileQualified& operator=(T1) volatile;
272   operator T1() const volatile;
273 };
274 static_assert(std::common_reference_with<
275               const T1&, const NonCVAssignmentVolatileQualified&>);
276 static_assert(std::assignable_from<NonCVAssignmentVolatileQualified&, T1>);
277 static_assert(
278     !std::assignable_from<const NonCVAssignmentVolatileQualified&, T1>);
279 static_assert(
280     !std::assignable_from<volatile NonCVAssignmentVolatileQualified&, T1>);
281 static_assert(!std::assignable_from<
282               const volatile NonCVAssignmentVolatileQualified&, T1>);
283 
284 struct NonCVAssignmentOnlyCVQualified {
285   NonCVAssignmentOnlyCVQualified& operator=(T1) const volatile;
286   operator T1() const volatile;
287 };
288 static_assert(std::common_reference_with<
289               const T1&, const NonCVAssignmentOnlyCVQualified&>);
290 static_assert(std::assignable_from<NonCVAssignmentOnlyCVQualified&, T1>);
291 static_assert(!std::assignable_from<const NonCVAssignmentOnlyCVQualified&, T1>);
292 static_assert(
293     !std::assignable_from<volatile NonCVAssignmentOnlyCVQualified&, T1>);
294 static_assert(
295     !std::assignable_from<const volatile NonCVAssignmentOnlyCVQualified&, T1>);
296 
297 struct ConstAssignmentOnly {
298   const ConstAssignmentOnly& operator=(T1) const;
299   operator T1() const;
300 };
301 static_assert(
302     std::common_reference_with<const T1&, const ConstAssignmentOnly&>);
303 static_assert(std::assignable_from<const ConstAssignmentOnly&, T1>);
304 static_assert(!std::assignable_from<ConstAssignmentOnly&, T1>);
305 static_assert(!std::assignable_from<volatile ConstAssignmentOnly&, T1>);
306 static_assert(!std::assignable_from<const volatile ConstAssignmentOnly&, T1>);
307 
308 struct VolatileAssignmentOnly {
309   volatile VolatileAssignmentOnly& operator=(T1) volatile;
310   operator T1() const volatile;
311 };
312 static_assert(
313     std::common_reference_with<const T1&, const VolatileAssignmentOnly&>);
314 static_assert(!std::assignable_from<VolatileAssignmentOnly&, T1>);
315 static_assert(std::assignable_from<volatile VolatileAssignmentOnly&, T1>);
316 
317 struct CVAssignmentOnly {
318   const volatile CVAssignmentOnly& operator=(T1) const volatile;
319   operator T1() const volatile;
320 };
321 static_assert(std::common_reference_with<const T1&, const CVAssignmentOnly&>);
322 static_assert(std::assignable_from<const volatile CVAssignmentOnly&, T1>);
323 static_assert(!std::assignable_from<CVAssignmentOnly&, T1>);
324 static_assert(!std::assignable_from<const CVAssignmentOnly&, T1>);
325 static_assert(!std::assignable_from<volatile CVAssignmentOnly&, T1>);
326 
327 struct LvalueRefQualifiedWithRvalueT1Only {
328   LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) &;
329   const LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) const&;
330   volatile LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) volatile&;
331   const volatile LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) const
332       volatile&;
333   operator T1() const volatile;
334 };
335 static_assert(std::common_reference_with<
336               const T1&, const LvalueRefQualifiedWithRvalueT1Only&>);
337 static_assert(std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
338 static_assert(
339     std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
340 static_assert(
341     std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
342 static_assert(std::assignable_from<
343               const volatile LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
344 static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, T1&>);
345 static_assert(
346     !std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&, T1&>);
347 static_assert(
348     !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&, T1&>);
349 static_assert(!std::assignable_from<
350               const volatile LvalueRefQualifiedWithRvalueT1Only&, T1&>);
351 static_assert(
352     !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
353 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
354                                     const T1&>);
355 static_assert(!std::assignable_from<
356               volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
357 static_assert(!std::assignable_from<
358               const volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
359 static_assert(
360     !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, volatile T1&>);
361 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
362                                     volatile T1&>);
363 static_assert(!std::assignable_from<
364               volatile LvalueRefQualifiedWithRvalueT1Only&, volatile T1&>);
365 static_assert(
366     !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
367                           volatile T1&>);
368 static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&,
369                                     const volatile T1&>);
370 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
371                                     const volatile T1&>);
372 static_assert(
373     !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&,
374                           const volatile T1&>);
375 static_assert(
376     !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
377                           const volatile T1&>);
378 static_assert(
379     !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
380 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
381                                     const T1&&>);
382 static_assert(!std::assignable_from<
383               volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
384 static_assert(!std::assignable_from<
385               const volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
386 static_assert(
387     !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, volatile T1&&>);
388 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
389                                     volatile T1&&>);
390 static_assert(!std::assignable_from<
391               volatile LvalueRefQualifiedWithRvalueT1Only&, volatile T1&&>);
392 static_assert(
393     !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
394                           volatile T1&&>);
395 static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&,
396                                     const volatile T1&&>);
397 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
398                                     const volatile T1&&>);
399 static_assert(
400     !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&,
401                           const volatile T1&&>);
402 static_assert(
403     !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
404                           const volatile T1&&>);
405 
406 struct NoLvalueRefAssignment {
407   NoLvalueRefAssignment& operator=(T1) &&;
408   const NoLvalueRefAssignment& operator=(T1) const&&;
409   volatile NoLvalueRefAssignment& operator=(T1) volatile&&;
410   const volatile NoLvalueRefAssignment& operator=(T1) const volatile&&;
411   operator T1() const volatile;
412 };
413 static_assert(
414     std::common_reference_with<const T1&, const NoLvalueRefAssignment&>);
415 static_assert(!std::assignable_from<NoLvalueRefAssignment&, T1>);
416 static_assert(!std::assignable_from<NoLvalueRefAssignment&, const T1>);
417 static_assert(!std::assignable_from<NoLvalueRefAssignment&, volatile T1>);
418 static_assert(!std::assignable_from<NoLvalueRefAssignment&, const volatile T1>);
419 static_assert(!std::assignable_from<const NoLvalueRefAssignment&, T1>);
420 static_assert(!std::assignable_from<const NoLvalueRefAssignment&, const T1>);
421 static_assert(!std::assignable_from<const NoLvalueRefAssignment&, volatile T1>);
422 static_assert(
423     !std::assignable_from<const NoLvalueRefAssignment&, const volatile T1>);
424 static_assert(!std::assignable_from<volatile NoLvalueRefAssignment&, T1>);
425 static_assert(!std::assignable_from<volatile NoLvalueRefAssignment&, const T1>);
426 static_assert(
427     !std::assignable_from<volatile NoLvalueRefAssignment&, volatile T1>);
428 static_assert(
429     !std::assignable_from<volatile NoLvalueRefAssignment&, const volatile T1>);
430 static_assert(!std::assignable_from<const volatile NoLvalueRefAssignment&, T1>);
431 static_assert(
432     !std::assignable_from<const volatile NoLvalueRefAssignment&, const T1>);
433 static_assert(
434     !std::assignable_from<const volatile NoLvalueRefAssignment&, volatile T1>);
435 static_assert(!std::assignable_from<const volatile NoLvalueRefAssignment&,
436                                     const volatile T1>);
437 } // namespace TypesFitForPurpose
438 
439 namespace StandardTypes {
440 static_assert(
441     CheckAssignableFromLvaluesAndRvalues<std::deque<int>, std::deque<int> >());
442 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>,
443                                                     std::deque<const int> >());
444 static_assert(!CheckAssignableFromLvaluesAndRvalues<
445               std::deque<int>, std::deque<int, A1<int> > >());
446 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>,
447                                                     std::vector<int> >());
448 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>, int>());
449 
450 static_assert(CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>,
451                                                    std::forward_list<int> >());
452 static_assert(!CheckAssignableFromLvaluesAndRvalues<
453               std::forward_list<int>, std::forward_list<const int> >());
454 static_assert(!CheckAssignableFromLvaluesAndRvalues<
455               std::forward_list<int>, std::forward_list<int, A1<int> > >());
456 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>,
457                                                     std::vector<int> >());
458 static_assert(
459     !CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>, int>());
460 
461 static_assert(
462     CheckAssignableFromLvaluesAndRvalues<std::list<int>, std::list<int> >());
463 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::list<int>,
464                                                     std::list<const int> >());
465 static_assert(!CheckAssignableFromLvaluesAndRvalues<
466               std::list<int>, std::list<int, A1<int> > >());
467 static_assert(
468     !CheckAssignableFromLvaluesAndRvalues<std::list<int>, std::vector<int> >());
469 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::list<int>, int>());
470 
471 static_assert(CheckAssignableFromLvaluesAndRvalues<std::map<int, void*>,
472                                                    std::map<int, void*> >());
473 static_assert(!CheckAssignableFromLvaluesAndRvalues<
474               std::map<int, void*>, std::map<const int, void*> >());
475 static_assert(!CheckAssignableFromLvaluesAndRvalues<
476               std::map<int, void*>,
477               std::map<int, void*, A1<std::pair<int, void*> > > >());
478 static_assert(!CheckAssignableFromLvaluesAndRvalues<
479               std::map<int, void*>, std::unordered_map<int, void*> >());
480 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::map<int, void*>,
481                                                     std::pair<int, void*> >());
482 
483 #ifndef _LIBCPP_HAS_NO_THREADS
484 static_assert(!CheckAssignableFromRvalues<std::mutex, std::mutex>());
485 static_assert(!CheckAssignableFromLvalues<std::mutex, std::mutex>());
486 #endif
487 
488 static_assert(CheckAssignableFromLvaluesAndRvalues<std::optional<int>, int>());
489 static_assert(
490     CheckAssignableFromLvaluesAndRvalues<std::optional<int>, double>());
491 static_assert(CheckAssignableFromLvaluesAndRvalues<std::optional<int>,
492                                                    std::optional<int> >());
493 static_assert(
494     !CheckAssignableFromLvaluesAndRvalues<int, std::optional<int> >());
495 static_assert(
496     !CheckAssignableFromLvaluesAndRvalues<double, std::optional<int> >());
497 
498 static_assert(
499     !std::common_reference_with<std::optional<int>, std::optional<double> >);
500 static_assert(
501     !CheckAssignableFromRvalues<std::optional<int>, std::optional<double> >());
502 static_assert(
503     !CheckAssignableFromLvalues<std::optional<int>, std::optional<double> >());
504 
505 static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, std::string>());
506 static_assert(
507     CheckAssignableFromLvaluesAndRvalues<std::string, std::string_view>());
508 static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, char*>());
509 static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, const char*>());
510 static_assert(!CheckAssignableFromLvaluesAndRvalues<
511               std::string, std::basic_string<wchar_t> >());
512 static_assert(
513     !CheckAssignableFromLvaluesAndRvalues<std::string, std::vector<char> >());
514 
515 static_assert(
516     CheckAssignableFromLvaluesAndRvalues<std::string_view, std::string_view>());
517 static_assert(
518     CheckAssignableFromLvaluesAndRvalues<std::string_view, std::string>());
519 static_assert(CheckAssignableFromLvaluesAndRvalues<std::string_view, char*>());
520 static_assert(
521     CheckAssignableFromLvaluesAndRvalues<std::string_view, const char*>());
522 static_assert(!CheckAssignableFromLvaluesAndRvalues<
523               std::string_view, std::basic_string_view<wchar_t> >());
524 
525 static_assert(
526     CheckAssignableFromRvalues<std::unique_ptr<int>, std::unique_ptr<int> >());
527 static_assert(
528     !CheckAssignableFromLvalues<std::unique_ptr<int>, std::unique_ptr<int> >());
529 
530 static_assert(
531     CheckAssignableFromLvaluesAndRvalues<std::unordered_map<int, void*>,
532                                          std::unordered_map<int, void*> >());
533 static_assert(!CheckAssignableFromLvaluesAndRvalues<
534               std::unordered_map<int, void*>,
535               std::unordered_map<const int, void*> >());
536 static_assert(!CheckAssignableFromLvaluesAndRvalues<
537               std::unordered_map<int, void*>,
538               std::unordered_map<int, void*, A1<std::pair<int, void*> > > >());
539 static_assert(!CheckAssignableFromLvaluesAndRvalues<
540               std::unordered_map<int, void*>, std::map<int, void*> >());
541 static_assert(!CheckAssignableFromLvaluesAndRvalues<
542               std::unordered_map<int, void*>, std::pair<int, void*> >());
543 
544 static_assert(CheckAssignableFromLvaluesAndRvalues<std::vector<int>,
545                                                    std::vector<int> >());
546 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>,
547                                                     std::deque<const int> >());
548 static_assert(!CheckAssignableFromLvaluesAndRvalues<
549               std::vector<int>, std::vector<int, A1<int> > >());
550 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::vector<int>,
551                                                     std::deque<int> >());
552 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::vector<int>, int>());
553 } // namespace StandardTypes
554 
555 int main(int, char**) { return 0; }
556