[meta.reflection] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp3_brtuk2/{from.md → to.md} +2857 -0

tmp/tmp3_brtuk2/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,2857 @@

+## Reflection <a id="meta.reflection">[[meta.reflection]]</a>
+### Header `<meta>` synopsis <a id="meta.syn">[[meta.syn]]</a>
+``` cpp
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [meta.string.literal], checking string literals
+  consteval bool is_string_literal(const char* p);
+  consteval bool is_string_literal(const wchar_t* p);
+  consteval bool is_string_literal(const char8_t* p);
+  consteval bool is_string_literal(const char16_t* p);
+  consteval bool is_string_literal(const char32_t* p);
+  // [meta.define.static], promoting to static storage
+  namespace meta {
+    template<ranges::input_range R>
+      consteval info reflect_constant_string(R&& r);
+    template<ranges::input_range R>
+      consteval info reflect_constant_array(R&& r);
+  }
+  template<ranges::input_range R>
+    consteval const ranges::range_value_t<R>* define_static_string(R&& r);
+  template<ranges::input_range R>
+    consteval span<const ranges::range_value_t<R>> define_static_array(R&& r);
+  template<class T>
+    consteval const remove_cvref_t<T>* define_static_object(T&& r);
+}
+namespace std::meta {
+  using info = decltype(^^::);
+  // [meta.reflection.exception], class exception
+  class exception;
+  // [meta.reflection.operators], operator representations
+  enum class operators {
+    see below;
+  };
+  using enum operators;
+  consteval operators operator_of(info r);
+  consteval string_view symbol_of(operators op);
+  consteval u8string_view u8symbol_of(operators op);
+  // [meta.reflection.names], reflection names and locations
+  consteval bool has_identifier(info r);
+  consteval string_view identifier_of(info r);
+  consteval u8string_view u8identifier_of(info r);
+  consteval string_view display_string_of(info r);
+  consteval u8string_view u8display_string_of(info r);
+  consteval source_location source_location_of(info r);
+  // [meta.reflection.queries], reflection queries
+  consteval info type_of(info r);
+  consteval info object_of(info r);
+  consteval info constant_of(info r);
+  consteval bool is_public(info r);
+  consteval bool is_protected(info r);
+  consteval bool is_private(info r);
+  consteval bool is_virtual(info r);
+  consteval bool is_pure_virtual(info r);
+  consteval bool is_override(info r);
+  consteval bool is_final(info r);
+  consteval bool is_deleted(info r);
+  consteval bool is_defaulted(info r);
+  consteval bool is_user_provided(info r);
+  consteval bool is_user_declared(info r);
+  consteval bool is_explicit(info r);
+  consteval bool is_noexcept(info r);
+  consteval bool is_bit_field(info r);
+  consteval bool is_enumerator(info r);
+  consteval bool is_annotation(info r);
+  consteval bool is_const(info r);
+  consteval bool is_volatile(info r);
+  consteval bool is_mutable_member(info r);
+  consteval bool is_lvalue_reference_qualified(info r);
+  consteval bool is_rvalue_reference_qualified(info r);
+  consteval bool has_static_storage_duration(info r);
+  consteval bool has_thread_storage_duration(info r);
+  consteval bool has_automatic_storage_duration(info r);
+  consteval bool has_internal_linkage(info r);
+  consteval bool has_module_linkage(info r);
+  consteval bool has_external_linkage(info r);
+  consteval bool has_c_language_linkage(info r);
+  consteval bool has_linkage(info r);
+  consteval bool is_complete_type(info r);
+  consteval bool is_enumerable_type(info r);
+  consteval bool is_variable(info r);
+  consteval bool is_type(info r);
+  consteval bool is_namespace(info r);
+  consteval bool is_type_alias(info r);
+  consteval bool is_namespace_alias(info r);
+  consteval bool is_function(info r);
+  consteval bool is_conversion_function(info r);
+  consteval bool is_operator_function(info r);
+  consteval bool is_literal_operator(info r);
+  consteval bool is_special_member_function(info r);
+  consteval bool is_constructor(info r);
+  consteval bool is_default_constructor(info r);
+  consteval bool is_copy_constructor(info r);
+  consteval bool is_move_constructor(info r);
+  consteval bool is_assignment(info r);
+  consteval bool is_copy_assignment(info r);
+  consteval bool is_move_assignment(info r);
+  consteval bool is_destructor(info r);
+  consteval bool is_function_parameter(info r);
+  consteval bool is_explicit_object_parameter(info r);
+  consteval bool has_default_argument(info r);
+  consteval bool has_ellipsis_parameter(info r);
+  consteval bool is_template(info r);
+  consteval bool is_function_template(info r);
+  consteval bool is_variable_template(info r);
+  consteval bool is_class_template(info r);
+  consteval bool is_alias_template(info r);
+  consteval bool is_conversion_function_template(info r);
+  consteval bool is_operator_function_template(info r);
+  consteval bool is_literal_operator_template(info r);
+  consteval bool is_constructor_template(info r);
+  consteval bool is_concept(info r);
+  consteval bool is_value(info r);
+  consteval bool is_object(info r);
+  consteval bool is_structured_binding(info r);
+  consteval bool is_class_member(info r);
+  consteval bool is_namespace_member(info r);
+  consteval bool is_nonstatic_data_member(info r);
+  consteval bool is_static_member(info r);
+  consteval bool is_base(info r);
+  consteval bool has_default_member_initializer(info r);
+  consteval bool has_parent(info r);
+  consteval info parent_of(info r);
+  consteval info dealias(info r);
+  consteval bool has_template_arguments(info r);
+  consteval info template_of(info r);
+  consteval vector<info> template_arguments_of(info r);
+  consteval vector<info> parameters_of(info r);
+  consteval info variable_of(info r);
+  consteval info return_type_of(info r);
+  // [meta.reflection.access.context], access control context
+  struct access_context;
+  // [meta.reflection.access.queries], member accessibility queries
+  consteval bool is_accessible(info r, access_context ctx);
+  consteval bool has_inaccessible_nonstatic_data_members(info r, access_context ctx);
+  consteval bool has_inaccessible_bases(info r, access_context ctx);
+  consteval bool has_inaccessible_subobjects(info r, access_context ctx);
+  // [meta.reflection.member.queries], reflection member queries
+  consteval vector<info> members_of(info r, access_context ctx);
+  consteval vector<info> bases_of(info type, access_context ctx);
+  consteval vector<info> static_data_members_of(info type, access_context ctx);
+  consteval vector<info> nonstatic_data_members_of(info type, access_context ctx);
+  consteval vector<info> subobjects_of(info type, access_context ctx);
+  consteval vector<info> enumerators_of(info type_enum);
+  // [meta.reflection.layout], reflection layout queries
+  struct member_offset;
+  consteval member_offset offset_of(info r);
+  consteval size_t size_of(info r);
+  consteval size_t alignment_of(info r);
+  consteval size_t bit_size_of(info r);
+  // [meta.reflection.annotation], annotation reflection
+  consteval vector<info> annotations_of(info item);
+  consteval vector<info> annotations_of_with_type(info item, info type);
+  // [meta.reflection.extract], value extraction
+  template<class T>
+    consteval T extract(info);
+  // [meta.reflection.substitute], reflection substitution
+  template<class R>
+    concept reflection_range = see below;
+  template<reflection_range R = initializer_list<info>>
+    consteval bool can_substitute(info templ, R&& arguments);
+  template<reflection_range R = initializer_list<info>>
+    consteval info substitute(info templ, R&& arguments);
+  // [meta.reflection.result], expression result reflection
+  template<class T>
+    consteval info reflect_constant(T expr);
+  template<class T>
+    consteval info reflect_object(T& expr);
+  template<class T>
+    consteval info reflect_function(T& fn);
+  // [meta.reflection.define.aggregate], class definition generation
+  struct data_member_options;
+  consteval info data_member_spec(info type, data_member_options options);
+  consteval bool is_data_member_spec(info r);
+  template<reflection_range R = initializer_list<info>>
+    consteval info define_aggregate(info type_class, R&&);
+  // associated with [meta.unary.cat], primary type categories
+  consteval bool is_void_type(info type);
+  consteval bool is_null_pointer_type(info type);
+  consteval bool is_integral_type(info type);
+  consteval bool is_floating_point_type(info type);
+  consteval bool is_array_type(info type);
+  consteval bool is_pointer_type(info type);
+  consteval bool is_lvalue_reference_type(info type);
+  consteval bool is_rvalue_reference_type(info type);
+  consteval bool is_member_object_pointer_type(info type);
+  consteval bool is_member_function_pointer_type(info type);
+  consteval bool is_enum_type(info type);
+  consteval bool is_union_type(info type);
+  consteval bool is_class_type(info type);
+  consteval bool is_function_type(info type);
+  consteval bool is_reflection_type(info type);
+  // associated with [meta.unary.comp], composite type categories
+  consteval bool is_reference_type(info type);
+  consteval bool is_arithmetic_type(info type);
+  consteval bool is_fundamental_type(info type);
+  consteval bool is_object_type(info type);
+  consteval bool is_scalar_type(info type);
+  consteval bool is_compound_type(info type);
+  consteval bool is_member_pointer_type(info type);
+  // associated with [meta.unary.prop], type properties
+  consteval bool is_const_type(info type);
+  consteval bool is_volatile_type(info type);
+  consteval bool is_trivially_copyable_type(info type);
+  consteval bool is_trivially_relocatable_type(info type);
+  consteval bool is_replaceable_type(info type);
+  consteval bool is_standard_layout_type(info type);
+  consteval bool is_empty_type(info type);
+  consteval bool is_polymorphic_type(info type);
+  consteval bool is_abstract_type(info type);
+  consteval bool is_final_type(info type);
+  consteval bool is_aggregate_type(info type);
+  consteval bool is_consteval_only_type(info type);
+  consteval bool is_signed_type(info type);
+  consteval bool is_unsigned_type(info type);
+  consteval bool is_bounded_array_type(info type);
+  consteval bool is_unbounded_array_type(info type);
+  consteval bool is_scoped_enum_type(info type);
+  template<reflection_range R = initializer_list<info>>
+    consteval bool is_constructible_type(info type, R&& type_args);
+  consteval bool is_default_constructible_type(info type);
+  consteval bool is_copy_constructible_type(info type);
+  consteval bool is_move_constructible_type(info type);
+  consteval bool is_assignable_type(info type_dst, info type_src);
+  consteval bool is_copy_assignable_type(info type);
+  consteval bool is_move_assignable_type(info type);
+  consteval bool is_swappable_with_type(info type1, info type2);
+  consteval bool is_swappable_type(info type);
+  consteval bool is_destructible_type(info type);
+  template<reflection_range R = initializer_list<info>>
+    consteval bool is_trivially_constructible_type(info type, R&& type_args);
+  consteval bool is_trivially_default_constructible_type(info type);
+  consteval bool is_trivially_copy_constructible_type(info type);
+  consteval bool is_trivially_move_constructible_type(info type);
+  consteval bool is_trivially_assignable_type(info type_dst, info type_src);
+  consteval bool is_trivially_copy_assignable_type(info type);
+  consteval bool is_trivially_move_assignable_type(info type);
+  consteval bool is_trivially_destructible_type(info type);
+  template<reflection_range R = initializer_list<info>>
+    consteval bool is_nothrow_constructible_type(info type, R&& type_args);
+  consteval bool is_nothrow_default_constructible_type(info type);
+  consteval bool is_nothrow_copy_constructible_type(info type);
+  consteval bool is_nothrow_move_constructible_type(info type);
+  consteval bool is_nothrow_assignable_type(info type_dst, info type_src);
+  consteval bool is_nothrow_copy_assignable_type(info type);
+  consteval bool is_nothrow_move_assignable_type(info type);
+  consteval bool is_nothrow_swappable_with_type(info type1, info type2);
+  consteval bool is_nothrow_swappable_type(info type);
+  consteval bool is_nothrow_destructible_type(info type);
+  consteval bool is_nothrow_relocatable_type(info type);
+  consteval bool is_implicit_lifetime_type(info type);
+  consteval bool has_virtual_destructor(info type);
+  consteval bool has_unique_object_representations(info type);
+  consteval bool reference_constructs_from_temporary(info type_dst, info type_src);
+  consteval bool reference_converts_from_temporary(info type_dst, info type_src);
+  // associated with [meta.unary.prop.query], type property queries
+  consteval size_t rank(info type);
+  consteval size_t extent(info type, unsigned i = 0);
+  // associated with [meta.rel], type relations
+  consteval bool is_same_type(info type1, info type2);
+  consteval bool is_base_of_type(info type_base, info type_derived);
+  consteval bool is_virtual_base_of_type(info type_base, info type_derived);
+  consteval bool is_convertible_type(info type_src, info type_dst);
+  consteval bool is_nothrow_convertible_type(info type_src, info type_dst);
+  consteval bool is_layout_compatible_type(info type1, info type2);
+  consteval bool is_pointer_interconvertible_base_of_type(info type_base, info type_derived);
+  template<reflection_range R = initializer_list<info>>
+    consteval bool is_invocable_type(info type, R&& type_args);
+  template<reflection_range R = initializer_list<info>>
+    consteval bool is_invocable_r_type(info type_result, info type, R&& type_args);
+  template<reflection_range R = initializer_list<info>>
+    consteval bool is_nothrow_invocable_type(info type, R&& type_args);
+  template<reflection_range R = initializer_list<info>>
+    consteval bool is_nothrow_invocable_r_type(info type_result, info type, R&& type_args);
+  // associated with [meta.trans.cv], const-volatile modifications
+  consteval info remove_const(info type);
+  consteval info remove_volatile(info type);
+  consteval info remove_cv(info type);
+  consteval info add_const(info type);
+  consteval info add_volatile(info type);
+  consteval info add_cv(info type);
+  // associated with [meta.trans.ref], reference modifications
+  consteval info remove_reference(info type);
+  consteval info add_lvalue_reference(info type);
+  consteval info add_rvalue_reference(info type);
+  // associated with [meta.trans.sign], sign modifications
+  consteval info make_signed(info type);
+  consteval info make_unsigned(info type);
+  // associated with [meta.trans.arr], array modifications
+  consteval info remove_extent(info type);
+  consteval info remove_all_extents(info type);
+  // associated with [meta.trans.ptr], pointer modifications
+  consteval info remove_pointer(info type);
+  consteval info add_pointer(info type);
+  // associated with [meta.trans.other], other transformations
+  consteval info remove_cvref(info type);
+  consteval info decay(info type);
+  template<reflection_range R = initializer_list<info>>
+    consteval info common_type(R&& type_args);
+  template<reflection_range R = initializer_list<info>>
+    consteval info common_reference(R&& type_args);
+  consteval info underlying_type(info type);
+  template<reflection_range R = initializer_list<info>>
+    consteval info invoke_result(info type, R&& type_args);
+  consteval info unwrap_reference(info type);
+  consteval info unwrap_ref_decay(info type);
+  consteval size_t tuple_size(info type);
+  consteval info tuple_element(size_t index, info type);
+  consteval size_t variant_size(info type);
+  consteval info variant_alternative(size_t index, info type);
+  consteval strong_ordering type_order(info type_a, info type_b);
+}
+```
+Unless otherwise specified, each function, and each specialization of
+any function template, specified in this header is a designated
+addressable function [[namespace.std]].
+The behavior of any function specified in namespace `std::meta` is
+*implementation-defined* when a reflection of a construct not otherwise
+specified by this document is provided as an argument.
+[*Note 1*: Values of type `std::meta::info` can represent
+implementation-specific constructs [[basic.fundamental]]. — *end note*]
+[*Note 2*:
+Many of the functions specified in namespace `std::meta` have semantics
+that can be affected by the completeness of class types represented by
+reflection values. For such functions, for any reflection `r` such that
+`dealias(r)` represents a specialization of a templated class with a
+reachable definition, the specialization is implicitly instantiated
+[[temp.inst]].
+[*Example 1*:
+``` cpp
+template<class T>
+struct X {
+  T mem;
+};
+static_assert(size_of(^^X<int>) == sizeof(int));    // instantiates X<int>
+```
+— *end example*]
+— *end note*]
+Any function in namespace `std::meta` whose return type is `string_view`
+or `u8string_view` returns an object *`V`* such that
+`V.data()[V.size()]` equals `'\0'`.
+[*Example 2*:
+``` cpp
+struct C { };
+constexpr string_view sv = identifier_of(^^C);
+static_assert(sv == "C");
+static_assert(sv.data()[0] == 'C');
+static_assert(sv.data()[1] == '{}0');
+```
+— *end example*]
+For the purpose of exposition, throughout this clause `^^E` is used to
+indicate a reflection representing source construct `E`.
+### Checking string literals <a id="meta.string.literal">[[meta.string.literal]]</a>
+``` cpp
+consteval bool is_string_literal(const char* p);
+consteval bool is_string_literal(const wchar_t* p);
+consteval bool is_string_literal(const char8_t* p);
+consteval bool is_string_literal(const char16_t* p);
+consteval bool is_string_literal(const char32_t* p);
+```
+*Returns:*
+- If `p` points to an unspecified object [[expr.const]], `false`.
+- Otherwise, if `p` points to a subobject of a string literal
+  object [[lex.string]], `true`.
+- Otherwise, `false`.
+### Promoting to static storage <a id="meta.define.static">[[meta.define.static]]</a>
+The functions in this subclause promote compile-time storage into static
+storage.
+``` cpp
+template<ranges::input_range R>
+  consteval info reflect_constant_string(R&& r);
+```
+Let `CharT` be `ranges::range_value_t<R>`.
+*Mandates:* `CharT` is one of `char`, `wchar_t`, `char8_t`, `char16_t`,
+`char32_t`.
+Let V be the pack of values of type `CharT` whose elements are the
+corresponding elements of `r`, except that if `r` refers to a string
+literal object, then V does not include the trailing null terminator of
+`r`.
+Let P be the template parameter object [[temp.param]] of type
+`const CharT[sizeof...(V) + 1]` initialized with `{`V`..., CharT()}`.
+*Returns:* .
+[*Note 1*: P is a potentially non-unique
+object [[intro.object]]. — *end note*]
+``` cpp
+template<ranges::input_range R>
+  consteval info reflect_constant_array(R&& r);
+```
+Let `T` be `ranges::range_value_t<R>`.
+*Mandates:* `T` is a structural type [[temp.param]],
+`is_constructible_v<T, ranges::range_reference_t<R>>` is `true`, and
+`is_copy_constructible_v<T>` is `true`.
+Let V be the pack of values of type `info` of the same size as `r`,
+where the iᵗʰ element is `reflect_constant(``eᵢ``)`, where `eᵢ` is the
+iᵗʰ element of `r`.
+Let P be
+- If `sizeof...(`V`) > 0` is `true`, then the template parameter
+  object [[temp.param]] of type `const T[sizeof...(`V`)]` initialized
+  with `{[:`V`:]...}`.
+- Otherwise, the template parameter object of type `const array<T, 0>`
+  initialized with `{}`.
+*Returns:* .
+*Throws:* `meta::exception` unless `reflect_constant(e)` is a constant
+subexpression for every element `e` of `r`.
+[*Note 2*: P is a potentially non-unique
+object [[intro.object]]. — *end note*]
+``` cpp
+template<ranges::input_range R>
+  consteval const ranges::range_value_t<R>* define_static_string(R&& r);
+```
+*Effects:* Equivalent to:
+``` cpp
+return meta::extract<const ranges::range_value_t<R>*>(meta::reflect_constant_string(r));
+```
+``` cpp
+template<ranges::input_range R>
+  consteval span<const ranges::range_value_t<R>> define_static_array(R&& r);
+```
+*Effects:* Equivalent to:
+``` cpp
+using T = ranges::range_value_t<R>;
+meta::info array = meta::reflect_constant_array(r);
+if (meta::is_array_type(meta::type_of(array))) {
+  return span<const T>(meta::extract<const T*>(array), meta::extent(meta::type_of(array)));
+} else {
+  return span<const T>();
+}
+```
+``` cpp
+template<class T>
+  consteval const remove_cvref_t<T>* define_static_object(T&& t);
+```
+*Effects:* Equivalent to:
+``` cpp
+using U = remove_cvref_t<T>;
+if constexpr (meta::is_class_type(^^U)) {
+  return addressof(meta::extract<const U&>(meta::reflect_constant(std::forward<T>(t))));
+} else {
+  return define_static_array(span(addressof(t), 1)).data();
+}
+```
+[*Note 3*: For class types, `define_static_object` provides the address
+of the template parameter object [[temp.param]] that is
+template-argument equivalent to `t`. — *end note*]
+### Class `exception` <a id="meta.reflection.exception">[[meta.reflection.exception]]</a>
+``` cpp
+namespace std::meta {
+  class exception : public std::exception {
+  private:
+    optional<string> what_;     // exposition only
+    u8string u8what_;           // exposition only
+    info from_;                 // exposition only
+    source_location where_;     // exposition only
+  public:
+    consteval exception(u8string_view what, info from,
+                        source_location where = source_location::current()) noexcept;
+    consteval exception(string_view what, info from,
+                        source_location where = source_location::current()) noexcept;
+    exception(const exception&) = default;
+    exception(exception&&) = default;
+    exception& operator=(const exception&) = default;
+    exception& operator=(exception&&) = default;
+    constexpr const char* what() const noexcept override;
+    consteval u8string_view u8what() const noexcept;
+    consteval info from() const noexcept;
+    consteval source_location where() const noexcept;
+  };
+}
+```
+Reflection functions throw exceptions of type `meta::exception` to
+signal an error. `meta::exception` is a consteval-only type.
+``` cpp
+consteval exception(u8string_view what, info from,
+                    source_location where = source_location::current()) noexcept;
+```
+*Effects:* Initializes *u8what\_* with `what`, *from\_* with `from`, and
+*where\_* with `where`. If `what` can be represented in the ordinary
+literal encoding, initializes *what\_* with `what`, transcoded from
+UTF-8 to the ordinary literal encoding. Otherwise, *what\_* is
+value-initialized.
+``` cpp
+consteval exception(string_view what, info from,
+                    source_location where = source_location::current()) noexcept;
+```
+`what` designates a sequence of characters that can be encoded in UTF-8.
+*Effects:* Initializes *what\_* with `what`, *u8what\_* with `what`
+transcoded from the ordinary literal encoding to UTF-8, *from\_* with
+`from` and *where\_* with `where`.
+``` cpp
+constexpr const char* what() const noexcept override;
+```
+*`what_`*`.has_value()` is `true`.
+*Returns:* *`what_`*`->c_str()`.
+``` cpp
+consteval u8string_view u8what() const noexcept;
+```
+*Returns:* *u8what\_*.
+``` cpp
+consteval info from() const noexcept;
+```
+*Returns:* *from\_*.
+``` cpp
+consteval source_location where() const noexcept;
+```
+*Returns:* *where\_*.
+### Operator representations <a id="meta.reflection.operators">[[meta.reflection.operators]]</a>
+``` cpp
+enum class operators {
+  see below;
+};
+using enum operators;
+```
+The enumeration type `operators` specifies constants used to identify
+operators that can be overloaded, with the meanings listed
+in  [[meta.reflection.operators]]. The values of the constants are
+distinct.
+**Table: Enum class `operators`** <a id="meta.reflection.operators">[meta.reflection.operators]</a>
+| Constant                    | Corresponding *operator-function-id* | Operator symbol name |
+| --------------------------- | ------------------------------------ | -------------------- |
+| `op_new`                    | `operator new`                       | `new`                |
+| `op_delete`                 | `operator delete`                    | `delete`             |
+| `op_array_new`              | `operator new[]`                     | `new[]`              |
+| `op_array_delete`           | `operator delete[]`                  | `delete[]`           |
+| `op_co_await`               | `operator co_await`                  | `co_await`           |
+| `op_parentheses`            | `operator()`                         | `()`                 |
+| `op_square_brackets`        | `operator[]`                         | `[]`                 |
+| `op_arrow`                  | `operator->`                         | `->`                 |
+| `op_arrow_star`             | `operator->*`                        | `->*`                |
+| `op_tilde`                  | `operator~`                          | `~`                  |
+| `op_exclamation`            | `operator!`                          | `!`                  |
+| `op_plus`                   | `operator+`                          | `+`                  |
+| `op_minus`                  | `operator-`                          | `-`                  |
+| `op_star`                   | `operator*`                          | `*`                  |
+| `op_slash`                  | `operator/`                          | `/`                  |
+| `op_percent`                | `operator%`                          | `%`                  |
+| `op_caret`                  | `operator^`                          | `^`                  |
+| `op_ampersand`              | `operator&`                          | `&`                  |
+| `op_equals`                 | `operator=`                          | `=`                  |
+| `op_pipe`                   | `operator|`                          | `|`                  |
+| `op_plus_equals`            | `operator+=`                         | `+=`                 |
+| `op_minus_equals`           | `operator-=`                         | `-=`                 |
+| `op_star_equals`            | `operator*=`                         | `*=`                 |
+| `op_slash_equals`           | `operator/=`                         | `/=`                 |
+| `op_percent_equals`         | `operator%=`                         | `%=`                 |
+| `op_caret_equals`           | `operator^=`                         | `^=`                 |
+| `op_ampersand_equals`       | `operator&=`                         | `&=`                 |
+| `op_pipe_equals`            | `operator|=`                         | `|=`                 |
+| `op_equals_equals`          | `operator==`                         | `==`                 |
+| `op_exclamation_equals`     | `operator!=`                         | `!=`                 |
+| `op_less`                   | `operator<`                          | `<`                  |
+| `op_greater`                | `operator>`                          | `>`                  |
+| `op_less_equals`            | `operator<=`                         | `<=`                 |
+| `op_greater_equals`         | `operator>=`                         | `>=`                 |
+| `op_spaceship`              | `operator<=>`                        | `<=>`                |
+| `op_ampersand_ampersand`    | `operator&&`                         | `&&`                 |
+| `op_pipe_pipe`              | `operator||`                         | `||`                 |
+| `op_less_less`              | `operator<<`                         | `<<`                 |
+| `op_greater_greater`        | `operator>>`                         | `>>`                 |
+| `op_less_less_equals`       | `operator<<=`                        | `<<=`                |
+| `op_greater_greater_equals` | `operator>>=`                        | `>>=`                |
+| `op_plus_plus`              | `operator++`                         | `++`                 |
+| `op_minus_minus`            | `operator--`                         | `--`                 |
+| `op_comma`                  | `operator,`                          | `,`                  |
+``` cpp
+consteval operators operator_of(info r);
+```
+*Returns:* The value of the enumerator from `operators` whose
+corresponding *operator-function-id* is the unqualified name of the
+entity represented by `r`.
+*Throws:* `meta::exception` unless `r` represents an operator function
+or operator function template.
+``` cpp
+consteval string_view symbol_of(operators op);
+consteval u8string_view u8symbol_of(operators op);
+```
+*Returns:* A `string_view` or `u8string_view` containing the characters
+of the operator symbol name corresponding to `op`, respectively encoded
+with the ordinary literal encoding or with UTF-8.
+*Throws:* `meta::exception` unless the value of `op` corresponds to one
+of the enumerators in `operators`.
+### Reflection names and locations <a id="meta.reflection.names">[[meta.reflection.names]]</a>
+``` cpp
+consteval bool has_identifier(info r);
+```
+*Returns:*
+- If `r` represents an entity that has a typedef name for linkage
+  purposes [[dcl.typedef]], then `true`.
+- Otherwise, if `r` represents an unnamed entity, then `false`.
+- Otherwise, if `r` represents a class type, then
+  `!has_template_arguments(r)`.
+- Otherwise, if `r` represents a function, then `true` if
+  `has_template_arguments(r)` is `false` and the function is not a
+  constructor, destructor, operator function, or conversion function.
+  Otherwise, `false`.
+- Otherwise, if `r` represents a template, then `true` if `r` does not
+  represent a constructor template, operator function template, or
+  conversion function template. Otherwise, `false`.
+- Otherwise, if `r` represents the iᵗʰ parameter of a function F that is
+  an (implicit or explicit) specialization of a templated function T and
+  the iᵗʰ parameter of the instantiated declaration of T whose template
+  arguments are those of F would be instantiated from a pack, then
+  `false`.
+- Otherwise, if `r` represents the parameter P of a function F, then let
+  S be the set of declarations, ignoring any explicit instantiations,
+  that precede some point in the evaluation context and that declare
+  either F or a templated function of which F is a specialization;
+  `true` if
+  - there is a declaration D in S that introduces a name N for either P
+    or the parameter corresponding to P in the templated function that D
+    declares and
+  - no declaration in S does so using any name other than N.
+  Otherwise, `false`.
+  \[*Example 1*:
+      void fun(int);
+      constexpr std::meta::info r = parameters_of(^^fun)[0];
+      static_assert(!has_identifier(r));
+      void fun(int x);
+      static_assert(has_identifier(r));
+      void fun(int x);
+      static_assert(has_identifier(r));
+      void poison() {
+        void fun(int y);
+      }
+      static_assert(!has_identifier(r));
+  — *end example*]
+- Otherwise, if `r` represents a variable, then `false` if the
+  declaration of that variable was instantiated from a function
+  parameter pack. Otherwise, `!has_template_arguments(r)`.
+- Otherwise, if `r` represents a structured binding, then `false` if the
+  declaration of that structured binding was instantiated from a
+  structured binding pack. Otherwise, `true`.
+- Otherwise, if `r` represents a type alias, then
+  `!has_template_arguments(r)`.
+- Otherwise, if `r` represents an enumerator, non-static-data member,
+  namespace, or namespace alias, then `true`.
+- Otherwise, if `r` represents a direct base class relationship, then
+  `has_identifier(type_of(r))`.
+- Otherwise, `r` represents a data member description
+  (T, N, A, W, *NUA*)[[class.mem.general]]; `true` if N is not $\bot$.
+  Otherwise, `false`.
+``` cpp
+consteval string_view identifier_of(info r);
+consteval u8string_view u8identifier_of(info r);
+```
+Let E be UTF-8 for `u8identifier_of`, and otherwise the ordinary literal
+encoding.
+*Returns:* An NTMBS, encoded with E, determined as follows:
+- If `r` represents an entity with a typedef name for linkage purposes,
+  then that name.
+- Otherwise, if `r` represents a literal operator or literal operator
+  template, then the *ud-suffix* of the operator or operator template.
+- Otherwise, if `r` represents the parameter P of a function F, then let
+  S be the set of declarations, ignoring any explicit instantiations,
+  that precede some point in the evaluation context and that declare
+  either F or a templated function of which F is a specialization; the
+  name that was introduced by a declaration in S for the parameter
+  corresponding to P.
+- Otherwise, if `r` represents an entity, then the identifier introduced
+  by the declaration of that entity.
+- Otherwise, if `r` represents a direct base class relationship, then
+  `identifier_of(type_of(r))` or `u8identifier_of(type_of(r))`,
+  respectively.
+- Otherwise, `r` represents a data member description
+  (T, N, A, W, NUA)[[class.mem.general]]; a `string_view` or
+  `u8string_view`, respectively, containing the identifier N.
+*Throws:* `meta::exception` unless `has_identifier(r)` is `true` and the
+identifier that would be returned (see above) is representable by E.
+``` cpp
+consteval string_view display_string_of(info r);
+consteval u8string_view u8display_string_of(info r);
+```
+*Returns:* An *implementation-defined* `string_view` or `u8string_view`,
+respectively.
+*Recommended practice:* Where possible, implementations should return a
+string suitable for identifying the represented construct.
+``` cpp
+consteval source_location source_location_of(info r);
+```
+*Returns:* If `r` represents a value, a type other than a class type or
+an enumeration type, the global namespace, or a data member description,
+then `source_location{}`. Otherwise, an *implementation-defined*
+`source_location` value.
+*Recommended practice:* If `r` represents an entity with a definition
+that is reachable from the evaluation context, a value corresponding to
+a definition should be returned.
+### Reflection queries <a id="meta.reflection.queries">[[meta.reflection.queries]]</a>
+``` cpp
+consteval bool has-type(info r);  // exposition only
+```
+*Returns:* `true` if `r` represents a value, annotation, object,
+variable, function whose type does not contain an undeduced placeholder
+type and that is not a constructor or destructor, enumerator, non-static
+data member, unnamed bit-field, direct base class relationship, data
+member description, or function parameter. Otherwise, `false`.
+``` cpp
+consteval info type_of(info r);
+```
+*Returns:*
+- If `r` represents the iᵗʰ parameter of a function F, then the iᵗʰ type
+  in the parameter-type-list of F[[dcl.fct]].
+- Otherwise, if `r` represents a value, object, variable, function,
+  non-static data member, or unnamed bit-field, then the type of what is
+  represented by `r`.
+- Otherwise, if `r` represents an annotation, then
+  `type_of(constant_of(r))`.
+- Otherwise, if `r` represents an enumerator N of an enumeration E,
+  then:
+  - If E is defined by a declaration D that precedes a point P in the
+    evaluation context and P does not occur within an *enum-specifier*
+    of D, then a reflection of E.
+  - Otherwise, a reflection of the type of N prior to the closing brace
+    of the *enum-specifier* as specified in  [[dcl.enum]].
+- Otherwise, if `r` represents a direct base class relationship (D, B),
+  then a reflection of B.
+- Otherwise, for a data member description
+  (T, N, A, W, *NUA*)[[class.mem.general]], a reflection of the type T.
+*Throws:* `meta::exception` unless *`has-type`*`(r)` is `true`.
+``` cpp
+consteval info object_of(info r);
+```
+*Returns:*
+- If `r` represents an object, then `r`.
+- Otherwise, if `r` represents a reference, then a reflection of the
+  object referred to by that reference.
+- Otherwise, `r` represents a variable; a reflection of the object
+  declared by that variable.
+*Throws:* `meta::exception` unless `r` is a reflection representing
+either
+- an object with static storage duration [[basic.stc.general]], or
+- a variable that either declares or refers to such an object, and if
+  that variable is a reference R, then either
+  - R is usable in constant expressions [[expr.const]], or
+  - the lifetime of R began within the core constant expression
+    currently under evaluation.
+[*Example 1*:
+``` cpp
+int x;
+int& y = x;
+static_assert(^^x != ^^y);                          // OK, r and y are different variables so their
+                                                    // reflections compare different
+static_assert(object_of(^^x) == object_of(^^y));    // OK, because y is a reference
+                                                    // to x, their underlying objects are the same
+```
+— *end example*]
+``` cpp
+consteval info constant_of(info r);
+```
+Let R be a constant expression of type `info` such that R` == r` is
+`true`. If `r` represents an annotation, then let C be its underlying
+constant.
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (is_annotation(R)) {
+  return C;
+} else {
+  return reflect_constant([: R :]);
+}
+```
+*Throws:* `meta::exception` unless either `r` represents an annotation
+or `[: `R` :]` is a valid *splice-expression*[[expr.prim.splice]].
+[*Example 2*:
+``` cpp
+constexpr int x = 0;
+constexpr int y = 0;
+static_assert(^^x != ^^y);                      // OK, x and y are different variables,
+                                                // so their reflections compare different
+static_assert(constant_of(^^x) ==
+              constant_of(^^y));                // OK, both constant_of(\reflexpr{x)} and
+                                                // constant_of(\reflexpr{y)} represent the value 0
+static_assert(constant_of(^^x) ==
+              reflect_constant(0));             // OK, likewise
+struct S { int m; };
+constexpr S s {42};
+static_assert(is_object(constant_of(^^s)) &&
+              is_object(reflect_object(s)));
+static_assert(constant_of(^^s) !=       // OK, template parameter object that is template-argument-
+              reflect_object(s));       // equivalent to s is a different object than s
+static_assert(constant_of(^^s) ==
+              constant_of(reflect_object(s)));  // OK
+consteval info fn() {
+  constexpr int x = 42;
+  return ^^x;
+}
+constexpr info r = constant_of(fn());           // error: x is outside its lifetime
+```
+— *end example*]
+``` cpp
+consteval bool is_public(info r);
+consteval bool is_protected(info r);
+consteval bool is_private(info r);
+```
+*Returns:* `true` if `r` represents either
+- a class member or unnamed bit-field that is public, protected, or
+  private, respectively, or
+- a direct base class relationship (D, B) for which B is, respectively,
+  a public, protected, or private base class of D.
+Otherwise, `false`.
+``` cpp
+consteval bool is_virtual(info r);
+```
+*Returns:* `true` if `r` represents either a virtual member function or
+a direct base class relationship (D, B) for which B is a virtual base
+class of D. Otherwise, `false`.
+``` cpp
+consteval bool is_pure_virtual(info r);
+consteval bool is_override(info r);
+```
+*Returns:* `true` if `r` represents a member function that is pure
+virtual or overrides another member function, respectively. Otherwise,
+`false`.
+``` cpp
+consteval bool is_final(info r);
+```
+*Returns:* `true` if `r` represents a final class or a final member
+function. Otherwise, `false`.
+``` cpp
+consteval bool is_deleted(info r);
+consteval bool is_defaulted(info r);
+```
+*Returns:* `true` if `r` represents a function that is a deleted
+function [[dcl.fct.def.delete]] or defaulted
+function [[dcl.fct.def.default]], respectively. Otherwise, `false`.
+``` cpp
+consteval bool is_user_provided(info r);
+consteval bool is_user_declared(info r);
+```
+*Returns:* `true` if `r` represents a function that is user-provided or
+user-declared [[dcl.fct.def.default]], respectively. Otherwise, `false`.
+``` cpp
+consteval bool is_explicit(info r);
+```
+*Returns:* `true` if `r` represents a member function that is declared
+explicit. Otherwise, `false`.
+[*Note 1*: If `r` represents a member function template that is
+declared explicit, `is_explicit(r)` is still `false` because in general,
+such queries for templates cannot be answered. — *end note*]
+``` cpp
+consteval bool is_noexcept(info r);
+```
+*Returns:* `true` if `r` represents a `noexcept` function type or a
+function with a non-throwing exception specification [[except.spec]].
+Otherwise, `false`.
+[*Note 2*: If `r` represents a function template that is declared
+`noexcept`, `is_noexcept(r)` is still `false` because in general, such
+queries for templates cannot be answered. — *end note*]
+``` cpp
+consteval bool is_bit_field(info r);
+```
+*Returns:* `true` if `r` represents a bit-field, or if `r` represents a
+data member description (T, N, A, W, *NUA*)[[class.mem.general]] for
+which W is not $\bot$. Otherwise, `false`.
+``` cpp
+consteval bool is_enumerator(info r);
+consteval bool is_annotation(info r);
+```
+*Returns:* `true` if `r` represents an enumerator or annotation,
+respectively. Otherwise, `false`.
+``` cpp
+consteval bool is_const(info r);
+consteval bool is_volatile(info r);
+```
+Let T be `type_of(r)` if *`has-type`*`(r)` is `true`. Otherwise, let T
+be `dealias(r)`.
+*Returns:* `true` if `T` represents a const or volatile type,
+respectively, or a const- or volatile-qualified function type,
+respectively. Otherwise, `false`.
+``` cpp
+consteval bool is_mutable_member(info r);
+```
+*Returns:* `true` if `r` represents a `mutable` non-static data member.
+Otherwise, `false`.
+``` cpp
+consteval bool is_lvalue_reference_qualified(info r);
+consteval bool is_rvalue_reference_qualified(info r);
+```
+Let T be `type_of(r)` if *`has-type`*`(r)` is `true`. Otherwise, let T
+be `dealias(r)`.
+*Returns:* `true` if T represents an lvalue- or rvalue-qualified
+function type, respectively. Otherwise, `false`.
+``` cpp
+consteval bool has_static_storage_duration(info r);
+consteval bool has_thread_storage_duration(info r);
+consteval bool has_automatic_storage_duration(info r);
+```
+*Returns:* `true` if `r` represents an object or variable that has
+static, thread, or automatic storage duration,
+respectively [[basic.stc]]. Otherwise, `false`.
+[*Note 3*: It is not possible to have a reflection representing an
+object or variable having dynamic storage duration. — *end note*]
+``` cpp
+consteval bool has_internal_linkage(info r);
+consteval bool has_module_linkage(info r);
+consteval bool has_external_linkage(info r);
+consteval bool has_c_language_linkage(info r);
+consteval bool has_linkage(info r);
+```
+*Returns:* `true` if `r` represents a variable, function, type,
+template, or namespace whose name has internal linkage, module linkage,
+C language linkage, or any linkage, respectively [[basic.link]].
+Otherwise, `false`.
+``` cpp
+consteval bool is_complete_type(info r);
+```
+*Returns:* `true` if `is_type(r)` is `true` and there is some point in
+the evaluation context from which the type represented by `dealias(r)`
+is not an incomplete type [[basic.types]]. Otherwise, `false`.
+``` cpp
+consteval bool is_enumerable_type(info r);
+```
+A type T is *enumerable* from a point P if either
+- T is a class type complete at point P or
+- T is an enumeration type defined by a declaration D such that D is
+  reachable from P but P does not occur within an *enum-specifier* of
+  D[[dcl.enum]].
+*Returns:* `true` if `dealias(r)` represents a type that is enumerable
+from some point in the evaluation context. Otherwise, `false`.
+[*Example 3*:
+``` cpp
+class S;
+enum class E;
+static_assert(!is_enumerable_type(^^S));
+static_assert(!is_enumerable_type(^^E));
+class S {
+  void mfn() {
+    static_assert(is_enumerable_type(^^S));
+  }
+  static_assert(!is_enumerable_type(^^S));
+};
+static_assert(is_enumerable_type(^^S));
+enum class E {
+  A = is_enumerable_type(^^E) ? 1 : 2
+};
+static_assert(is_enumerable_type(^^E));
+static_assert(static_cast<int>(E::A) == 2);
+```
+— *end example*]
+``` cpp
+consteval bool is_variable(info r);
+```
+*Returns:* `true` if `r` represents a variable. Otherwise, `false`.
+``` cpp
+consteval bool is_type(info r);
+consteval bool is_namespace(info r);
+```
+*Returns:* `true` if `r` represents an entity whose underlying entity is
+a type or namespace, respectively. Otherwise, `false`.
+``` cpp
+consteval bool is_type_alias(info r);
+consteval bool is_namespace_alias(info r);
+```
+*Returns:* `true` if `r` represents a type alias or namespace alias,
+respectively. Otherwise, `false`.
+[*Note 4*: A specialization of an alias template is a type
+alias. — *end note*]
+``` cpp
+consteval bool is_function(info r);
+```
+*Returns:* `true` if `r` represents a function. Otherwise, `false`.
+``` cpp
+consteval bool is_conversion_function(info r);
+consteval bool is_operator_function(info r);
+consteval bool is_literal_operator(info r);
+```
+*Returns:* `true` if `r` represents a function that is a conversion
+function [[class.conv.fct]], operator function [[over.oper]], or literal
+operator [[over.literal]], respectively. Otherwise, `false`.
+``` cpp
+consteval bool is_special_member_function(info r);
+consteval bool is_constructor(info r);
+consteval bool is_default_constructor(info r);
+consteval bool is_copy_constructor(info r);
+consteval bool is_move_constructor(info r);
+consteval bool is_assignment(info r);
+consteval bool is_copy_assignment(info r);
+consteval bool is_move_assignment(info r);
+consteval bool is_destructor(info r);
+```
+*Returns:* `true` if `r` represents a function that is a special member
+function [[special]], a constructor, a default constructor, a copy
+constructor, a move constructor, an assignment operator, a copy
+assignment operator, a move assignment operator, or a destructor,
+respectively. Otherwise, `false`.
+``` cpp
+consteval bool is_function_parameter(info r);
+```
+*Returns:* `true` if `r` represents a function parameter. Otherwise,
+`false`.
+``` cpp
+consteval bool is_explicit_object_parameter(info r);
+```
+*Returns:* `true` if `r` represents a function parameter that is an
+explicit object parameter [[dcl.fct]]. Otherwise, `false`.
+``` cpp
+consteval bool has_default_argument(info r);
+```
+*Returns:* If `r` represents a parameter P of a function F, then:
+- If F is a specialization of a templated function T, then `true` if
+  there exists a declaration D of T that precedes some point in the
+  evaluation context and D specifies a default argument for the
+  parameter of T corresponding to P. Otherwise, `false`.
+- Otherwise, if there exists a declaration D of F that precedes some
+  point in the evaluation context and D specifies a default argument for
+  P, then `true`.
+Otherwise, `false`.
+``` cpp
+consteval bool has_ellipsis_parameter(info r);
+```
+*Returns:* `true` if `r` represents a function or function type that has
+an ellipsis in its parameter-type-list [[dcl.fct]]. Otherwise, `false`.
+``` cpp
+consteval bool is_template(info r);
+```
+*Returns:* `true` if `r` represents a function template, class template,
+variable template, alias template, or concept. Otherwise, `false`.
+[*Note 5*: A template specialization is not a template. For example,
+`is_template(``)` is `true` but `is_template(``)` is
+`false`. — *end note*]
+``` cpp
+consteval bool is_function_template(info r);
+consteval bool is_variable_template(info r);
+consteval bool is_class_template(info r);
+consteval bool is_alias_template(info r);
+consteval bool is_conversion_function_template(info r);
+consteval bool is_operator_function_template(info r);
+consteval bool is_literal_operator_template(info r);
+consteval bool is_constructor_template(info r);
+consteval bool is_concept(info r);
+```
+*Returns:* `true` if `r` represents a function template, variable
+template, class template, alias template, conversion function template,
+operator function template, literal operator template, constructor
+template, or concept, respectively. Otherwise, `false`.
+``` cpp
+consteval bool is_value(info r);
+consteval bool is_object(info r);
+```
+*Returns:* `true` if `r` represents a value or object, respectively.
+Otherwise, `false`.
+``` cpp
+consteval bool is_structured_binding(info r);
+```
+*Returns:* `true` if `r` represents a structured binding. Otherwise,
+`false`.
+``` cpp
+consteval bool is_class_member(info r);
+consteval bool is_namespace_member(info r);
+consteval bool is_nonstatic_data_member(info r);
+consteval bool is_static_member(info r);
+consteval bool is_base(info r);
+```
+*Returns:* `true` if `r` represents a class member, namespace member,
+non-static data member, static member, or direct base class
+relationship, respectively. Otherwise, `false`.
+``` cpp
+consteval bool has_default_member_initializer(info r);
+```
+*Returns:* `true` if `r` represents a non-static data member that has a
+default member initializer. Otherwise, `false`.
+``` cpp
+consteval bool has_parent(info r);
+```
+*Returns:*
+- If `r` represents the global namespace, then `false`.
+- Otherwise, if `r` represents an entity that has C language
+  linkage [[dcl.link]], then `false`.
+- Otherwise, if `r` represents an entity that has a language linkage
+  other than C++ language linkage, then an *implementation-defined*
+  value.
+- Otherwise, if `r` represents a type that is neither a class nor
+  enumeration type, then `false`.
+- Otherwise, if `r` represents an entity or direct base class
+  relationship, then `true`.
+- Otherwise, `false`.
+``` cpp
+consteval info parent_of(info r);
+```
+*Returns:*
+- If `r` represents a non-static data member that is a direct member of
+  an anonymous union, or an unnamed bit-field declared within the
+  *member-specification* of such a union, then a reflection representing
+  the innermost enclosing anonymous union.
+- Otherwise, if `r` represents an enumerator, then a reflection
+  representing the corresponding enumeration type.
+- Otherwise, if `r` represents a direct base class relationship (D, B),
+  then a reflection representing D.
+- Otherwise, let E be a class, function, or namespace whose class scope,
+  function parameter scope, or namespace scope, respectively, is the
+  innermost such scope that either is, or encloses, the target scope of
+  a declaration of what is represented by `r`.
+  - If E is the function call operator of a closure type for a
+    *consteval-block-declaration*[[dcl.pre]], then
+    `parent_of(parent_of(``))`. \[*Note 1*: In this case, the first
+    `parent_of` will be the closure type, so the second `parent_of` is
+    necessary to give the parent of that closure type. — *end note*]
+  - Otherwise, .
+*Throws:* `meta::exception` unless `has_parent(r)` is `true`.
+[*Example 4*:
+``` cpp
+struct I { };
+struct F : I {
+  union {
+    int o;
+  };
+  enum N {
+    A
+  };
+};
+constexpr auto ctx = std::meta::access_context::current();
+static_assert(parent_of(^^F) == ^^::);
+static_assert(parent_of(bases_of(^^F, ctx)[0]) == ^^F);
+static_assert(is_union_type(parent_of(^^F::o)));
+static_assert(parent_of(^^F::N) == ^^F);
+static_assert(parent_of(^^F::A) == ^^F::N);
+```
+— *end example*]
+``` cpp
+consteval info dealias(info r);
+```
+*Returns:* A reflection representing the underlying entity of what `r`
+represents.
+*Throws:* `meta::exception` unless `r` represents an entity.
+[*Example 5*:
+``` cpp
+using X = int;
+using Y = X;
+static_assert(dealias(^^int) == ^^int);
+static_assert(dealias(^^X) == ^^int);
+static_assert(dealias(^^Y) == ^^int);
+```
+— *end example*]
+``` cpp
+consteval bool has_template_arguments(info r);
+```
+*Returns:* `true` if `r` represents a specialization of a function
+template, variable template, class template, or an alias template.
+Otherwise, `false`.
+``` cpp
+consteval info template_of(info r);
+```
+*Returns:* A reflection of the template of the specialization
+represented by `r`.
+*Throws:* `meta::exception` unless `has_template_arguments(r)` is
+`true`.
+``` cpp
+consteval vector<info> template_arguments_of(info r);
+```
+*Returns:* A `vector` containing reflections of the template arguments
+of the template specialization represented by `r`, in the order in which
+they appear in the corresponding template argument list. For a given
+template argument A, its corresponding reflection R is determined as
+follows:
+- If A denotes a type or type alias, then R is a reflection representing
+  the underlying entity of A. \[*Note 2*: R always represents a type,
+  never a type alias. — *end note*]
+- Otherwise, if A denotes a class template, variable template, concept,
+  or alias template, then R is a reflection representing A.
+- Otherwise, A is a constant template argument [[temp.arg.nontype]]. Let
+  P be the corresponding template parameter.
+  - If P has reference type, then R is a reflection representing the
+    object or function referred to by A.
+  - Otherwise, if P has class type, then R represents the corresponding
+    template parameter object.
+  - Otherwise, R is a reflection representing the value of A.
+*Throws:* `meta::exception` unless `has_template_arguments(r)` is
+`true`.
+[*Example 6*:
+``` cpp
+template<class T, class U = T> struct Pair { };
+template<class T> struct Pair<char, T> { };
+template<class T> using PairPtr = Pair<T*>;
+static_assert(template_of(^^Pair<int>) == ^^Pair);
+static_assert(template_of(^^Pair<char, char>) == ^^Pair);
+static_assert(template_arguments_of(^^Pair<int>).size() == 2);
+static_assert(template_arguments_of(^^Pair<int>)[0] == ^^int);
+static_assert(template_of(^^PairPtr<int>) == ^^PairPtr);
+static_assert(template_arguments_of(^^PairPtr<int>).size() == 1);
+struct S { };
+int i;
+template<int, int&, S, template<class> class>
+  struct X { };
+constexpr auto T = ^^X<1, i, S{}, PairPtr>;
+static_assert(is_value(template_arguments_of(T)[0]));
+static_assert(is_object(template_arguments_of(T)[1]));
+static_assert(is_object(template_arguments_of(T)[2]));
+static_assert(template_arguments_of(T)[3] == ^^PairPtr);
+```
+— *end example*]
+``` cpp
+consteval vector<info> parameters_of(info r);
+```
+*Returns:*
+- If `r` represents a function F, then a `vector` containing reflections
+  of the parameters of F, in the order in which they appear in a
+  declaration of F.
+- Otherwise, `r` represents a function type T; a `vector` containing
+  reflections of the types in parameter-type-list [[dcl.fct]] of T, in
+  the order in which they appear in the parameter-type-list.
+*Throws:* `meta::exception` unless `r` represents a function or a
+function type.
+``` cpp
+consteval info variable_of(info r);
+```
+*Returns:* The reflection of the parameter variable corresponding to
+`r`.
+*Throws:* `meta::exception` unless
+- `r` represents a parameter of a function F and
+- there is a point P in the evaluation context for which the innermost
+  non-block scope enclosing P is the function parameter
+  scope [[basic.scope.param]] associated with F.
+``` cpp
+consteval info return_type_of(info r);
+```
+*Returns:* The reflection of the return type of the function or function
+type represented by `r`.
+*Throws:* `meta::exception` unless either `r` represents a function and
+*`has-type`*`(r)` is `true` or `r` represents a function type.
+### Access control context <a id="meta.reflection.access.context">[[meta.reflection.access.context]]</a>
+The `access_context` class is a non-aggregate type that represents a
+namespace, class, or function from which queries pertaining to access
+rules may be performed, as well as the designating class
+[[class.access.base]], if any.
+An `access_context` has an associated scope and designating class.
+``` cpp
+namespace std::meta {
+  struct access_context {
+    access_context() = delete;
+    consteval info scope() const;
+    consteval info designating_class() const;
+    static consteval access_context current() noexcept;
+    static consteval access_context unprivileged() noexcept;
+    static consteval access_context unchecked() noexcept;
+    consteval access_context via(info cls) const;
+  };
+}
+```
+`access_context` is a structural type. Two values `ac1` and `ac2` of
+type `access_context` are template-argument-equivalent [[temp.type]] if
+`ac1.scope()` and `ac2.scope()` are template-argument-equivalent and
+`ac1.designating_class()` and `ac2.designating_class()` are
+template-argument-equivalent.
+``` cpp
+consteval info scope() const;
+consteval info designating_class() const;
+```
+*Returns:* The `access_context`’s associated scope and designating
+class, respectively.
+``` cpp
+static consteval access_context current() noexcept;
+```
+Given a program point P, let *`eval-point`*`(`P`)` be the following
+program point:
+- If a potentially-evaluated subexpression [[intro.execution]] of a
+  default member initializer I for a member of class
+  C[[class.mem.general]] appears at P, then a point determined as
+  follows:
+  - If an aggregate initialization is using I, *`eval-point`*`(`Q`)`,
+    where Q is the point at which that aggregate initialization appears.
+  - Otherwise, if an initialization by an inherited
+    constructor [[class.inhctor.init]] is using I, a point whose
+    immediate scope is the class scope corresponding to C.
+  - Otherwise, a point whose immediate scope is the function parameter
+    scope corresponding to the constructor definition that is using I.
+- Otherwise, if a potentially-evaluated subexpression of a default
+  argument [[dcl.fct.default]] appears at P, *`eval-point`*`(`Q`)`,
+  where Q is the point at which the invocation of the
+  function [[expr.call]] using that default argument appears.
+- Otherwise, if the immediate scope of P is a function parameter scope
+  introduced by a declaration D, and P appears either before the locus
+  of D or within the trailing *requires-clause* of D, a point whose
+  immediate scope is the innermost scope enclosing the locus of D that
+  is not a template parameter scope.
+- Otherwise, if the immediate scope of P is a function parameter scope
+  introduced by a *lambda-expression* L whose *lambda-introducer*
+  appears at point Q, and P appears either within the
+  *trailing-return-type* or the trailing *requires-clause* of L,
+  *`eval-point`*`(`Q`)`.
+- Otherwise, if the innermost non-block scope enclosing P is the
+  function parameter scope introduced by a
+  *consteval-block-declaration*[[dcl.pre]], a point whose immediate
+  scope is that inhabited by the outermost *consteval-block-declaration*
+  D containing P such that each scope (if any) that intervenes between P
+  and the function parameter scope introduced by D is either
+  - a block scope or
+  - a function parameter scope or lambda scope introduced by a
+    *consteval-block-declaration*.
+- Otherwise, P.
+Given a scope S, let *`ctx-scope`*`(`S`)` be the following scope:
+- If S is a class scope or namespace scope, S.
+- Otherwise, if S is a function parameter scope introduced by the
+  declaration of a function, S.
+- Otherwise, if S is a lambda scope introduced by a *lambda-expression*
+  L, the function parameter scope corresponding to the call operator of
+  the closure type of L.
+- Otherwise, *`ctx-scope`*`(`S'`)`, where S' is the parent scope of S.
+*Returns:* An `access_context` whose designating class is the null
+reflection and whose scope represents the function, class, or namespace
+whose corresponding function parameter scope, class scope, or namespace
+scope, respectively, is *`ctx-scope`*`(`S`)`, where S is the immediate
+scope of *`eval-point`*`(`P`)` and P is the point at which the
+invocation of `current` lexically appears.
+*Remarks:* `current` is not an addressable function [[namespace.std]].
+An invocation of `current` that appears at a program point P is
+value-dependent [[temp.dep.constexpr]] if *`eval-point`*`(`P`)` is
+enclosed by a scope corresponding to a templated entity.
+[*Example 1*:
+``` cpp
+struct A {
+  int a = 0;
+  consteval A(int p) : a(p) {}
+};
+struct B : A {
+  using A::A;
+  consteval B(int p, int q) : A(p * q) {}
+  info s = access_context::current().scope();
+};
+struct C : B { using B::B; };
+struct Agg {
+  consteval bool eq(info rhs = access_context::current().scope()) {
+    return s == rhs;
+  }
+  info s = access_context::current().scope();
+};
+namespace NS {
+  static_assert(Agg{}.s == access_context::current().scope());              // OK
+  static_assert(Agg{}.eq());                                                // OK
+  static_assert(B(1).s == ^^B);                                             // OK
+  static_assert(is_constructor(B{1, 2}.s) && parent_of(B{1, 2}.s) == ^^B);  // OK
+  static_assert(is_constructor(C{1, 2}.s) && parent_of(C{1, 2}.s) == ^^B);  // OK
+  auto fn() -> [:is_namespace(access_context::current().scope()) ? ^^int : ^^bool:];
+  static_assert(type_of(^^fn) == ^^auto()->int);                            // OK
+  template<auto R>
+    struct TCls {
+      consteval bool fn()
+        requires (is_type(access_context::current().scope())) {
+          return true;                  // OK, scope is TCls<R>.
+        }
+    };
+  static_assert(TCls<0>{}.fn());        // OK
+}
+```
+— *end example*]
+``` cpp
+static consteval access_context unprivileged() noexcept;
+```
+*Returns:* An `access_context` whose designating class is the null
+reflection and whose scope is the global namespace.
+``` cpp
+static consteval access_context unchecked() noexcept;
+```
+*Returns:* An `access_context` whose designating class and scope are
+both the null reflection.
+``` cpp
+consteval access_context via(info cls) const;
+```
+*Returns:* An `access_context` whose scope is `this->scope()` and whose
+designating class is `cls`.
+*Throws:* `meta::exception` unless `cls` is either the null reflection
+or a reflection of a complete class type.
+### Member accessibility queries <a id="meta.reflection.access.queries">[[meta.reflection.access.queries]]</a>
+``` cpp
+consteval bool is_accessible(info r, access_context ctx);
+```
+Let *`PARENT-CLS`*`(r)` be:
+- If `parent_of(r)` represents a class C, then C.
+- Otherwise, *`PARENT-CLS`*`(parent_of(r))`.
+Let *`DESIGNATING-CLS`*`(r, ctx)` be:
+- If `ctx.designating_class()` represents a class C, then C.
+- Otherwise, *`PARENT-CLS`*`(r)`.
+*Returns:*
+- If `r` represents an unnamed bit-field F, then
+  `is_accessible(``r_H``, ctx)`, where `r_H` represents a hypothetical
+  non-static data member of the class represented by *`PARENT-CLS`*`(r)`
+  with the same access as F. \[*Note 1*: Unnamed bit-fields are treated
+  as class members for the purpose of `is_accessible`. — *end note*]
+- Otherwise, if `r` does not represent a class member or a direct base
+  class relationship, then `true`.
+- Otherwise, if `r` represents
+  - a class member that is not a (possibly indirect or variant) member
+    of *`DESIGNATING-CLS`*`(r, ctx)` or
+  - a direct base class relationship such that `parent_of(r)` does not
+    represent *`DESIGNATING-CLS`*`(r, ctx)` or a (direct or indirect)
+    base class thereof,
+  then `false`.
+- Otherwise, if `ctx.scope()` is the null reflection, then `true`.
+- Otherwise, letting P be a program point whose immediate scope is the
+  function parameter scope, class scope, or namespace scope
+  corresponding to the function, class, or namespace represented by
+  `ctx.scope()`:
+  - If `r` represents a direct base class relationship (D, B), then
+    `true` if base class B of *`DESIGNATING-CLS`*`(r, ctx)` is
+    accessible at P[[class.access.base]]; otherwise `false`.
+  - Otherwise, `r` represents a class member M; `true` if M would be
+    accessible at P with the designating class [[class.access.base]] as
+    *`DESIGNATING-CLS`*`(r, ctx)` if the effect of any
+    *using-declaration*s [[namespace.udecl]] were ignored. Otherwise,
+    `false`.
+[*Note 1*: The definitions of when a class member or base class is
+accessible from a point P do not consider whether a declaration of that
+entity is reachable from P. — *end note*]
+*Throws:* `meta::exception` if
+- `r` represents a class member for which *`PARENT-CLS`*`(r)` is an
+  incomplete class or
+- `r` represents a direct base class relationship (D, B) for which D is
+  incomplete.
+[*Example 1*:
+``` cpp
+consteval access_context fn() {
+  return access_context::current();
+}
+class Cls {
+  int mem;
+  friend consteval access_context fn();
+public:
+  static constexpr auto r = ^^mem;
+};
+static_assert(is_accessible(Cls::r, fn()));                             // OK
+static_assert(!is_accessible(Cls::r, access_context::current()));       // OK
+static_assert(is_accessible(Cls::r, access_context::unchecked()));      // OK
+```
+— *end example*]
+``` cpp
+consteval bool has_inaccessible_nonstatic_data_members(info r, access_context ctx);
+```
+*Returns:* `true` if `is_accessible(`R`, ctx)` is `false` for any R in
+`nonstatic_data_members_of(r, access_context::unchecked())`. Otherwise,
+`false`.
+*Throws:* `meta::exception` unless
+- `nonstatic_data_members_of(r, access_context::unchecked())` is a
+  constant subexpression and
+- `r` does not represent a closure type.
+``` cpp
+consteval bool has_inaccessible_bases(info r, access_context ctx);
+```
+*Returns:* `true` if `is_accessible(`R`, ctx)` is `false` for any R in
+`bases_of(r, access_context::unchecked())`. Otherwise, `false`.
+*Throws:* `meta::exception` unless
+`bases_of(r, access_context::unchecked())` is a constant subexpression.
+``` cpp
+consteval bool has_inaccessible_subobjects(info r, access_context ctx);
+```
+*Effects:* Equivalent to:
+``` cpp
+return has_inaccessible_bases(r, ctx) || has_inaccessible_nonstatic_data_members(r, ctx);
+```
+### Reflection member queries <a id="meta.reflection.member.queries">[[meta.reflection.member.queries]]</a>
+``` cpp
+consteval vector<info> members_of(info r, access_context ctx);
+```
+A declaration D *members-of-precedes* a point P if D precedes either P
+or the point immediately following the *class-specifier* of the
+outermost class for which P is in a complete-class context.
+A declaration D of a member M of a class or namespace Q is
+*Q-members-of-eligible* if
+- the host scope of D[[basic.scope.scope]] is the class scope or
+  namespace scope associated with Q,
+- D is not a friend declaration,
+- M is not a closure type [[expr.prim.lambda.closure]],
+- M is not a specialization of a template [[temp.pre]],
+- if Q is a class that is not a closure type, then M is a direct member
+  of Q[[class.mem.general]] that is not a variant member of a nested
+  anonymous union of Q[[class.union.anon]], and
+- if Q is a closure type, then M is a function call operator or function
+  call operator template.
+It is *implementation-defined* whether declarations of other members of
+a closure type Q are Q-members-of-eligible.
+A member M of a class or namespace Q is *Q-members-of-representable*
+from a point P if a Q-members-of-eligible declaration of M
+members-of-precedes P, and M is
+- a class or enumeration type,
+- a type alias,
+- a class template, function template, variable template, alias
+  template, or concept,
+- a variable or reference V for which the type of V does not contain an
+  undeduced placeholder type,
+- a function F for which
+  - the type of F does not contain an undeduced placeholder type,
+  - the constraints (if any) of F are satisfied, and
+  - if F is a prospective destructor, F is the selected
+    destructor [[class.dtor]],
+- a non-static data member,
+- a namespace, or
+- a namespace alias.
+[*Note 1*: Examples of direct members that are not
+Q-members-of-representable for any entity Q include: unscoped
+enumerators [[enum]], partial specializations of
+templates [[temp.spec.partial]], and closure
+types [[expr.prim.lambda.closure]]. — *end note*]
+*Returns:* A `vector` containing reflections of all members M of the
+entity Q represented by `dealias(r)` for which
+- M is Q-members-of-representable from some point in the evaluation
+  context and
+- `is_accessible(``, ctx)` is `true`.
+If `dealias(r)` represents a class C, then the `vector` also contains
+reflections representing all unnamed bit-fields B whose declarations
+inhabit the class scope corresponding to C for which
+`is_accessible(``, ctx)` is `true`. Reflections of class members and
+unnamed bit-fields that are declared appear in the order in which they
+are declared.
+[*Note 2*: Base classes are not members. Implicitly-declared special
+members appear after any user-declared
+members [[special]]. — *end note*]
+*Throws:* `meta::exception` unless `dealias(r)` is a reflection
+representing either a class type that is complete from some point in the
+evaluation context or a namespace.
+[*Example 1*:
+``` cpp
+// TU1
+export module M;
+namespace NS {
+  export int m;
+  static int l;
+}
+static_assert(members_of(^^NS, access_context::current()).size() == 2);
+// TU2
+import M;
+static_assert(                                                  // NS::l does not precede
+  members_of(^^NS, access_context::current()).size() == 1);     // the constant-expression [basic.lookup]
+class B {};
+struct S : B {
+private:
+  class I;
+public:
+  int m;
+};
+static_assert(                                                  // 6 special members,
+  members_of(^^S, access_context::current()).size() == 7);      // 1 public member,
+                                                                // does not include base
+static_assert(                                                  // all of the above,
+  members_of(^^S, access_context::unchecked()).size() == 8);    // as well as a reflection
+                                                                // representing S::I
+```
+— *end example*]
+``` cpp
+consteval vector<info> bases_of(info type, access_context ctx);
+```
+*Returns:* Let C be the class represented by `dealias(type)`. A `vector`
+containing the reflections of all the direct base class relationships B,
+if any, of C such that `is_accessible(``, ctx)` is `true`. The direct
+base class relationships appear in the order in which the corresponding
+base classes appear in the *base-specifier-list* of C.
+*Throws:* `meta::exception` unless `dealias(type)` represents a class
+type that is complete from some point in the evaluation context.
+``` cpp
+consteval vector<info> static_data_members_of(info type, access_context ctx);
+```
+*Returns:* A `vector` containing each element `e` of
+`members_of(type, ctx)` such that `is_variable(e)` is `true`, preserving
+their order.
+*Throws:* `meta::exception` unless `dealias(type)` represents a class
+type that is complete from some point in the evaluation context.
+``` cpp
+consteval vector<info> nonstatic_data_members_of(info type, access_context ctx);
+```
+*Returns:* A `vector` containing each element `e` of
+`members_of(type, ctx)` such that `is_nonstatic_data_member(e)` is
+`true`, preserving their order.
+*Throws:* `meta::exception` unless `dealias(type)` represents a class
+type that is complete from some point in the evaluation context.
+``` cpp
+consteval vector<info> subobjects_of(info type, access_context ctx);
+```
+*Returns:* A `vector` containing each element of `bases_of(type, ctx)`
+followed by each element of `nonstatic_data_members_of(type, ctx)`,
+preserving their order.
+*Throws:* `meta::exception` unless `dealias(type)` represents a class
+type that is complete from some point in the evaluation context.
+``` cpp
+consteval vector<info> enumerators_of(info type_enum);
+```
+*Returns:* A `vector` containing the reflections of each enumerator of
+the enumeration represented by `dealias(type_enum)`, in the order in
+which they are declared.
+*Throws:* `meta::exception` unless `dealias(type_enum)` represents an
+enumeration type, and `is_enumerable_type(type_enum)` is `true`.
+### Reflection layout queries <a id="meta.reflection.layout">[[meta.reflection.layout]]</a>
+``` cpp
+struct member_offset {
+  ptrdiff_t bytes;
+  ptrdiff_t bits;
+  constexpr ptrdiff_t total_bits() const;
+  auto operator<=>(const member_offset&) const = default;
+};
+constexpr ptrdiff_t member_offset::total_bits() const;
+```
+*Returns:* `bytes * CHAR_BIT + bits`.
+``` cpp
+consteval member_offset offset_of(info r);
+```
+Let V be the offset in bits from the beginning of a complete object of
+the type represented by `parent_of(r)` to the subobject associated with
+the construct represented by `r`.
+*Returns:* `{`V` / CHAR_BIT, `V` % CHAR_BIT}`.
+*Throws:* `meta::exception` unless `r` represents a non-static data
+member, unnamed bit-field, or direct base class relationship (D, B) for
+which either B is not a virtual base class or D is not an abstract
+class.
+``` cpp
+consteval size_t size_of(info r);
+```
+*Returns:* If
+- `r` represents a non-static data member of type T or a data member
+  description (T, N, A, W, *NUA*) or
+- `dealias(r)` represents a type T,
+then `sizeof(`T`)` if T is not a reference type and
+`size_of(add_pointer(``))` otherwise. Otherwise, `size_of(type_of(r))`.
+[*Note 1*: It is possible that while `sizeof(char) == size_of(``)` is
+`true`, that `sizeof(char&) == size_of(``&)` is `false`. If `b`
+represents a direct base class relationship of an empty base class, then
+`size_of(b) > 0` is `true`. — *end note*]
+*Throws:* `meta::exception` unless all of the following conditions are
+met:
+- `dealias(r)` is a reflection of a type, object, value, variable of
+  non-reference type, non-static data member that is not a bit-field,
+  direct base class relationship, or data member description
+  (T, N, A, W, *NUA*)[[class.mem.general]] where W is $\bot$.
+- If `dealias(r)` represents a type, then `is_complete_type(r)` is
+  `true`.
+``` cpp
+consteval size_t alignment_of(info r);
+```
+*Returns:*
+- If `dealias(r)` represents a type T, then
+  `alignment_of(add_pointer(r))` if T is a reference type and the
+  alignment requirement of T otherwise.
+- Otherwise, if `dealias(r)` represents a variable or object, then the
+  alignment requirement of the variable or object.
+- Otherwise, if `r` represents a direct base class relationship, then
+  `alignment_of(type_of(r))`.
+- Otherwise, if `r` represents a non-static data member M of a class C,
+  then the alignment of the direct member subobject corresponding to M
+  of a complete object of type C.
+- Otherwise, `r` represents a data member description
+  (T, N, A, W, *NUA*)[[class.mem.general]]. If A is not $\bot$, then the
+  value A. Otherwise, `alignment_of(``)`.
+*Throws:* `meta::exception` unless all of the following conditions are
+met:
+- `dealias(r)` is a reflection of a type, object, variable of
+  non-reference type, non-static data member that is not a bit-field,
+  direct base class relationship, or data member description.
+- If `dealias(r)` represents a type, then `is_complete_type(r)` is
+  `true`.
+``` cpp
+consteval size_t bit_size_of(info r);
+```
+*Returns:*
+- If `r` represents an unnamed bit-field or a non-static data member
+  that is a bit-field with width W, then W.
+- Otherwise, if `r` represents a data member description
+  (T, N, A, W, *NUA*)[[class.mem.general]] and W is not $\bot$, then W.
+- Otherwise, `CHAR_BIT * size_of(r)`.
+*Throws:* `meta::exception` unless all of the following conditions are
+met:
+- `dealias(r)` is a reflection of a type, object, value, variable of
+  non-reference type, non-static data member, unnamed bit-field, direct
+  base class relationship, or data member description.
+- If `dealias(r)` represents a type, then `is_complete_type(r)` is
+  `true`.
+### Annotation reflection <a id="meta.reflection.annotation">[[meta.reflection.annotation]]</a>
+``` cpp
+consteval vector<info> annotations_of(info item);
+```
+Let E be
+- the corresponding *base-specifier* if `item` represents a direct base
+  class relationship,
+- otherwise, the entity represented by `item`.
+*Returns:* A `vector` containing all of the reflections R representing
+each annotation applying to each declaration of E that precedes either
+some point in the evaluation context [[expr.const]] or a point
+immediately following the *class-specifier* of the outermost class for
+which such a point is in a complete-class context. For any two
+reflections R₁ and R₂ in the returned `vector`, if the annotation
+represented by R₁ precedes the annotation represented by R₂, then R₁
+appears before R₂. If R₁ and R₂ represent annotations from the same
+translation unit T, any element in the returned `vector` between R₁ and
+R₂ represents an annotation from T.
+[*Note 1*: The order in which two annotations appear is otherwise
+unspecified. — *end note*]
+*Throws:* `meta::exception` unless `item` represents a type, type alias,
+variable, function, namespace, enumerator, direct base class
+relationship, or non-static data member.
+[*Example 1*:
+``` cpp
+[[=1]] void f();
+[[=2, =3]] void g();
+void g [[=4]] ();
+static_assert(annotations_of(^^f).size() == 1);
+static_assert(annotations_of(^^g).size() == 3);
+static_assert([: constant_of(annotations_of(^^g)[0]) :] == 2);
+static_assert(extract<int>(annotations_of(^^g)[1]) == 3);
+static_assert(extract<int>(annotations_of(^^g)[2]) == 4);
+struct Option { bool value; };
+struct C {
+  [[=Option{true}]] int a;
+  [[=Option{false}]] int b;
+};
+static_assert(extract<Option>(annotations_of(^^C::a)[0]).value);
+static_assert(!extract<Option>(annotations_of(^^C::b)[0]).value);
+template<class T>
+  struct [[=42]] D { };
+constexpr std::meta::info a1 = annotations_of(^^D<int>)[0];
+constexpr std::meta::info a2 = annotations_of(^^D<char>)[0];
+static_assert(a1 != a2);
+static_assert(constant_of(a1) == constant_of(a2));
+[[=1]] int x, y;
+static_assert(annotations_of(^^x)[0] == annotations_of(^^y)[0]);
+```
+— *end example*]
+``` cpp
+consteval vector<info> annotations_of_with_type(info item, info type);
+```
+*Returns:* A `vector` containing each element `e` of
+`annotations_of(item)` where
+``` cpp
+remove_const(type_of(e)) == remove_const(type)
+```
+is `true`, preserving their order.
+*Throws:* `meta::exception` unless
+- `annotations_of(item)` is a constant expression and
+- `dealias(type)` represents a type and `is_complete_type(type)` is
+  `true`.
+### Value extraction <a id="meta.reflection.extract">[[meta.reflection.extract]]</a>
+The `extract` function template may be used to extract a value out of a
+reflection when its type is known.
+The following are defined for exposition only to aid in the
+specification of `extract`.
+``` cpp
+template<class T>
+  consteval T extract-ref(info r);      // exposition only
+```
+[*Note 1*: `T` is a reference type. — *end note*]
+*Returns:* If `r` represents an object O, then a reference to O.
+Otherwise, a reference to the object declared, or referred to, by the
+variable represented by `r`.
+*Throws:* `meta::exception` unless
+- `r` represents a variable or object of type `U`,
+- `is_convertible_v<remove_reference_t<U>(*)[], remove_reference_t<T>(*)[]>`
+  is `true`, and \[*Note 1*: The intent is to allow only qualification
+  conversion from `U` to `T`. — *end note*]
+- If `r` represents a variable, then either that variable is usable in
+  constant expressions or its lifetime began within the core constant
+  expression currently under evaluation.
+``` cpp
+template<class T>
+  consteval T extract-member-or-function(info r);       // exposition only
+```
+*Returns:*
+- If `T` is a pointer type, then a pointer value pointing to the
+  function represented by `r`.
+- Otherwise, a pointer-to-member value designating the non-static data
+  member or function represented by `r`.
+*Throws:* `meta::exception` unless
+- `r` represents a non-static data member with type `X`, that is not a
+  bit-field, that is a direct member of class `C`, `T` and `X C::*` are
+  similar types [[conv.qual]], and `is_convertible_v<X C::*, T>` is
+  `true`;
+- `r` represents an implicit object member function with type `F` or
+  `F noexcept` that is a direct member of a class `C`, and `T` is
+  `F C::*`; or
+- `r` represents a non-member function, static member function, or
+  explicit object member function of function type `F` or `F noexcept`,
+  and `T` is `F*`.
+``` cpp
+template<class T>
+  consteval T extract-value(info r);    // exposition only
+```
+Let `U` be the type of the value or object that `r` represents.
+*Returns:* `static_cast<T>([:`R`:])`, where R is a constant expression
+of type `info` such that R` == r` is `true`.
+*Throws:* `meta::exception` unless
+- `U` is a pointer type, `T` and `U` are either similar [[conv.qual]] or
+  both function pointer types, and `is_convertible_v<U, T>` is `true`,
+- `U` is not a pointer type and the cv-unqualified types of `T` and `U`
+  are the same,
+- `U` is an array type, `T` is a pointer type, and the value `r`
+  represents is convertible to `T`, or
+- `U` is a closure type, `T` is a function pointer type, and the value
+  that `r` represents is convertible to `T`.
+``` cpp
+template<class T>
+  consteval T extract(info r);
+```
+Let `U` be `remove_cv_t<T>`.
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (is_reference_type(^^T)) {
+  return extract-ref<T>(r);
+} else if (is_nonstatic_data_member(r) || is_function(r)) {
+  return extract-member-or-function<U>(r);
+} else {
+  return extract-value<U>(constant_of(r));
+}
+```
+### Reflection substitution <a id="meta.reflection.substitute">[[meta.reflection.substitute]]</a>
+``` cpp
+template<class R>
+concept reflection_range =
+  ranges::input_range<R> &&
+  same_as<ranges::range_value_t<R>, info> &&
+  same_as<remove_cvref_t<ranges::range_reference_t<R>>, info>;
+template<reflection_range R = initializer_list<info>>
+  consteval bool can_substitute(info templ, R&& arguments);
+```
+Let `Z` be the template represented by `templ` and let `Args...` be a
+sequence of prvalue constant expressions that compute the reflections
+held by the elements of `arguments`, in order.
+*Returns:* `true` if `Z<[:Args:]...>` is a valid
+*template-id*[[temp.names]] that does not name a function whose type
+contains an undeduced placeholder type. Otherwise, `false`.
+*Throws:* `meta::exception` unless `templ` represents a template, and
+every reflection in `arguments` represents a construct usable as a
+template argument [[temp.arg]].
+[*Note 1*: If forming `Z<[:Args:]...>` leads to a failure outside of
+the immediate context, the program is ill-formed. — *end note*]
+``` cpp
+template<reflection_range R = initializer_list<info>>
+  consteval info substitute(info templ, R&& arguments);
+```
+Let `Z` be the template represented by `templ` and let `Args...` be a
+sequence of prvalue constant expressions that compute the reflections
+held by the elements of `arguments`, in order.
+*Returns:* .
+*Throws:* `meta::exception` unless `can_substitute(templ, arguments)` is
+`true`.
+[*Note 2*: If forming `Z<[:Args:]...>` leads to a failure outside of
+the immediate context, the program is ill-formed. — *end note*]
+[*Example 1*:
+``` cpp
+template<class T>
+  auto fn1();
+static_assert(!can_substitute(^^fn1, {^^int}));         // OK
+constexpr info r1 = substitute(^^fn1, {^^int});         // error: fn1<int> contains an undeduced
+                                                        // placeholder type for its return type
+template<class T>
+  auto fn2() {
+    static_assert(^^T != ^^int);    // static assertion failed during instantiation of fn2<int>
+    return 0;
+  }
+constexpr bool r2 = can_substitute(^^fn2, {^^int});     // error: instantiation of body of fn2<int>
+                                                        // is needed to deduce return type
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+consteval info to_integral_constant(unsigned i) {
+  return substitute(^^integral_constant, {^^unsigned, reflect_constant(i)});
+}
+constexpr info r = to_integral_constant(2);     // OK, r represents the type
+                                                // integral_constant<unsigned, 2>
+```
+— *end example*]
+### Expression result reflection <a id="meta.reflection.result">[[meta.reflection.result]]</a>
+``` cpp
+template<class T>
+  consteval info reflect_constant(T expr);
+```
+*Mandates:* `is_copy_constructible_v<T>` is `true` and `T` is a
+cv-unqualified structural type [[temp.param]] that is not a reference
+type.
+Let V be:
+- if `T` is a class type, then an object that is
+  template-argument-equivalent to the value of `expr`;
+- otherwise, the value of `expr`.
+Let `TCls` be the invented template:
+``` cpp
+template<T P> struct TCls;
+```
+*Returns:* `template_arguments_of(``)[0]`.
+[*Note 1*: This is a reflection of an object for class types, and a
+reflection of a value otherwise. — *end note*]
+*Throws:* `meta::exception` unless the *template-id* `TCls<`V`>` would
+be valid.
+[*Example 1*:
+``` cpp
+template<auto D>
+  struct A { };
+struct N { int x; };
+struct K { char const* p; };
+constexpr info r1 = reflect_constant(42);
+static_assert(is_value(r1));
+static_assert(r1 == template_arguments_of(^^A<42>)[0]);
+constexpr info r2 = reflect_constant(N{42});
+static_assert(is_object(r2));
+static_assert(r2 == template_arguments_of(^^A<N{42}>)[0]);
+constexpr info r3 = reflect_constant(K{nullptr});   // OK
+constexpr info r4 = reflect_constant(K{"ebab"});    // error: constituent pointer
+                                                    // points to string literal
+```
+— *end example*]
+``` cpp
+template<class T>
+  consteval info reflect_object(T& expr);
+```
+*Mandates:* `T` is an object type.
+*Returns:* A reflection of the object designated by `expr`.
+*Throws:* `meta::exception` unless `expr` is suitable for use as a
+constant template argument for a constant template parameter of type
+`T&` [[temp.arg.nontype]].
+``` cpp
+template<class T>
+  consteval info reflect_function(T& fn);
+```
+*Mandates:* `T` is a function type.
+*Returns:* A reflection of the function designated by `fn`.
+*Throws:* `meta::exception` unless `fn` is suitable for use as a
+constant template argument for a constant template parameter of type
+`T&` [[temp.arg.nontype]].
+### Reflection class definition generation <a id="meta.reflection.define.aggregate">[[meta.reflection.define.aggregate]]</a>
+``` cpp
+namespace std::meta {
+  struct data_member_options {
+    struct name-type {                          // exposition only
+      template<class T>
+        requires constructible_from<u8string, T>
+        consteval name-type(T&&);
+      template<class T>
+        requires constructible_from<string, T>
+        consteval name-type(T&&);
+    private:
+      variant<u8string, string> contents;       // exposition only
+    };
+    optional<name-type> name;
+    optional<int> alignment;
+    optional<int> bit_width;
+    bool no_unique_address = false;
+  };
+}
+```
+The classes `data_member_options` and `data_member_options::name-type`
+are consteval-only types [[basic.types.general]], and are not structural
+types [[temp.param]].
+``` cpp
+template<class T>
+  requires constructible_from<u8string, T>
+  consteval name-type(T&& value);
+```
+*Effects:* Initializes *contents* with
+`u8string(std::forward<T>(value))`.
+``` cpp
+template<class T>
+  requires constructible_from<string, T>
+  consteval name-type(T&& value);
+```
+*Effects:* Initializes *contents* with `string(std::forward<T>(value))`.
+[*Note 1*:
+The class *name-type* allows the function `data_member_spec` to accept
+an ordinary string literal (or `string_view`, `string`, etc.) or a UTF-8
+string literal (or `u8string_view`, `u8string`, etc.) equally well.
+[*Example 1*:
+    consteval void fn() {
+      data_member_options o1 = {.name = "ordinary_literal_encoding"};
+      data_member_options o2 = {.name = u8"utf8_encoding"};
+    }
+— *end example*]
+— *end note*]
+``` cpp
+consteval info data_member_spec(info type, data_member_options options);
+```
+*Returns:* A reflection of a data member description
+(T, N, A, W, *NUA*)[[class.mem.general]] where
+- T is the type represented by `dealias(type)`,
+- N is either the identifier encoded by `options.name` or $\bot$ if
+  `options.name` does not contain a value,
+- A is either the alignment value held by `options.alignment` or $\bot$
+  if `options.alignment` does not contain a value,
+- W is either the value held by `options.bit_width` or $\bot$ if
+  `options.bit_width` does not contain a value, and
+- *NUA* is the value held by `options.no_unique_address`.
+[*Note 2*: The returned reflection value is primarily useful in
+conjunction with `define_aggregate`; it can also be queried by certain
+other functions in `std::meta` (e.g., `type_of`,
+`identifier_of`). — *end note*]
+*Throws:* `meta::exception` unless the following conditions are met:
+- `dealias(type)` represents either an object type or a reference type;
+- if `options.name` contains a value, then:
+  - `holds_alternative<u8string>(options.name->`*`contents`*`)` is
+    `true` and `get<u8string>(options.name->`*`contents`*`)` contains a
+    valid identifier [[lex.name]] that is not a keyword [[lex.key]] when
+    interpreted with UTF-8, or
+  - `holds_alternative<string>(options.name->`*`contents`*`)` is `true`
+    and `get<string>(options.name->`*`contents`*`)` contains a valid
+    identifier [[lex.name]] that is not a keyword [[lex.key]] when
+    interpreted with the ordinary literal encoding;
+  \[*Note 1*: The name corresponds to the spelling of an
+  identifier token after phase 6 of translation [[lex.phases]].
+  Lexical constructs like
+  *universal-character-name*s [[lex.universal.char]] are not
+  processed and will cause evaluation to fail. For example,
+  `R"(\u03B1)"` is an invalid identifier and is not interpreted as
+  `"`α`"`. — *end note*]
+- if `options.name` does not contain a value, then `options.bit_width`
+  contains a value;
+- if `options.bit_width` contains a value V, then
+  - `is_integral_type(type) || is_enum_type(type)` is `true`,
+  - `options.alignment` does not contain a value,
+  - `options.no_unique_address` is `false`, and
+  - if V equals `0`, then `options.name` does not contain a value; and
+- if `options.alignment` contains a value, it is an alignment
+  value [[basic.align]] not less than `alignment_of(type)`.
+``` cpp
+consteval bool is_data_member_spec(info r);
+```
+*Returns:* `true` if `r` represents a data member description.
+Otherwise, `false`.
+``` cpp
+template<reflection_range R = initializer_list<info>>
+  consteval info define_aggregate(info class_type, R&& mdescrs);
+```
+Let C be the class represented by `class_type` and $r_K$ be the Kᵗʰ
+reflection value in `mdescrs`. For every $r_K$ in `mdescrs`, let
+$(T_K, N_K, A_K, W_K, *NUA*_K)$ be the corresponding data member
+description represented by $r_K$.
+- C is incomplete from every point in the evaluation context;
+  \[*Note 2*: C can be a class template specialization for which there
+  is a reachable definition of the class template. In this case, the
+  injected declaration is an explicit specialization. — *end note*]
+- `is_data_member_spec(`$r_K$`)` is `true` for every $r_K$;
+- `is_complete_type(`$T_K$`)` is `true` for every $r_K$; and
+- for every pair $(r_K, r_L)$ where K < L, if $N_K$ is not $\bot$ and
+  $N_L$ is not $\bot$, then either:
+  - $N_K$` != `$N_L$ is `true` or
+  - $N_K$` == u8"_"` is `true`. \[*Note 3*: Every provided identifier is
+    unique or `"_"`. — *end note*]
+*Effects:* Produces an injected declaration D[[expr.const]] that defines
+C and has properties as follows:
+- The target scope of D is the scope to which C
+  belongs [[basic.scope.scope]].
+- The locus of D follows immediately after the core constant expression
+  currently under evaluation.
+- The characteristic sequence of D[[expr.const]] is the sequence of
+  reflection values $r_K$.
+- If C is a specialization of a templated class T, and C is not a local
+  class, then D is an explicit specialization of T.
+- For each $r_K$, there is a corresponding entity $M_K$ belonging to the
+  class scope of D with the following properties:
+  - If $N_K$ is $\bot$, $M_K$ is an unnamed bit-field. Otherwise, $M_K$
+    is a non-static data member whose name is the identifier determined
+    by the character sequence encoded by $N_K$ in UTF-8.
+  - The type of $M_K$ is $T_K$.
+  - $M_K$ is declared with the attribute `[[no_unique_address]]` if and
+    only if *NUA*_K is `true`.
+  - If $W_K$ is not $\bot$, $M_K$ is a bit-field whose width is that
+    value. Otherwise, $M_K$ is not a bit-field.
+  - If $A_K$ is not $\bot$, $M_K$ has the *alignment-specifier*
+    `alignas(`$A_K$`)`. Otherwise, $M_K$ has no *alignment-specifier*.
+- For every $r_L$ in `mdescrs` such that K < L, the declaration
+  corresponding to $r_K$ precedes the declaration corresponding to
+  $r_L$.
+*Returns:* `class_type`.
+### Reflection type traits <a id="meta.reflection.traits">[[meta.reflection.traits]]</a>
+This subclause specifies `consteval` functions to query the properties
+of types [[meta.unary]], query the relationships between types
+[[meta.rel]], or transform types [[meta.trans]], during program
+translation. Each `consteval` function declared in this class has an
+associated class template declared elsewhere in this document.
+Every function and function template declared in this subclause throws
+an exception of type `meta::exception` unless the following conditions
+are met:
+- For every parameter `p` of type `info`, `is_type(p)` is `true`.
+- For every parameter `r` whose type is constrained on
+  `reflection_range`, `ranges::{}all_of({}r, is_type)` is `true`.
+``` cpp
+// associated with [meta.unary.cat], primary type categories
+consteval bool is_void_type(info type);
+consteval bool is_null_pointer_type(info type);
+consteval bool is_integral_type(info type);
+consteval bool is_floating_point_type(info type);
+consteval bool is_array_type(info type);
+consteval bool is_pointer_type(info type);
+consteval bool is_lvalue_reference_type(info type);
+consteval bool is_rvalue_reference_type(info type);
+consteval bool is_member_object_pointer_type(info type);
+consteval bool is_member_function_pointer_type(info type);
+consteval bool is_enum_type(info type);
+consteval bool is_union_type(info type);
+consteval bool is_class_type(info type);
+consteval bool is_function_type(info type);
+consteval bool is_reflection_type(info type);
+// associated with [meta.unary.comp], composite type categories
+consteval bool is_reference_type(info type);
+consteval bool is_arithmetic_type(info type);
+consteval bool is_fundamental_type(info type);
+consteval bool is_object_type(info type);
+consteval bool is_scalar_type(info type);
+consteval bool is_compound_type(info type);
+consteval bool is_member_pointer_type(info type);
+// associated with [meta.unary.prop], type properties
+consteval bool is_const_type(info type);
+consteval bool is_volatile_type(info type);
+consteval bool is_trivially_copyable_type(info type);
+consteval bool is_trivially_relocatable_type(info type);
+consteval bool is_replaceable_type(info type);
+consteval bool is_standard_layout_type(info type);
+consteval bool is_empty_type(info type);
+consteval bool is_polymorphic_type(info type);
+consteval bool is_abstract_type(info type);
+consteval bool is_final_type(info type);
+consteval bool is_aggregate_type(info type);
+consteval bool is_consteval_only_type(info type);
+consteval bool is_signed_type(info type);
+consteval bool is_unsigned_type(info type);
+consteval bool is_bounded_array_type(info type);
+consteval bool is_unbounded_array_type(info type);
+consteval bool is_scoped_enum_type(info type);
+template<reflection_range R = initializer_list<info>>
+  consteval bool is_constructible_type(info type, R&& type_args);
+consteval bool is_default_constructible_type(info type);
+consteval bool is_copy_constructible_type(info type);
+consteval bool is_move_constructible_type(info type);
+consteval bool is_assignable_type(info type_dst, info type_src);
+consteval bool is_copy_assignable_type(info type);
+consteval bool is_move_assignable_type(info type);
+consteval bool is_swappable_with_type(info type1, info type2);
+consteval bool is_swappable_type(info type);
+consteval bool is_destructible_type(info type);
+template<reflection_range R = initializer_list<info>>
+  consteval bool is_trivially_constructible_type(info type, R&& type_args);
+consteval bool is_trivially_default_constructible_type(info type);
+consteval bool is_trivially_copy_constructible_type(info type);
+consteval bool is_trivially_move_constructible_type(info type);
+consteval bool is_trivially_assignable_type(info type_dst, info type_src);
+consteval bool is_trivially_copy_assignable_type(info type);
+consteval bool is_trivially_move_assignable_type(info type);
+consteval bool is_trivially_destructible_type(info type);
+template<reflection_range R = initializer_list<info>>
+  consteval bool is_nothrow_constructible_type(info type, R&& type_args);
+consteval bool is_nothrow_default_constructible_type(info type);
+consteval bool is_nothrow_copy_constructible_type(info type);
+consteval bool is_nothrow_move_constructible_type(info type);
+consteval bool is_nothrow_assignable_type(info type_dst, info type_src);
+consteval bool is_nothrow_copy_assignable_type(info type);
+consteval bool is_nothrow_move_assignable_type(info type);
+consteval bool is_nothrow_swappable_with_type(info type1, info type2);
+consteval bool is_nothrow_swappable_type(info type);
+consteval bool is_nothrow_destructible_type(info type);
+consteval bool is_nothrow_relocatable_type(info type);
+consteval bool is_implicit_lifetime_type(info type);
+consteval bool has_virtual_destructor(info type);
+consteval bool has_unique_object_representations(info type);
+consteval bool reference_constructs_from_temporary(info type_dst, info type_src);
+consteval bool reference_converts_from_temporary(info type_dst, info type_src);
+// associated with [meta.rel], type relations
+consteval bool is_same_type(info type1, info type2);
+consteval bool is_base_of_type(info type_base, info type_derived);
+consteval bool is_virtual_base_of_type(info type_base, info type_derived);
+consteval bool is_convertible_type(info type_src, info type_dst);
+consteval bool is_nothrow_convertible_type(info type_src, info type_dst);
+consteval bool is_layout_compatible_type(info type1, info type2);
+consteval bool is_pointer_interconvertible_base_of_type(info type_base, info type_derived);
+template<reflection_range R = initializer_list<info>>
+  consteval bool is_invocable_type(info type, R&& type_args);
+template<reflection_range R = initializer_list<info>>
+  consteval bool is_invocable_r_type(info type_result, info type, R&& type_args);
+template<reflection_range R = initializer_list<info>>
+  consteval bool is_nothrow_invocable_type(info type, R&& type_args);
+template<reflection_range R = initializer_list<info>>
+  consteval bool is_nothrow_invocable_r_type(info type_result, info type, R&& type_args);
+// associated with [meta.trans.cv], const-volatile modifications
+consteval info remove_const(info type);
+consteval info remove_volatile(info type);
+consteval info remove_cv(info type);
+consteval info add_const(info type);
+consteval info add_volatile(info type);
+consteval info add_cv(info type);
+// associated with [meta.trans.ref], reference modifications
+consteval info remove_reference(info type);
+consteval info add_lvalue_reference(info type);
+consteval info add_rvalue_reference(info type);
+// associated with [meta.trans.sign], sign modifications
+consteval info make_signed(info type);
+consteval info make_unsigned(info type);
+// associated with [meta.trans.arr], array modifications
+consteval info remove_extent(info type);
+consteval info remove_all_extents(info type);
+// associated with [meta.trans.ptr], pointer modifications
+consteval info remove_pointer(info type);
+consteval info add_pointer(info type);
+// associated with [meta.trans.other], other transformations
+consteval info remove_cvref(info type);
+consteval info decay(info type);
+template<reflection_range R = initializer_list<info>>
+  consteval info common_type(R&& type_args);
+template<reflection_range R = initializer_list<info>>
+  consteval info common_reference(R&& type_args);
+consteval info underlying_type(info type);
+template<reflection_range R = initializer_list<info>>
+  consteval info invoke_result(info type, R&& type_args);
+consteval info unwrap_reference(info type);
+consteval info unwrap_ref_decay(info type);
+```
+Each function or function template declared above has the following
+behavior based on the signature and return type of that function or
+function template.
+[*Note 1*: The associated class template need not be
+instantiated. — *end note*]
+[*Note 2*: For those functions or function templates which return a
+reflection, that reflection always represents a type and never a type
+alias. — *end note*]
+[*Note 3*: If `t` is a reflection of the type `int` and `u` is a
+reflection of an alias to the type `int`, then `t == u` is `false` but
+`is_same_type(t, u)` is `true`. Also, `t == dealias(u)` is
+`true`. — *end note*]
+``` cpp
+consteval size_t rank(info type);
+```
+*Returns:* `rank_v<`T`>`, where T is the type represented by
+`dealias(type)`.
+``` cpp
+consteval size_t extent(info type, unsigned i = 0);
+```
+*Returns:* `extent_v<`T`, `I`>`, where T is the type represented by
+`dealias(type)` and I is a constant equal to `i`.
+``` cpp
+consteval size_t tuple_size(info type);
+```
+*Returns:* `tuple_size_v<`T`>`, where T is the type represented by
+`dealias(type)`.
+``` cpp
+consteval info tuple_element(size_t index, info type);
+```
+*Returns:* A reflection representing the type denoted by
+`tuple_element_t<`I`, `T`>`, where T is the type represented by
+`dealias(type)` and I is a constant equal to `index`.
+``` cpp
+consteval size_t variant_size(info type);
+```
+*Returns:* `variant_size_v<`T`>`, where T is the type represented by
+`dealias(type)`.
+``` cpp
+consteval info variant_alternative(size_t index, info type);
+```
+*Returns:* A reflection representing the type denoted by
+`variant_alternative_t<`I`, `T`>`, where T is the type represented by
+`dealias(type)` and I is a constant equal to `index`.
+``` cpp
+consteval strong_ordering type_order(info t1, info t2);
+```
+*Returns:* `type_order_v<`T₁`, `T₂`>`, where T₁ and T₂ are the types
+represented by `dealias(t1)` and `dealias(t2)`, respectively.

Diff to HTML by rtfpessoa