1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10export namespace std {
11  // [meta.help], helper class
12  using std::integral_constant;
13
14  using std::bool_constant;
15  using std::false_type;
16  using std::true_type;
17
18  // [meta.unary.cat], primary type categories
19  using std::is_array;
20  using std::is_class;
21  using std::is_enum;
22  using std::is_floating_point;
23  using std::is_function;
24  using std::is_integral;
25  using std::is_lvalue_reference;
26  using std::is_member_function_pointer;
27  using std::is_member_object_pointer;
28  using std::is_null_pointer;
29  using std::is_pointer;
30  using std::is_rvalue_reference;
31  using std::is_union;
32  using std::is_void;
33
34  // [meta.unary.comp], composite type categories
35  using std::is_arithmetic;
36  using std::is_compound;
37  using std::is_fundamental;
38  using std::is_member_pointer;
39  using std::is_object;
40  using std::is_reference;
41  using std::is_scalar;
42
43  // [meta.unary.prop], type properties
44  using std::is_abstract;
45  using std::is_aggregate;
46  using std::is_const;
47  using std::is_empty;
48  using std::is_final;
49  using std::is_polymorphic;
50  using std::is_standard_layout;
51  using std::is_trivial;
52  using std::is_trivially_copyable;
53  using std::is_volatile;
54
55  using std::is_bounded_array;
56#if _LIBCPP_STD_VER >= 23
57  using std::is_scoped_enum;
58#endif
59  using std::is_signed;
60  using std::is_unbounded_array;
61  using std::is_unsigned;
62
63  using std::is_constructible;
64  using std::is_copy_constructible;
65  using std::is_default_constructible;
66  using std::is_move_constructible;
67
68  using std::is_assignable;
69  using std::is_copy_assignable;
70  using std::is_move_assignable;
71
72  using std::is_swappable;
73  using std::is_swappable_with;
74
75  using std::is_destructible;
76
77  using std::is_trivially_constructible;
78  using std::is_trivially_copy_constructible;
79  using std::is_trivially_default_constructible;
80  using std::is_trivially_move_constructible;
81
82  using std::is_trivially_assignable;
83  using std::is_trivially_copy_assignable;
84  using std::is_trivially_destructible;
85  using std::is_trivially_move_assignable;
86
87  using std::is_nothrow_constructible;
88  using std::is_nothrow_copy_constructible;
89  using std::is_nothrow_default_constructible;
90  using std::is_nothrow_move_constructible;
91
92  using std::is_nothrow_assignable;
93  using std::is_nothrow_copy_assignable;
94  using std::is_nothrow_move_assignable;
95
96  using std::is_nothrow_swappable;
97  using std::is_nothrow_swappable_with;
98
99  using std::is_nothrow_destructible;
100
101  //  using std::is_implicit_lifetime;
102
103  using std::has_virtual_destructor;
104
105  using std::has_unique_object_representations;
106
107  // using std::reference_constructs_from_temporary;
108  // using std::reference_converts_from_temporary;
109
110  // [meta.unary.prop.query], type property queries
111  using std::alignment_of;
112  using std::extent;
113  using std::rank;
114
115  // [meta.rel], type relations
116  using std::is_base_of;
117  using std::is_convertible;
118  // using std::is_layout_compatible;
119  using std::is_nothrow_convertible;
120  // using std::is_pointer_interconvertible_base_of;
121  using std::is_same;
122
123  using std::is_invocable;
124  using std::is_invocable_r;
125
126  using std::is_nothrow_invocable;
127  using std::is_nothrow_invocable_r;
128
129  // [meta.trans.cv], const-volatile modifications
130  using std::add_const;
131  using std::add_cv;
132  using std::add_volatile;
133  using std::remove_const;
134  using std::remove_cv;
135  using std::remove_volatile;
136
137  using std::add_const_t;
138  using std::add_cv_t;
139  using std::add_volatile_t;
140  using std::remove_const_t;
141  using std::remove_cv_t;
142  using std::remove_volatile_t;
143
144  // [meta.trans.ref], reference modifications
145  using std::add_lvalue_reference;
146  using std::add_rvalue_reference;
147  using std::remove_reference;
148
149  using std::add_lvalue_reference_t;
150  using std::add_rvalue_reference_t;
151  using std::remove_reference_t;
152
153  // [meta.trans.sign], sign modifications
154  using std::make_signed;
155  using std::make_unsigned;
156
157  using std::make_signed_t;
158  using std::make_unsigned_t;
159
160  // [meta.trans.arr], array modifications
161  using std::remove_all_extents;
162  using std::remove_extent;
163
164  using std::remove_all_extents_t;
165  using std::remove_extent_t;
166
167  // [meta.trans.ptr], pointer modifications
168  using std::add_pointer;
169  using std::remove_pointer;
170
171  using std::add_pointer_t;
172  using std::remove_pointer_t;
173
174  // [meta.trans.other], other transformations
175  using std::basic_common_reference;
176  using std::common_reference;
177  using std::common_type;
178  using std::conditional;
179  using std::decay;
180  using std::enable_if;
181  using std::invoke_result;
182  using std::remove_cvref;
183  using std::type_identity;
184  using std::underlying_type;
185  using std::unwrap_ref_decay;
186  using std::unwrap_reference;
187
188  using std::common_reference_t;
189  using std::common_type_t;
190  using std::conditional_t;
191  using std::decay_t;
192  using std::enable_if_t;
193  using std::invoke_result_t;
194  using std::remove_cvref_t;
195  using std::type_identity_t;
196  using std::underlying_type_t;
197  using std::unwrap_ref_decay_t;
198  using std::unwrap_reference_t;
199  using std::void_t;
200
201  // [meta.logical], logical operator traits
202  using std::conjunction;
203  using std::disjunction;
204  using std::negation;
205
206  // [meta.unary.cat], primary type categories
207  using std::is_array_v;
208  using std::is_class_v;
209  using std::is_enum_v;
210  using std::is_floating_point_v;
211  using std::is_function_v;
212  using std::is_integral_v;
213  using std::is_lvalue_reference_v;
214  using std::is_member_function_pointer_v;
215  using std::is_member_object_pointer_v;
216  using std::is_null_pointer_v;
217  using std::is_pointer_v;
218  using std::is_rvalue_reference_v;
219  using std::is_union_v;
220  using std::is_void_v;
221
222  // [meta.unary.comp], composite type categories
223  using std::is_arithmetic_v;
224  using std::is_compound_v;
225  using std::is_fundamental_v;
226  using std::is_member_pointer_v;
227  using std::is_object_v;
228  using std::is_reference_v;
229  using std::is_scalar_v;
230
231  // [meta.unary.prop], type properties
232  using std::has_unique_object_representations_v;
233  using std::has_virtual_destructor_v;
234  using std::is_abstract_v;
235  using std::is_aggregate_v;
236  using std::is_assignable_v;
237  using std::is_bounded_array_v;
238  using std::is_const_v;
239  using std::is_constructible_v;
240  using std::is_copy_assignable_v;
241  using std::is_copy_constructible_v;
242  using std::is_default_constructible_v;
243  using std::is_destructible_v;
244  using std::is_empty_v;
245  using std::is_final_v;
246  // using std::is_implicit_lifetime_v;
247  using std::is_move_assignable_v;
248  using std::is_move_constructible_v;
249  using std::is_nothrow_assignable_v;
250  using std::is_nothrow_constructible_v;
251  using std::is_nothrow_copy_assignable_v;
252  using std::is_nothrow_copy_constructible_v;
253  using std::is_nothrow_default_constructible_v;
254  using std::is_nothrow_destructible_v;
255  using std::is_nothrow_move_assignable_v;
256  using std::is_nothrow_move_constructible_v;
257  using std::is_nothrow_swappable_v;
258  using std::is_nothrow_swappable_with_v;
259  using std::is_polymorphic_v;
260#if _LIBCPP_STD_VER >= 23
261  using std::is_scoped_enum_v;
262#endif
263  using std::is_signed_v;
264  using std::is_standard_layout_v;
265  using std::is_swappable_v;
266  using std::is_swappable_with_v;
267  using std::is_trivial_v;
268  using std::is_trivially_assignable_v;
269  using std::is_trivially_constructible_v;
270  using std::is_trivially_copy_assignable_v;
271  using std::is_trivially_copy_constructible_v;
272  using std::is_trivially_copyable_v;
273  using std::is_trivially_default_constructible_v;
274  using std::is_trivially_destructible_v;
275  using std::is_trivially_move_assignable_v;
276  using std::is_trivially_move_constructible_v;
277  using std::is_unbounded_array_v;
278  using std::is_unsigned_v;
279  using std::is_volatile_v;
280  // using std::reference_constructs_from_temporary_v;
281  // using std::reference_converts_from_temporary_v;
282
283  // [meta.unary.prop.query], type property queries
284  using std::alignment_of_v;
285  using std::extent_v;
286  using std::rank_v;
287
288  // [meta.rel], type relations
289  using std::is_base_of_v;
290  using std::is_convertible_v;
291  using std::is_invocable_r_v;
292  using std::is_invocable_v;
293  // using std::is_layout_compatible_v;
294  using std::is_nothrow_convertible_v;
295  using std::is_nothrow_invocable_r_v;
296  using std::is_nothrow_invocable_v;
297  // using std::is_pointer_interconvertible_base_of_v;
298  using std::is_same_v;
299
300  // [meta.logical], logical operator traits
301  using std::conjunction_v;
302  using std::disjunction_v;
303  using std::negation_v;
304
305  // [meta.member], member relationships
306  // using std::is_corresponding_member;
307  // using std::is_pointer_interconvertible_with_class;
308
309  // [meta.const.eval], constant evaluation context
310  using std::is_constant_evaluated;
311
312  // [depr.meta.types]
313  using std::aligned_storage;
314  using std::aligned_storage_t;
315  using std::aligned_union;
316  using std::aligned_union_t;
317  using std::is_pod;
318  using std::is_pod_v;
319} // namespace std
320