[PATCH 4/9] c++: C++26 Reflection [PR120775]
Jonathan Wakely
jwakely@redhat.com
Sat Nov 15 08:47:10 GMT 2025
On Fri, 14 Nov 2025 at 19:37 -0500, Marek Polacek wrote:
>This contains the libstdc++ bits (including <meta>).
Excliting! A few small changes requested below ...
>-- >8 --
>diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
>index ae7a7ca9073..5fff459a779 100644
>--- a/libstdc++-v3/include/Makefile.am
>+++ b/libstdc++-v3/include/Makefile.am
>@@ -89,6 +89,7 @@ std_headers = \
> ${std_srcdir}/locale \
> ${std_srcdir}/map \
> ${std_srcdir}/memory_resource \
>+ ${std_srcdir}/meta \
> ${std_srcdir}/mutex \
> ${std_srcdir}/ostream \
> ${std_srcdir}/print \
>diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
>index f07e2326816..d364d046267 100644
>--- a/libstdc++-v3/include/Makefile.in
>+++ b/libstdc++-v3/include/Makefile.in
>@@ -448,6 +448,7 @@ std_freestanding = \
> @GLIBCXX_HOSTED_TRUE@ ${std_srcdir}/locale \
> @GLIBCXX_HOSTED_TRUE@ ${std_srcdir}/map \
> @GLIBCXX_HOSTED_TRUE@ ${std_srcdir}/memory_resource \
>+@GLIBCXX_HOSTED_TRUE@ ${std_srcdir}/meta \
> @GLIBCXX_HOSTED_TRUE@ ${std_srcdir}/mutex \
> @GLIBCXX_HOSTED_TRUE@ ${std_srcdir}/ostream \
> @GLIBCXX_HOSTED_TRUE@ ${std_srcdir}/print \
>diff --git a/libstdc++-v3/include/bits/iterator_concepts.h b/libstdc++-v3/include/bits/iterator_concepts.h
>index fd91b22d75a..61cf3c510c3 100644
>--- a/libstdc++-v3/include/bits/iterator_concepts.h
>+++ b/libstdc++-v3/include/bits/iterator_concepts.h
>@@ -1008,7 +1008,7 @@ namespace ranges
> // for use by __range_iter_t below.
> template<typename _Tp>
> requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&>
>- auto
>+ constexpr auto
> __begin(_Tp& __t)
> {
> if constexpr (is_array_v<_Tp>)
>diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def
>index 29ecf15c7e3..c59dc09c6d8 100644
>--- a/libstdc++-v3/include/bits/version.def
>+++ b/libstdc++-v3/include/bits/version.def
>@@ -2191,6 +2191,15 @@ ftms = {
> };
> };
>
>+ftms = {
>+ name = reflection;
>+ values = {
>+ v = 202506;
>+ cxxmin = 26;
>+ extra_cond = "__cpp_impl_reflection >= 202506L";
>+ };
>+};
>+
> ftms = {
> name = is_implicit_lifetime;
> values = {
>diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h
>index 5901d27113d..b947ee3c953 100644
>--- a/libstdc++-v3/include/bits/version.h
>+++ b/libstdc++-v3/include/bits/version.h
>@@ -2465,4 +2465,14 @@
> #endif /* !defined(__cpp_lib_is_implicit_lifetime) */
> #undef __glibcxx_want_is_implicit_lifetime
>
>+#if !defined(__cpp_lib_reflection)
>+# if (__cplusplus > 202302L) && (__cpp_impl_reflection >= 202506L)
>+# define __glibcxx_reflection 202506L
>+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_reflection)
>+# define __cpp_lib_reflection 202506L
>+# endif
>+# endif
>+#endif /* !defined(__cpp_lib_reflection) */
>+#undef __glibcxx_want_reflection
>+
> #undef __glibcxx_want_all
>diff --git a/libstdc++-v3/include/precompiled/stdc++.h b/libstdc++-v3/include/precompiled/stdc++.h
>index 54baed43a5e..30de85d8c37 100644
>--- a/libstdc++-v3/include/precompiled/stdc++.h
>+++ b/libstdc++-v3/include/precompiled/stdc++.h
>@@ -234,6 +234,7 @@
> #if __cplusplus > 202302L
> #include <debugging>
> #include <inplace_vector>
>+#include <meta>
> #include <text_encoding>
> #include <stdbit.h>
> #include <stdckdint.h>
>diff --git a/libstdc++-v3/include/std/meta b/libstdc++-v3/include/std/meta
>new file mode 100644
>index 00000000000..13c79358bc9
>--- /dev/null
>+++ b/libstdc++-v3/include/std/meta
>@@ -0,0 +1,651 @@
>+// <meta> -*- C++ -*-
>+
>+// Copyright (C) 2025 Free Software Foundation, Inc.
>+//
>+// This file is part of the GNU ISO C++ Library. This library is free
>+// software; you can redistribute it and/or modify it under the
>+// terms of the GNU General Public License as published by the
>+// Free Software Foundation; either version 3, or (at your option)
>+// any later version.
>+
>+// This library is distributed in the hope that it will be useful,
>+// but WITHOUT ANY WARRANTY; without even the implied warranty of
>+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>+// GNU General Public License for more details.
>+
>+// Under Section 7 of GPL version 3, you are granted additional
>+// permissions described in the GCC Runtime Library Exception, version
>+// 3.1, as published by the Free Software Foundation.
>+
>+// You should have received a copy of the GNU General Public License and
>+// a copy of the GCC Runtime Library Exception along with this program;
>+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
>+// <http://www.gnu.org/licenses/>.
>+
>+/** @file include/meta
>+ * This is a Standard C++ Library header.
>+ */
>+
>+#ifndef _GLIBCXX_META
>+#define _GLIBCXX_META 1
>+
>+#ifdef _GLIBCXX_SYSHDR
>+#pragma GCC system_header
>+#endif
>+
>+#include <array>
>+#include <initializer_list>
>+#include <optional>
>+#include <source_location>
>+#include <span>
>+#include <string>
>+#include <string_view>
>+#include <vector>
We could move all these headers after the #if below, so that we don't
include anything if this is going to be an empty file. I don't think
we're consistent about how we do that elsewhere though, so it's not
important to change now.
>+
>+#define __glibcxx_want_reflection
>+#include <bits/version.h>
>+
>+#if __glibcxx_reflection >= 202506L // C++ >= 26 && __cpp_impl_reflection
>+
>+namespace std _GLIBCXX_VISIBILITY(default)
>+{
>+_GLIBCXX_BEGIN_NAMESPACE_VERSION
>+
>+#if __has_builtin(__builtin_is_string_literal)
>+ // [meta.string.literal], checking string literals
>+ consteval bool is_string_literal(const char* __p)
>+ {
>+ return __builtin_is_string_literal(__p);
>+ }
>+
>+ consteval bool is_string_literal(const wchar_t* __p)
>+ {
>+ return __builtin_is_string_literal(__p);
>+ }
>+
>+#ifdef _GLIBCXX_USE_CHAR8_T
>+ consteval bool is_string_literal(const char8_t* __p)
>+ {
>+ return __builtin_is_string_literal(__p);
>+ }
>+#endif
>+
>+ consteval bool is_string_literal(const char16_t* __p)
>+ {
>+ return __builtin_is_string_literal(__p);
>+ }
>+
>+ consteval bool is_string_literal(const char32_t* __p)
>+ {
>+ return __builtin_is_string_literal(__p);
>+ }
>+#endif
>+
>+ namespace meta
>+ {
>+ using info = decltype(^^int);
>+
>+ // [meta.reflection.exception], class exception
>+ class exception : public std::exception {
>+ private:
>+ string _M_what;
>+ u8string _M_u8what;
>+ info _M_from;
>+ source_location _M_where;
>+
>+ public:
>+ consteval exception(u8string_view __what, info __from,
Please put a newline before 'exception'
consteval
exception(u8string_view __what, info __from,
>+ source_location __where
>+ = source_location::current()) noexcept
>+ : _M_what{_S_exception_cvt_from_utf8(__what)}, _M_u8what{__what},
>+ _M_from{__from}, _M_where{__where} {}
>+
>+ consteval exception(string_view __what, info __from,
Ditto
>+ source_location __where
>+ = source_location::current()) noexcept
>+ : _M_what{__what}, _M_u8what{_S_exception_cvt_to_utf8(__what)},
>+ _M_from{__from}, _M_where{__where} {}
>+
>+ exception(const exception&) = default;
>+ exception(exception&&) = default;
>+
>+ exception& operator=(const exception&) = default;
>+ exception& operator=(exception&&) = default;
>+
>+ consteval const char *what() const noexcept override
>+ {
>+ // If u8string is not empty and string is empty, conversion
>+ // from UTF-8 to ordinary literal encoding failed.
>+ // In that case what() should be non-constant.
>+ if (_M_what.size() == 0 && _M_u8what.size() != 0)
>+ asm("");
>+ return _M_what.c_str();
>+ }
>+ consteval u8string_view u8what() const noexcept { return _M_u8what; }
>+ consteval info from() const noexcept { return _M_from; }
>+ consteval source_location where() const noexcept { return _M_where; }
>+ private:
>+ // Helper special template metafunctions to convert from UTF-8 to
>+ // ordinary literal encoding and vice versa. On conversion failure
>+ // they just return an empty {,u8}string_view.
>+ template<ranges::input_range _R>
We need to avoid single letter names of the form _[A-Z] like _R
because they clash with ctype macros on some C libraries, so it should
be _Rg everywhere that you've used _R.
>+ static consteval u8string_view _S_exception_cvt_to_utf8(_R&&);
>+ template<ranges::input_range _R>
>+ static consteval string_view _S_exception_cvt_from_utf8(_R&&);
>+ };
>+
>+ // [meta.reflection.operators], operator representations
>+ enum class operators {
>+ op_new = 1,
>+ op_delete,
>+ op_array_new,
>+ op_array_delete,
>+ op_co_await,
>+ op_parentheses,
>+ op_square_brackets,
>+ op_arrow,
>+ op_arrow_star,
>+ op_tilde,
>+ op_exclamation,
>+ op_plus,
>+ op_minus,
>+ op_star,
>+ op_slash,
>+ op_percent,
>+ op_caret,
>+ op_ampersand,
>+ op_equals,
>+ op_pipe,
>+ op_plus_equals,
>+ op_minus_equals,
>+ op_star_equals,
>+ op_slash_equals,
>+ op_percent_equals,
>+ op_caret_equals,
>+ op_ampersand_equals,
>+ op_pipe_equals,
>+ op_equals_equals,
>+ op_exclamation_equals,
>+ op_less,
>+ op_greater,
>+ op_less_equals,
>+ op_greater_equals,
>+ op_spaceship,
>+ op_ampersand_ampersand,
>+ op_pipe_pipe,
>+ op_less_less,
>+ op_greater_greater,
>+ op_less_less_equals,
>+ op_greater_greater_equals,
>+ op_plus_plus,
>+ op_minus_minus,
>+ op_comma
>+ };
>+ using enum operators;
>+ consteval operators operator_of(info);
>+ consteval string_view symbol_of(operators);
>+ consteval u8string_view u8symbol_of(operators);
>+
>+ // [meta.reflection.names], reflection names and locations
>+ consteval bool has_identifier(info);
>+
>+ consteval string_view identifier_of(info);
>+ consteval u8string_view u8identifier_of(info);
>+
>+ consteval string_view display_string_of(info);
>+ consteval u8string_view u8display_string_of(info);
>+
>+ consteval source_location source_location_of(info);
>+
>+ // [meta.reflection.queries], reflection queries
>+ consteval info type_of(info);
>+ consteval info object_of(info);
>+ consteval info constant_of(info);
>+
>+ consteval bool is_public(info);
>+ consteval bool is_protected(info);
>+ consteval bool is_private(info);
>+
>+ consteval bool is_virtual(info);
>+ consteval bool is_pure_virtual(info);
>+ consteval bool is_override(info);
>+ consteval bool is_final(info);
>+
>+ consteval bool is_deleted(info);
>+ consteval bool is_defaulted(info);
>+ consteval bool is_user_provided(info);
>+ consteval bool is_user_declared(info);
>+ consteval bool is_explicit(info);
>+ consteval bool is_noexcept(info);
>+
>+ consteval bool is_bit_field(info);
>+ consteval bool is_enumerator(info);
>+ consteval bool is_annotation(info);
>+
>+ consteval bool is_const(info);
>+ consteval bool is_volatile(info);
>+ consteval bool is_mutable_member(info);
>+ consteval bool is_lvalue_reference_qualified(info);
>+ consteval bool is_rvalue_reference_qualified(info);
>+
>+ consteval bool has_static_storage_duration(info);
>+ consteval bool has_thread_storage_duration(info);
>+ consteval bool has_automatic_storage_duration(info);
>+
>+ consteval bool has_internal_linkage(info);
>+ consteval bool has_module_linkage(info);
>+ consteval bool has_external_linkage(info);
>+ consteval bool has_c_language_linkage(info);
>+ consteval bool has_linkage(info);
>+
>+ consteval bool is_complete_type(info);
>+ consteval bool is_enumerable_type(info);
>+
>+ consteval bool is_variable(info);
>+ consteval bool is_type(info);
>+ consteval bool is_namespace(info);
>+ consteval bool is_type_alias(info);
>+ consteval bool is_namespace_alias(info);
>+
>+ consteval bool is_function(info);
>+ consteval bool is_conversion_function(info);
>+ consteval bool is_operator_function(info);
>+ consteval bool is_literal_operator(info);
>+ consteval bool is_special_member_function(info);
>+ consteval bool is_constructor(info);
>+ consteval bool is_default_constructor(info);
>+ consteval bool is_copy_constructor(info);
>+ consteval bool is_move_constructor(info);
>+ consteval bool is_assignment(info);
>+ consteval bool is_copy_assignment(info);
>+ consteval bool is_move_assignment(info);
>+ consteval bool is_destructor(info);
>+
>+ consteval bool is_function_parameter(info);
>+ consteval bool is_explicit_object_parameter(info);
>+ consteval bool has_default_argument(info);
>+ consteval bool has_ellipsis_parameter(info);
>+
>+ consteval bool is_template(info);
>+ consteval bool is_function_template(info);
>+ consteval bool is_variable_template(info);
>+ consteval bool is_class_template(info);
>+ consteval bool is_alias_template(info);
>+ consteval bool is_conversion_function_template(info);
>+ consteval bool is_operator_function_template(info);
>+ consteval bool is_literal_operator_template(info);
>+ consteval bool is_constructor_template(info);
>+ consteval bool is_concept(info);
>+
>+ consteval bool is_value(info);
>+ consteval bool is_object(info);
>+
>+ consteval bool is_structured_binding(info);
>+
>+ consteval bool is_class_member(info);
>+ consteval bool is_namespace_member(info);
>+ consteval bool is_nonstatic_data_member(info);
>+ consteval bool is_static_member(info);
>+ consteval bool is_base(info);
>+
>+ consteval bool has_default_member_initializer(info);
>+
>+ consteval bool has_parent(info);
>+ consteval info parent_of(info);
>+
>+ consteval info dealias(info);
>+
>+ consteval bool has_template_arguments(info);
>+ consteval info template_of(info);
>+ consteval vector<info> template_arguments_of(info);
>+ consteval vector<info> parameters_of(info);
>+ consteval info variable_of(info);
>+ consteval info return_type_of(info);
>+
>+ // [meta.reflection.access.context], access control context
>+ struct access_context {
>+ private:
>+ consteval access_context(info __scope, info __designating_class) noexcept
>+ : _M_scope{__scope}, _M_designating_class{__designating_class} { }
>+ public:
>+ access_context() = delete;
>+ consteval access_context(const access_context &) = default;
>+ consteval access_context(access_context &&) = default;
>+
>+ consteval info scope() const { return _M_scope; }
>+ consteval info designating_class() const { return _M_designating_class; }
>+
>+ static consteval access_context current() noexcept;
>+ static consteval access_context unprivileged() noexcept
>+ { return access_context { ^^::, info {} }; }
>+ static consteval access_context unchecked() noexcept
>+ { return access_context { info {}, info {} }; }
>+ consteval access_context via(info) const;
>+
>+ info _M_scope;
>+ info _M_designating_class;
>+ };
>+
>+ // [meta.reflection.access.queries], member accessibility queries
>+ consteval bool is_accessible(info, access_context);
>+ consteval bool has_inaccessible_nonstatic_data_members(info,
>+ access_context);
>+ consteval bool has_inaccessible_bases(info, access_context);
>+ consteval bool has_inaccessible_subobjects(info, access_context);
>+
>+ // [meta.reflection.member.queries], reflection member queries
>+ consteval vector<info> members_of(info, access_context);
>+ consteval vector<info> bases_of(info, access_context);
>+ consteval vector<info> static_data_members_of(info, access_context);
>+ consteval vector<info> nonstatic_data_members_of(info, access_context);
>+ consteval vector<info> subobjects_of(info, access_context);
>+ consteval vector<info> enumerators_of(info);
>+
>+ // [meta.reflection.layout], reflection layout queries
>+ struct member_offset {
>+ ptrdiff_t bytes;
>+ ptrdiff_t bits;
>+
>+ constexpr ptrdiff_t
>+ total_bits() const
>+ { return bytes * __CHAR_BIT__ + bits; }
>+
>+ auto operator<=>(const member_offset&) const = default;
>+ };
>+
>+ consteval member_offset offset_of(info);
>+ consteval size_t size_of(info);
>+ consteval size_t alignment_of(info);
>+ consteval size_t bit_size_of(info);
>+
>+ // [meta.reflection.extract], value extraction
>+ template<class _Tp>
>+ consteval _Tp extract(info);
>+
>+ // [meta.reflection.substitute], reflection substitution
>+ 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, _R&&);
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval info substitute(info, _R&&);
>+
>+ // [meta.reflection.result], expression result reflection
>+ template<typename _Tp>
>+ requires (is_copy_constructible_v<_Tp>)
>+ consteval info reflect_constant(_Tp);
>+ template<typename _Tp>
>+ requires (!is_function_v<remove_reference_t<_Tp>>)
>+ consteval info reflect_object(_Tp&);
>+ template<typename _Tp>
>+ requires (is_function_v<remove_reference_t<_Tp>>)
>+ consteval info reflect_function(_Tp&);
>+
>+ // [meta.reflection.array], promoting to static storage arrays
>+ template<ranges::input_range _R>
>+ consteval info reflect_constant_string(_R&&);
>+
>+ template<ranges::input_range _R>
>+ consteval info reflect_constant_array(_R&&);
>+
>+ // [meta.reflection.define.aggregate], class definition generation
>+ struct data_member_options {
>+ struct _Name {
>+ template<class _Tp>
>+ requires constructible_from<u8string, _Tp>
>+ consteval _Name(_Tp&& __n) : _M_is_u8(true), _M_u8s((_Tp&&) __n) {}
>+
>+ template<class _Tp>
>+ requires constructible_from<string, _Tp>
>+ consteval _Name(_Tp&& __n) : _M_is_u8(false), _M_s((_Tp&&) __n) {}
>+
>+ private:
>+ bool _M_is_u8;
>+ u8string _M_u8s;
>+ string _M_s;
>+ info _M_unused = {};
>+ };
>+
>+ optional<_Name> name;
>+ optional<int> alignment;
>+ optional<int> bit_width;
>+ bool no_unique_address = false;
>+ };
>+ consteval info data_member_spec(info, data_member_options);
>+ consteval bool is_data_member_spec(info);
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval info define_aggregate(info, _R&&);
>+
>+ // associated with [meta.unary.cat], primary type categories
>+ consteval bool is_void_type(info);
>+ consteval bool is_null_pointer_type(info);
>+ consteval bool is_integral_type(info);
>+ consteval bool is_floating_point_type(info);
>+ consteval bool is_array_type(info);
>+ consteval bool is_pointer_type(info);
>+ consteval bool is_lvalue_reference_type(info);
>+ consteval bool is_rvalue_reference_type(info);
>+ consteval bool is_member_object_pointer_type(info);
>+ consteval bool is_member_function_pointer_type(info);
>+ consteval bool is_enum_type(info);
>+ consteval bool is_union_type(info);
>+ consteval bool is_class_type(info);
>+ consteval bool is_function_type(info);
>+ consteval bool is_reflection_type(info);
>+
>+ // associated with [meta.unary.comp], composite type categories
>+ consteval bool is_reference_type(info);
>+ consteval bool is_arithmetic_type(info);
>+ consteval bool is_fundamental_type(info);
>+ consteval bool is_object_type(info);
>+ consteval bool is_scalar_type(info);
>+ consteval bool is_compound_type(info);
>+ consteval bool is_member_pointer_type(info);
>+
>+ // associated with [meta.unary.prop], type properties
>+ consteval bool is_const_type(info);
>+ consteval bool is_volatile_type(info);
>+ consteval bool is_trivially_copyable_type(info);
>+ consteval bool is_standard_layout_type(info);
>+ consteval bool is_empty_type(info);
>+ consteval bool is_polymorphic_type(info);
>+ consteval bool is_abstract_type(info);
>+ consteval bool is_final_type(info);
>+ consteval bool is_aggregate_type(info);
>+ consteval bool is_consteval_only_type(info);
>+ consteval bool is_signed_type(info);
>+ consteval bool is_unsigned_type(info);
>+ consteval bool is_bounded_array_type(info);
>+ consteval bool is_unbounded_array_type(info);
>+ consteval bool is_scoped_enum_type(info);
>+
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval bool is_constructible_type(info, _R&&);
>+ consteval bool is_default_constructible_type(info);
>+ consteval bool is_copy_constructible_type(info);
>+ consteval bool is_move_constructible_type(info);
>+
>+ consteval bool is_assignable_type(info, info);
>+ consteval bool is_copy_assignable_type(info);
>+ consteval bool is_move_assignable_type(info);
>+
>+ consteval bool is_swappable_with_type(info, info);
>+ consteval bool is_swappable_type(info);
>+
>+ consteval bool is_destructible_type(info);
>+
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval bool is_trivially_constructible_type(info, _R&&);
>+ consteval bool is_trivially_default_constructible_type(info);
>+ consteval bool is_trivially_copy_constructible_type(info);
>+ consteval bool is_trivially_move_constructible_type(info);
>+
>+ consteval bool is_trivially_assignable_type(info, info);
>+ consteval bool is_trivially_copy_assignable_type(info);
>+ consteval bool is_trivially_move_assignable_type(info);
>+ consteval bool is_trivially_destructible_type(info);
>+
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval bool is_nothrow_constructible_type(info, _R&&);
>+ consteval bool is_nothrow_default_constructible_type(info);
>+ consteval bool is_nothrow_copy_constructible_type(info);
>+ consteval bool is_nothrow_move_constructible_type(info);
>+
>+ consteval bool is_nothrow_assignable_type(info, info);
>+ consteval bool is_nothrow_copy_assignable_type(info);
>+ consteval bool is_nothrow_move_assignable_type(info);
>+
>+ consteval bool is_nothrow_swappable_with_type(info, info);
>+ consteval bool is_nothrow_swappable_type(info);
>+
>+ consteval bool is_nothrow_destructible_type(info);
>+
>+ consteval bool is_implicit_lifetime_type(info);
>+
>+ consteval bool has_virtual_destructor(info);
>+
>+ consteval bool has_unique_object_representations(info);
>+
>+ consteval bool reference_constructs_from_temporary(info, info);
>+ consteval bool reference_converts_from_temporary(info, info);
>+
>+ // associated with [meta.unary.prop.query], type property queries
>+ consteval size_t rank(info);
>+ consteval size_t extent(info, unsigned = 0);
>+
>+ // associated with [meta.rel], type relations
>+ consteval bool is_same_type(info, info);
>+ consteval bool is_base_of_type(info, info);
>+ consteval bool is_virtual_base_of_type(info, info);
>+ consteval bool is_convertible_type(info, info);
>+ consteval bool is_nothrow_convertible_type(info, info);
>+ consteval bool is_layout_compatible_type(info, info);
>+ consteval bool is_pointer_interconvertible_base_of_type(info, info);
>+
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval bool is_invocable_type(info, _R&&);
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval bool is_invocable_r_type(info, info, _R&&);
>+
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval bool is_nothrow_invocable_type(info, _R&&);
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval bool is_nothrow_invocable_r_type(info, info, _R&&);
>+
>+ // associated with [meta.trans.cv], const-volatile modifications
>+ consteval info remove_const(info);
>+ consteval info remove_volatile(info);
>+ consteval info remove_cv(info);
>+ consteval info add_const(info);
>+ consteval info add_volatile(info);
>+ consteval info add_cv(info);
>+
>+ // associated with [meta.trans.ref], reference modifications
>+ consteval info remove_reference(info);
>+ consteval info add_lvalue_reference(info);
>+ consteval info add_rvalue_reference(info);
>+
>+ // associated with [meta.trans.sign], sign modifications
>+ consteval info make_signed(info);
>+ consteval info make_unsigned(info);
>+
>+ // associated with [meta.trans.arr], array modifications
>+ consteval info remove_extent(info);
>+ consteval info remove_all_extents(info);
>+
>+ // associated with [meta.trans.ptr], pointer modifications
>+ consteval info remove_pointer(info);
>+ consteval info add_pointer(info);
>+
>+ // associated with [meta.trans.other], other transformations
>+ consteval info remove_cvref(info);
>+ consteval info decay(info);
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval info common_type(_R&&);
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval info common_reference(_R&&);
>+ consteval info underlying_type(info);
>+ template<reflection_range _R = initializer_list<info>>
>+ consteval info invoke_result(info, _R&&);
>+ consteval info unwrap_reference(info);
>+ consteval info unwrap_ref_decay(info);
>+
>+ consteval size_t tuple_size(info);
>+ consteval info tuple_element(size_t, info);
>+
>+ consteval size_t variant_size(info);
>+ consteval info variant_alternative(size_t, info);
>+
>+ consteval strong_ordering type_order(info, info);
>+
>+ // [meta.reflection.annotation], annotation reflection
>+ consteval vector<info> annotations_of(info);
>+ consteval vector<info> annotations_of_with_type(info, info);
>+
>+ consteval access_context
>+ access_context::via(info __cls) const
>+ {
>+ if (__cls != info {}
>+ && (!std::meta::is_class_type(__cls)
>+ || !std::meta::is_complete_type(__cls)))
>+ {
>+#if __cpp_exceptions
>+ throw std::meta::exception(u8"via argument other than null "
>+ "or complete class type reflection",
>+ ^^access_context::via);
>+#else
>+ return *this;
Should this be non-constant instead of returning a valid value?
>+#endif
>+ }
>+ return access_context { _M_scope, __cls };
>+ }
>+
>+ } // namespace meta
>+
>+ // [meta.define.static], promoting to static storage strings
>+ template<ranges::input_range _R>
>+ consteval const ranges::range_value_t<_R>*
>+ define_static_string(_R&& __r)
>+ {
>+ auto __str = meta::reflect_constant_string(__r);
>+ return meta::extract<const ranges::range_value_t<_R>*>(__str);
>+ }
>+
>+ template<ranges::input_range _R>
>+ consteval span<const ranges::range_value_t<_R>>
>+ define_static_array(_R&& __r)
>+ {
>+ using _Tp = ranges::range_value_t<_R>;
>+ auto __array = meta::reflect_constant_array(__r);
>+ auto __type = meta::type_of(__array);
>+ if (meta::is_array_type(__type))
>+ return span<const _Tp>(meta::extract<const _Tp*>(__array),
>+ meta::extent(__type, 0U));
>+ else
>+ return span<const _Tp>();
>+ }
>+
>+ template<class _Tp>
>+ consteval const remove_cvref_t<_Tp>*
>+ define_static_object(_Tp&& __t)
>+ {
>+ using _Up = remove_cvref_t<_Tp>;
>+ if constexpr (meta::is_class_type(^^_Up))
>+ {
>+ auto __cst = meta::reflect_constant(std::forward<_Tp>(__t));
>+ return std::addressof(meta::extract<const _Up&>(__cst));
>+ }
>+ else
>+ return std::define_static_array(span<const _Up>(std::addressof(__t),
>+ 1)).data();
>+ }
>+
>+_GLIBCXX_END_NAMESPACE_VERSION
>+} // namespace std
>+
>+#endif // C++26
>+
>+#endif // _GLIBCXX_META
>diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
>index d28b077398b..75859e11ebf 100644
>--- a/libstdc++-v3/include/std/type_traits
>+++ b/libstdc++-v3/include/std/type_traits
>@@ -695,6 +695,29 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> : public false_type { };
> #endif
>
>+#if __cpp_impl_reflection >= 202500L // C++ >= 26
>+ /// is_reflection
>+ template<typename _Tp>
>+ struct is_reflection
>+ : public false_type { };
>+
>+ template<>
>+ struct is_reflection<decltype(^^int)>
>+ : public true_type { };
>+
>+ template<>
>+ struct is_reflection<const decltype(^^int)>
>+ : public true_type { };
>+
>+ template<>
>+ struct is_reflection<volatile decltype(^^int)>
>+ : public true_type { };
>+
>+ template<>
>+ struct is_reflection<const volatile decltype(^^int)>
>+ : public true_type { };
>+#endif
>+
> #ifdef __cpp_lib_is_null_pointer // C++ >= 11
> /// is_null_pointer (LWG 2247).
> template<typename _Tp>
>@@ -757,11 +780,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> { };
>
> /// is_fundamental
>+#if __cpp_impl_reflection >= 202500L
>+ template<typename _Tp>
>+ struct is_fundamental
>+ : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
>+ is_null_pointer<_Tp>, is_reflection<_Tp>>::type
>+ { };
>+#else
> template<typename _Tp>
> struct is_fundamental
> : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
> is_null_pointer<_Tp>>::type
> { };
>+#endif
I think I'd prefer just one definition, with a conditional part:
template<typename _Tp>
struct is_fundamental
: public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
is_null_pointer<_Tp>
#if __cpp_impl_reflection >= 202500L
, is_reflection<_Tp>
#endif
>::type
{ };
That way if we need to add other traits to the list, or we can replace
is_arithmetic<_Tp> with a new __bool_constant<__is_arithmetic(_Tp)>
builtin, we don't need to edit two definitions of is_fundamental.
> /// is_object
> #if _GLIBCXX_USE_BUILTIN_TRAIT(__is_object)
>@@ -3519,6 +3550,12 @@ template <typename _Tp>
> is_member_function_pointer<_Tp>::value;
> #endif
>
>+#if __cpp_impl_reflection >= 202500L // C++ >= 26
>+template <typename _Tp>
>+ inline constexpr bool is_reflection_v =
>+ is_reflection<_Tp>::value;
We could specialize this to avoid instantiating the is_reflection
class template, but that can be optimized later.
>+#endif
>+
> template <typename _Tp>
> inline constexpr bool is_enum_v = __is_enum(_Tp);
> template <typename _Tp>
>@@ -3851,6 +3888,24 @@ template<typename _Ret, typename _Fn, typename... _Args>
> # endif
> #endif
>
>+#if __cpp_impl_reflection >= 202500L \
>+ && _GLIBCXX_USE_BUILTIN_TRAIT(__builtin_is_consteval_only) // C++ >= 26
>+ /// is_consteval_only - true if the type is consteval-only.
>+ /// @since C++26
>+ template<typename _Tp>
>+ struct is_consteval_only
>+ : bool_constant<__builtin_is_consteval_only(_Tp)>
>+ { };
>+
>+ /** is_consteval_only_v - true if the type is consteval-only.
>+ * @ingroup variable_templates
>+ * @since C++26
>+ */
>+ template<typename _Tp>
>+ inline constexpr bool is_consteval_only_v
>+ = __builtin_is_consteval_only(_Tp);
>+#endif
>+
> /** * Remove references and cv-qualifiers.
> * @since C++20
> * @{
>diff --git a/libstdc++-v3/src/c++23/std.cc.in b/libstdc++-v3/src/c++23/std.cc.in
>index 27d83f1ba1b..a75db1fe0a0 100644
>--- a/libstdc++-v3/src/c++23/std.cc.in
>+++ b/libstdc++-v3/src/c++23/std.cc.in
>@@ -2035,6 +2035,261 @@ export namespace std::pmr
> using std::pmr::unsynchronized_pool_resource;
> }
>
>+// <meta>
>+#if __glibcxx_reflection >= 202506L
>+export namespace std
>+{
>+#if __has_builtin(__builtin_is_string_literal)
>+ using std::is_string_literal;
>+#endif
>+ using std::define_static_string;
>+ using std::define_static_array;
>+ using std::define_static_object;
>+ namespace meta
>+ {
>+ using std::meta::info;
>+ using std::meta::exception;
>+ using std::meta::operators;
>+ using enum std::meta::operators;
This is enough to export all the enumerators of this enum, right?
Hmm, we don't do this for other enums such as
std::filesystem::file_type, which might be a bug in the existing
exports...
>+ using std::meta::operator_of;
>+ using std::meta::symbol_of;
>+ using std::meta::u8symbol_of;
>+ using std::meta::has_identifier;
>+ using std::meta::identifier_of;
>+ using std::meta::u8identifier_of;
>+ using std::meta::display_string_of;
>+ using std::meta::u8display_string_of;
>+ using std::meta::source_location_of;
>+ using std::meta::type_of;
>+ using std::meta::object_of;
>+ using std::meta::constant_of;
>+ using std::meta::is_public;
>+ using std::meta::is_protected;
>+ using std::meta::is_private;
>+ using std::meta::is_virtual;
>+ using std::meta::is_pure_virtual;
>+ using std::meta::is_override;
>+ using std::meta::is_final;
>+ using std::meta::is_deleted;
>+ using std::meta::is_defaulted;
>+ using std::meta::is_user_provided;
>+ using std::meta::is_user_declared;
>+ using std::meta::is_explicit;
>+ using std::meta::is_noexcept;
>+ using std::meta::is_bit_field;
>+ using std::meta::is_enumerator;
>+ using std::meta::is_annotation;
>+ using std::meta::is_const;
>+ using std::meta::is_volatile;
>+ using std::meta::is_mutable_member;
>+ using std::meta::is_lvalue_reference_qualified;
>+ using std::meta::is_rvalue_reference_qualified;
>+ using std::meta::has_static_storage_duration;
>+ using std::meta::has_thread_storage_duration;
>+ using std::meta::has_automatic_storage_duration;
>+ using std::meta::has_internal_linkage;
>+ using std::meta::has_module_linkage;
>+ using std::meta::has_external_linkage;
>+ using std::meta::has_c_language_linkage;
>+ using std::meta::has_linkage;
>+ using std::meta::is_complete_type;
>+ using std::meta::is_enumerable_type;
>+ using std::meta::is_variable;
>+ using std::meta::is_type;
>+ using std::meta::is_namespace;
>+ using std::meta::is_type_alias;
>+ using std::meta::is_namespace_alias;
>+ using std::meta::is_function;
>+ using std::meta::is_conversion_function;
>+ using std::meta::is_operator_function;
>+ using std::meta::is_literal_operator;
>+ using std::meta::is_special_member_function;
>+ using std::meta::is_constructor;
>+ using std::meta::is_default_constructor;
>+ using std::meta::is_copy_constructor;
>+ using std::meta::is_move_constructor;
>+ using std::meta::is_assignment;
>+ using std::meta::is_copy_assignment;
>+ using std::meta::is_move_assignment;
>+ using std::meta::is_destructor;
>+ using std::meta::is_function_parameter;
>+ using std::meta::is_explicit_object_parameter;
>+ using std::meta::has_default_argument;
>+ using std::meta::has_ellipsis_parameter;
>+ using std::meta::is_template;
>+ using std::meta::is_function_template;
>+ using std::meta::is_variable_template;
>+ using std::meta::is_class_template;
>+ using std::meta::is_alias_template;
>+ using std::meta::is_conversion_function_template;
>+ using std::meta::is_operator_function_template;
>+ using std::meta::is_literal_operator_template;
>+ using std::meta::is_constructor_template;
>+ using std::meta::is_concept;
>+ using std::meta::is_value;
>+ using std::meta::is_object;
>+ using std::meta::is_structured_binding;
>+ using std::meta::is_class_member;
>+ using std::meta::is_namespace_member;
>+ using std::meta::is_nonstatic_data_member;
>+ using std::meta::is_static_member;
>+ using std::meta::is_base;
>+ using std::meta::has_default_member_initializer;
>+ using std::meta::has_parent;
>+ using std::meta::parent_of;
>+ using std::meta::dealias;
>+ using std::meta::has_template_arguments;
>+ using std::meta::template_of;
>+ using std::meta::template_arguments_of;
>+ using std::meta::parameters_of;
>+ using std::meta::variable_of;
>+ using std::meta::return_type_of;
>+ using std::meta::access_context;
>+ using std::meta::is_accessible;
>+ using std::meta::has_inaccessible_nonstatic_data_members;
>+ using std::meta::has_inaccessible_bases;
>+ using std::meta::has_inaccessible_subobjects;
>+ using std::meta::members_of;
>+ using std::meta::bases_of;
>+ using std::meta::static_data_members_of;
>+ using std::meta::nonstatic_data_members_of;
>+ using std::meta::subobjects_of;
>+ using std::meta::enumerators_of;
>+ using std::meta::member_offset;
>+ using std::meta::offset_of;
>+ using std::meta::size_of;
>+ using std::meta::alignment_of;
>+ using std::meta::bit_size_of;
>+ using std::meta::extract;
>+ using std::meta::reflection_range;
>+ using std::meta::can_substitute;
>+ using std::meta::substitute;
>+ using std::meta::reflect_constant;
>+ using std::meta::reflect_object;
>+ using std::meta::reflect_function;
>+ using std::meta::reflect_constant_string;
>+ using std::meta::reflect_constant_array;
>+ using std::meta::data_member_options;
>+ using std::meta::data_member_spec;
>+ using std::meta::is_data_member_spec;
>+ using std::meta::define_aggregate;
>+ using std::meta::is_void_type;
>+ using std::meta::is_null_pointer_type;
>+ using std::meta::is_integral_type;
>+ using std::meta::is_floating_point_type;
>+ using std::meta::is_array_type;
>+ using std::meta::is_pointer_type;
>+ using std::meta::is_lvalue_reference_type;
>+ using std::meta::is_rvalue_reference_type;
>+ using std::meta::is_member_object_pointer_type;
>+ using std::meta::is_member_function_pointer_type;
>+ using std::meta::is_enum_type;
>+ using std::meta::is_union_type;
>+ using std::meta::is_class_type;
>+ using std::meta::is_function_type;
>+ using std::meta::is_reflection_type;
>+ using std::meta::is_reference_type;
>+ using std::meta::is_arithmetic_type;
>+ using std::meta::is_fundamental_type;
>+ using std::meta::is_object_type;
>+ using std::meta::is_scalar_type;
>+ using std::meta::is_compound_type;
>+ using std::meta::is_member_pointer_type;
>+ using std::meta::is_const_type;
>+ using std::meta::is_volatile_type;
>+ using std::meta::is_trivially_copyable_type;
>+ using std::meta::is_standard_layout_type;
>+ using std::meta::is_empty_type;
>+ using std::meta::is_polymorphic_type;
>+ using std::meta::is_abstract_type;
>+ using std::meta::is_final_type;
>+ using std::meta::is_aggregate_type;
>+ using std::meta::is_consteval_only_type;
>+ using std::meta::is_signed_type;
>+ using std::meta::is_unsigned_type;
>+ using std::meta::is_bounded_array_type;
>+ using std::meta::is_unbounded_array_type;
>+ using std::meta::is_scoped_enum_type;
>+ using std::meta::is_constructible_type;
>+ using std::meta::is_default_constructible_type;
>+ using std::meta::is_copy_constructible_type;
>+ using std::meta::is_move_constructible_type;
>+ using std::meta::is_assignable_type;
>+ using std::meta::is_copy_assignable_type;
>+ using std::meta::is_move_assignable_type;
>+ using std::meta::is_swappable_with_type;
>+ using std::meta::is_swappable_type;
>+ using std::meta::is_destructible_type;
>+ using std::meta::is_trivially_constructible_type;
>+ using std::meta::is_trivially_default_constructible_type;
>+ using std::meta::is_trivially_copy_constructible_type;
>+ using std::meta::is_trivially_move_constructible_type;
>+ using std::meta::is_trivially_assignable_type;
>+ using std::meta::is_trivially_copy_assignable_type;
>+ using std::meta::is_trivially_move_assignable_type;
>+ using std::meta::is_trivially_destructible_type;
>+ using std::meta::is_nothrow_constructible_type;
>+ using std::meta::is_nothrow_default_constructible_type;
>+ using std::meta::is_nothrow_copy_constructible_type;
>+ using std::meta::is_nothrow_move_constructible_type;
>+ using std::meta::is_nothrow_assignable_type;
>+ using std::meta::is_nothrow_copy_assignable_type;
>+ using std::meta::is_nothrow_move_assignable_type;
>+ using std::meta::is_nothrow_swappable_with_type;
>+ using std::meta::is_nothrow_swappable_type;
>+ using std::meta::is_nothrow_destructible_type;
>+ using std::meta::is_implicit_lifetime_type;
>+ using std::meta::has_virtual_destructor;
>+ using std::meta::has_unique_object_representations;
>+ using std::meta::reference_constructs_from_temporary;
>+ using std::meta::reference_converts_from_temporary;
>+ using std::meta::rank;
>+ using std::meta::extent;
>+ using std::meta::is_same_type;
>+ using std::meta::is_base_of_type;
>+ using std::meta::is_virtual_base_of_type;
>+ using std::meta::is_convertible_type;
>+ using std::meta::is_nothrow_convertible_type;
>+ using std::meta::is_layout_compatible_type;
>+ using std::meta::is_pointer_interconvertible_base_of_type;
>+ using std::meta::is_invocable_type;
>+ using std::meta::is_invocable_r_type;
>+ using std::meta::is_nothrow_invocable_type;
>+ using std::meta::is_nothrow_invocable_r_type;
>+ using std::meta::remove_const;
>+ using std::meta::remove_volatile;
>+ using std::meta::remove_cv;
>+ using std::meta::add_const;
>+ using std::meta::add_volatile;
>+ using std::meta::add_cv;
>+ using std::meta::remove_reference;
>+ using std::meta::add_lvalue_reference;
>+ using std::meta::add_rvalue_reference;
>+ using std::meta::make_signed;
>+ using std::meta::make_unsigned;
>+ using std::meta::remove_extent;
>+ using std::meta::remove_all_extents;
>+ using std::meta::remove_pointer;
>+ using std::meta::add_pointer;
>+ using std::meta::remove_cvref;
>+ using std::meta::decay;
>+ using std::meta::common_type;
>+ using std::meta::common_reference;
>+ using std::meta::underlying_type;
>+ using std::meta::invoke_result;
>+ using std::meta::unwrap_reference;
>+ using std::meta::unwrap_ref_decay;
>+ using std::meta::tuple_size;
>+ using std::meta::tuple_element;
>+ using std::meta::variant_size;
>+ using std::meta::variant_alternative;
>+ using std::meta::type_order;
>+ using std::meta::annotations_of;
>+ using std::meta::annotations_of_with_type;
>+ }
>+}
>+#endif
>+
> // <mutex>
> export namespace std
> {
>diff --git a/libstdc++-v3/testsuite/20_util/is_consteval_only/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_consteval_only/requirements/explicit_instantiation.cc
>new file mode 100644
>index 00000000000..3680730bd45
>--- /dev/null
>+++ b/libstdc++-v3/testsuite/20_util/is_consteval_only/requirements/explicit_instantiation.cc
>@@ -0,0 +1,29 @@
>+// { dg-do compile { target c++26 } }
>+// { dg-additional-options "-freflection" }
>+
>+// Copyright (C) 2025 Free Software Foundation, Inc.
>+//
>+// This file is part of the GNU ISO C++ Library. This library is free
>+// software; you can redistribute it and/or modify it under the
>+// terms of the GNU General Public License as published by the
>+// Free Software Foundation; either version 3, or (at your option)
>+// any later version.
>+
>+// This library is distributed in the hope that it will be useful,
>+// but WITHOUT ANY WARRANTY; without even the implied warranty of
>+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>+// GNU General Public License for more details.
>+
>+// You should have received a copy of the GNU General Public License along
>+// with this library; see the file COPYING3. If not see
>+// <http://www.gnu.org/licenses/>.
>+
>+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
We don't need the copyright and license header on these tests, they're
not doing anything legally significant that is copyrightable.
>+
>+#include <type_traits>
>+
>+namespace std
>+{
>+ typedef short test_type;
>+ template struct is_consteval_only<test_type>;
>+}
>diff --git a/libstdc++-v3/testsuite/20_util/is_consteval_only/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_consteval_only/requirements/typedefs.cc
>new file mode 100644
>index 00000000000..39a55baeb3f
>--- /dev/null
>+++ b/libstdc++-v3/testsuite/20_util/is_consteval_only/requirements/typedefs.cc
>@@ -0,0 +1,34 @@
>+// { dg-do compile { target c++26 } }
>+// { dg-additional-options "-freflection" }
>+
>+// Copyright (C) 2025 Free Software Foundation, Inc.
>+//
>+// This file is part of the GNU ISO C++ Library. This library is free
>+// software; you can redistribute it and/or modify it under the
>+// terms of the GNU General Public License as published by the
>+// Free Software Foundation; either version 3, or (at your option)
>+// any later version.
>+//
>+// This library is distributed in the hope that it will be useful,
>+// but WITHOUT ANY WARRANTY; without even the implied warranty of
>+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>+// GNU General Public License for more details.
>+//
>+// You should have received a copy of the GNU General Public License along
>+// with this library; see the file COPYING3. If not see
>+// <http://www.gnu.org/licenses/>.
>+
>+//
>+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
>+
>+#include <type_traits>
>+
>+void test01()
>+{
>+ // Check for required typedefs
>+ typedef std::is_consteval_only<decltype (^^int)> test_type;
>+ typedef test_type::value_type value_type;
>+ typedef test_type::type type;
>+ typedef test_type::type::value_type type_value_type;
>+ typedef test_type::type::type type_type;
>+}
>diff --git a/libstdc++-v3/testsuite/20_util/is_consteval_only/value.cc b/libstdc++-v3/testsuite/20_util/is_consteval_only/value.cc
>new file mode 100644
>index 00000000000..d391ac79c34
>--- /dev/null
>+++ b/libstdc++-v3/testsuite/20_util/is_consteval_only/value.cc
>@@ -0,0 +1,47 @@
>+// { dg-do compile { target c++26 } }
>+// { dg-additional-options "-freflection" }
>+
>+// Copyright (C) 2025 Free Software Foundation, Inc.
>+//
>+// This file is part of the GNU ISO C++ Library. This library is free
>+// software; you can redistribute it and/or modify it under the
>+// terms of the GNU General Public License as published by the
>+// Free Software Foundation; either version 3, or (at your option)
>+// any later version.
>+//
>+// This library is distributed in the hope that it will be useful,
>+// but WITHOUT ANY WARRANTY; without even the implied warranty of
>+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>+// GNU General Public License for more details.
>+//
>+// You should have received a copy of the GNU General Public License along
>+// with this library; see the file COPYING3. If not see
>+// <http://www.gnu.org/licenses/>.
>+
>+#include <type_traits>
>+#include <testsuite_tr1.h>
>+
>+void test01()
>+{
>+ using std::is_consteval_only;
>+ using namespace __gnu_test;
>+ int v = 1;
>+ struct S1 { decltype(^^long) a; };
>+ union U2 { int a; decltype(^^test01) b; };
>+ struct S3 { const decltype(^^__gnu_test) *c; };
>+ struct S4 : public S3 {};
>+ struct S5 { int a; long *b; };
>+
>+ static_assert(test_category<is_consteval_only, decltype(^^long)>(true), "");
>+ static_assert(test_category<is_consteval_only, const decltype(^^test01)>(true), "");
>+ static_assert(test_category<is_consteval_only, volatile decltype(^^__gnu_test)>(true), "");
>+ static_assert(test_category<is_consteval_only, const volatile decltype(^^v)>(true), "");
>+ static_assert(test_category<is_consteval_only, const S1>(true), "");
>+ static_assert(test_category<is_consteval_only, U2>(true), "");
>+ static_assert(test_category<is_consteval_only, S3>(true), "");
>+ static_assert(test_category<is_consteval_only, S4>(true), "");
>+
>+ // Sanity check.
>+ static_assert(test_category<is_consteval_only, int>(false), "");
>+ static_assert(test_category<is_consteval_only, S5>(false), "");
>+}
>diff --git a/libstdc++-v3/testsuite/20_util/is_reflection/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_reflection/requirements/explicit_instantiation.cc
>new file mode 100644
>index 00000000000..952574a8567
>--- /dev/null
>+++ b/libstdc++-v3/testsuite/20_util/is_reflection/requirements/explicit_instantiation.cc
>@@ -0,0 +1,29 @@
>+// { dg-do compile { target c++26 } }
>+// { dg-additional-options "-freflection" }
>+
>+// Copyright (C) 2025 Free Software Foundation, Inc.
>+//
>+// This file is part of the GNU ISO C++ Library. This library is free
>+// software; you can redistribute it and/or modify it under the
>+// terms of the GNU General Public License as published by the
>+// Free Software Foundation; either version 3, or (at your option)
>+// any later version.
>+
>+// This library is distributed in the hope that it will be useful,
>+// but WITHOUT ANY WARRANTY; without even the implied warranty of
>+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>+// GNU General Public License for more details.
>+
>+// You should have received a copy of the GNU General Public License along
>+// with this library; see the file COPYING3. If not see
>+// <http://www.gnu.org/licenses/>.
>+
>+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
>+
>+#include <type_traits>
>+
>+namespace std
>+{
>+ typedef short test_type;
>+ template struct is_reflection<test_type>;
We should really rationalize our type_traits tests and stop having
three separate one-line tests for every individual trait :-\
That's not something to fix with this patch though, just reminding
myself to revisit it one day.
>+}
>diff --git a/libstdc++-v3/testsuite/20_util/is_reflection/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_reflection/requirements/typedefs.cc
>new file mode 100644
>index 00000000000..04cdb0a56be
>--- /dev/null
>+++ b/libstdc++-v3/testsuite/20_util/is_reflection/requirements/typedefs.cc
>@@ -0,0 +1,34 @@
>+// { dg-do compile { target c++26 } }
>+// { dg-additional-options "-freflection" }
>+
>+// Copyright (C) 2025 Free Software Foundation, Inc.
>+//
>+// This file is part of the GNU ISO C++ Library. This library is free
>+// software; you can redistribute it and/or modify it under the
>+// terms of the GNU General Public License as published by the
>+// Free Software Foundation; either version 3, or (at your option)
>+// any later version.
>+//
>+// This library is distributed in the hope that it will be useful,
>+// but WITHOUT ANY WARRANTY; without even the implied warranty of
>+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>+// GNU General Public License for more details.
>+//
>+// You should have received a copy of the GNU General Public License along
>+// with this library; see the file COPYING3. If not see
>+// <http://www.gnu.org/licenses/>.
>+
>+//
>+// NB: This file is for testing type_traits with NO OTHER INCLUDES.
>+
>+#include <type_traits>
>+
>+void test01()
>+{
>+ // Check for required typedefs
>+ typedef std::is_reflection<decltype (^^int)> test_type;
>+ typedef test_type::value_type value_type;
>+ typedef test_type::type type;
>+ typedef test_type::type::value_type type_value_type;
>+ typedef test_type::type::type type_type;
>+}
>diff --git a/libstdc++-v3/testsuite/20_util/is_reflection/value.cc b/libstdc++-v3/testsuite/20_util/is_reflection/value.cc
>new file mode 100644
>index 00000000000..ec820751faf
>--- /dev/null
>+++ b/libstdc++-v3/testsuite/20_util/is_reflection/value.cc
>@@ -0,0 +1,37 @@
>+// { dg-do compile { target c++26 } }
>+// { dg-additional-options "-freflection" }
>+
>+// Copyright (C) 2025 Free Software Foundation, Inc.
>+//
>+// This file is part of the GNU ISO C++ Library. This library is free
>+// software; you can redistribute it and/or modify it under the
>+// terms of the GNU General Public License as published by the
>+// Free Software Foundation; either version 3, or (at your option)
>+// any later version.
>+//
>+// This library is distributed in the hope that it will be useful,
>+// but WITHOUT ANY WARRANTY; without even the implied warranty of
>+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>+// GNU General Public License for more details.
>+//
>+// You should have received a copy of the GNU General Public License along
>+// with this library; see the file COPYING3. If not see
>+// <http://www.gnu.org/licenses/>.
>+
>+#include <type_traits>
>+#include <testsuite_tr1.h>
>+
>+void test01()
>+{
>+ using std::is_reflection;
>+ using namespace __gnu_test;
>+ int v = 1;
>+
>+ static_assert(test_category<is_reflection, decltype(^^long)>(true), "");
>+ static_assert(test_category<is_reflection, const decltype(^^test01)>(true), "");
>+ static_assert(test_category<is_reflection, volatile decltype(^^__gnu_test)>(true), "");
>+ static_assert(test_category<is_reflection, const volatile decltype(^^v)>(true), "");
>+
>+ // Sanity check.
>+ static_assert(test_category<is_reflection, int>(false), "");
>+}
>diff --git a/libstdc++-v3/testsuite/20_util/variable_templates_for_traits.cc b/libstdc++-v3/testsuite/20_util/variable_templates_for_traits.cc
>index b48958746e1..0efc533f25b 100644
>--- a/libstdc++-v3/testsuite/20_util/variable_templates_for_traits.cc
>+++ b/libstdc++-v3/testsuite/20_util/variable_templates_for_traits.cc
>@@ -1,5 +1,6 @@
> // { dg-additional-options "-Wno-deprecated-declarations" { target c++2a } }
> // { dg-do compile { target c++17 } }
>+// { dg-additional-options "-freflection" { target c++26 } }
>
> // Copyright (C) 2014-2025 Free Software Foundation, Inc.
> //
>@@ -330,6 +331,12 @@ static_assert(is_convertible_v<int&, const int&>
> static_assert(!is_convertible_v<const int&, int&>
> && !is_convertible<const int&, int&>::value, "");
>
>+#if __cpp_impl_reflection >= 202500L
>+static_assert(is_reflection_v<decltype(^^int)>
>+ && is_reflection<decltype(^^int)>::value, "");
>+static_assert(!is_reflection_v<int> && !is_reflection<int>::value, "");
>+#endif
>+
> static_assert(negation_v<false_type>, "");
> static_assert(!negation_v<true_type>, "");
> static_assert(conjunction_v<>, "");
>
>
More information about the Libstdc++
mailing list