{"id":2175268,"url":"http://patchwork.ozlabs.org/api/1.0/patches/2175268/?format=json","project":{"id":17,"url":"http://patchwork.ozlabs.org/api/1.0/projects/17/?format=json","name":"GNU Compiler Collection","link_name":"gcc","list_id":"gcc-patches.gcc.gnu.org","list_email":"gcc-patches@gcc.gnu.org","web_url":null,"scm_url":null,"webscm_url":null},"msgid":"","date":"2025-12-17T16:47:11","name":"[4/9,v2] c++: C++26 Reflection [PR120775]","commit_ref":null,"pull_url":null,"state":"new","archived":false,"hash":"35e69ad6f1cbb05bc15d0543c00474d5586a8614","submitter":{"id":14370,"url":"http://patchwork.ozlabs.org/api/1.0/people/14370/?format=json","name":"Marek Polacek","email":"polacek@redhat.com"},"delegate":null,"mbox":"http://patchwork.ozlabs.org/project/gcc/patch/aULej7pJ334aqEsf@redhat.com/mbox/","series":[{"id":485726,"url":"http://patchwork.ozlabs.org/api/1.0/series/485726/?format=json","date":"2025-12-17T16:42:41","name":"c++: C++26 Reflection [PR120775]","version":2,"mbox":"http://patchwork.ozlabs.org/series/485726/mbox/"}],"check":"pending","checks":"http://patchwork.ozlabs.org/api/patches/2175268/checks/","tags":{},"headers":{"Return-Path":"","X-Original-To":["incoming@patchwork.ozlabs.org","gcc-patches@gcc.gnu.org"],"Delivered-To":["patchwork-incoming@legolas.ozlabs.org","gcc-patches@gcc.gnu.org"],"Authentication-Results":["legolas.ozlabs.org;\n\tdkim=pass (1024-bit key;\n unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256\n header.s=mimecast20190719 header.b=Kr62Lf5j;\n\tdkim-atps=neutral","legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org\n (client-ip=38.145.34.32; helo=vm01.sourceware.org;\n envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org;\n receiver=patchwork.ozlabs.org)","sourceware.org;\n\tdkim=pass (1024-bit key,\n unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256\n header.s=mimecast20190719 header.b=Kr62Lf5j","sourceware.org; dmarc=pass (p=quarantine dis=none)\n header.from=redhat.com","sourceware.org; spf=pass smtp.mailfrom=redhat.com","server2.sourceware.org;\n arc=none smtp.remote-ip=170.10.133.124"],"Received":["from vm01.sourceware.org (vm01.sourceware.org [38.145.34.32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4dWft30D65z1xty\n\tfor ; Thu, 18 Dec 2025 03:50:03 +1100 (AEDT)","from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 1C81A4BA23D2\n\tfor ; Wed, 17 Dec 2025 16:50:01 +0000 (GMT)","from us-smtp-delivery-124.mimecast.com\n (us-smtp-delivery-124.mimecast.com [170.10.133.124])\n by sourceware.org (Postfix) with ESMTP id EE0494BA23D4\n for ; Wed, 17 Dec 2025 16:47:18 +0000 (GMT)","from mail-qk1-f200.google.com (mail-qk1-f200.google.com\n [209.85.222.200]) by relay.mimecast.com with ESMTP with STARTTLS\n (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id\n us-mta-526-lmZTgZhTOtKGjeOkJgXVKQ-1; Wed, 17 Dec 2025 11:47:17 -0500","by mail-qk1-f200.google.com with SMTP id\n af79cd13be357-8b22ab98226so1919643985a.2\n for ; Wed, 17 Dec 2025 08:47:17 -0800 (PST)","from redhat.com ([2603:7000:9500:10::1db4])\n by smtp.gmail.com with ESMTPSA id\n 6a1803df08f44-8899ea36210sm98106646d6.27.2025.12.17.08.47.13\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Wed, 17 Dec 2025 08:47:13 -0800 (PST)"],"DKIM-Filter":["OpenDKIM Filter v2.11.0 sourceware.org 1C81A4BA23D2","OpenDKIM Filter v2.11.0 sourceware.org EE0494BA23D4"],"DMARC-Filter":"OpenDMARC Filter v1.4.2 sourceware.org EE0494BA23D4","ARC-Filter":"OpenARC Filter v1.0.0 sourceware.org EE0494BA23D4","ARC-Seal":"i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1765990039; cv=none;\n b=hvmzDlMDavzQX7+iLYy6K1GvAH7AHbm9eS1ZDBwi+H7gzeHcsuhihn2z9HE38Jpkmut34W9uAfz99pPs0BRm0Ycrm1GNkL2H+nmRAJo4DJHXATu/yIIKPT6GsegIjMtQZ5kO5DZyBkCZBAKFpKnmiQq0A1/w5X839gDNY50WggM=","ARC-Message-Signature":"i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1765990039; c=relaxed/simple;\n bh=DSc2pyrQlBDyp+S9AFtOhWQjucGm7KXQ9BQGsGCj4dg=;\n h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version;\n b=VO+QQi/zzhw4Ze52NtDHOBGzSpAQOtmpGRjVXpV6Z8paXj8B6DKc93favxl8q2c8CRkaGKfrWNMow4vnIzEcqox24Ffz8aDWGTCYmfMlKFiKnRXRKtNQ+IW6vt5kdNXudwu0ez1jwKwvO1XlaDTJrfIWKgokPc0hY9mWjZ4XWA8=","ARC-Authentication-Results":"i=1; server2.sourceware.org","DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com;\n s=mimecast20190719; t=1765990038;\n h=from:from:reply-to:subject:subject:date:date:message-id:message-id:\n to:to:cc:mime-version:mime-version:content-type:content-type:\n in-reply-to:in-reply-to:references:references;\n bh=RgMJwUwdlXzu88Mlb1ZpCE4ekboi78aAxmJgT+cBOns=;\n b=Kr62Lf5jcS1oPxH9dTPFO9j9v9Grhz+dgPNC6wsQy5BdlK1qauw3KI4DNvpMxL+S+HYXKE\n XYtt4HsSkqhJyNmNyw15ArAKK+ZM9K9jbamGXsnhqO7ikbkPHQWjnqrphxzfdlnZpxIlJ7\n apBdfOVdLHhc4syPqZh1ryWRRgxkPoQ=","X-MC-Unique":"lmZTgZhTOtKGjeOkJgXVKQ-1","X-Mimecast-MFC-AGG-ID":"lmZTgZhTOtKGjeOkJgXVKQ_1765990037","X-Google-DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20230601; t=1765990036; x=1766594836;\n h=user-agent:in-reply-to:content-disposition:mime-version:references\n :message-id:subject:to:from:date:x-gm-gg:x-gm-message-state:from:to\n :cc:subject:date:message-id:reply-to;\n bh=RgMJwUwdlXzu88Mlb1ZpCE4ekboi78aAxmJgT+cBOns=;\n b=Qi+2WR5we/BJed6xrY9imlNH0GT9j6ZpinWNoqyx8wd1TwcEE/C++YE7hllY7N5tRk\n +kRAVZ++aSSZNHLrLP5MqPVAAl2eWB3KRdcCKIn/sziOeo5MU6oCUWjVNUKY8UGaMc+S\n PeGOYM/ik+vyxqED8H/KrJ+h2aQhOKCnjUseF4YXXLWzy7Gte5IgoEFL2V/yIguCBB28\n vlGsno8yp7x1gEzr16o4wLBj8I3CCLgxORrEtPcrEVPH6raLkRWdlrf8alxEITaeStfc\n CjItLj6DF4EPUIMfnSGw0XwKKFXW/xsvggtk+47EvoGUUa/X6OZHfPGLXHuCoMT1BQrh\n dSRw==","X-Gm-Message-State":"AOJu0Yz760KWUAVrHsHIPpWFxbg1bwfQ5nyX9UceedKaPHQMWzZfd65R\n Xgbsm9Jpe5c+O1a0Php5DVdTc1sTHQSKPw0GX3JvHq3RghG6CHjynJgQXYO/YTaN8wh0fkli20c\n SaCEKcgR9lG16+VJ4/FI3W4i0FhITORdG6Fb8L1UBeLxZt8zruoTkLO/nwICfXWJ5LYBG/qwPT/\n QG83SLWg26Ah/u27hecJRI9fYVfNqGPm6SqVF3eqPozw==","X-Gm-Gg":"AY/fxX6Iizivzrv8HnaphVWoEx7eqltyv29TcFLZOLBC4Jho3JZS5EuBN2nU5X81X15\n a/1v+WyEfV3B1jU3N2B8/N+LnmkrHJP1P/856Xtx/KwVWhjrDq4yicZpw/MVG3oyDsNObRBUGPs\n ERYc/sj8h8xW3tDl2ObF5v3wupquXPfj1jwwRxZwtfxjbkj3zMGW0UlLnubPW5pPYyMdtOWe4IX\n uJPE8V6UkZ8fFK/e381B4P2k5asEG+6DYUXNmlIoowIZAB1+4Oacl3U8rx/dFJQMacjdY5ydQ0O\n TmmLxhx4pgKlxrXbgAm93sHY+EKYNB/wXORjEssSsFe9b3+vKl1F/dDMAHhfRKpIkQ==","X-Received":["by 2002:a05:620a:2a15:b0:8b2:e4f0:74c4 with SMTP id\n af79cd13be357-8bb3a39bdc3mr2330181885a.84.1765990035273;\n Wed, 17 Dec 2025 08:47:15 -0800 (PST)","by 2002:a05:620a:2a15:b0:8b2:e4f0:74c4 with SMTP id\n af79cd13be357-8bb3a39bdc3mr2330174385a.84.1765990034389;\n Wed, 17 Dec 2025 08:47:14 -0800 (PST)"],"X-Google-Smtp-Source":"\n AGHT+IHc+6tLVy0Qz3QcsYm5z2X/6ZzBwFs4t7lLaJ7Ow5nfEaavFMYYWycVCYUL+VBkfNjKSScFgw==","Date":"Wed, 17 Dec 2025 11:47:11 -0500","From":"Marek Polacek ","To":"GCC Patches , Jason Merrill ,\n Jakub Jelinek , Jonathan Wakely ","Subject":"[PATCH 4/9 v2] c++: C++26 Reflection [PR120775]","Message-ID":"","References":"","MIME-Version":"1.0","In-Reply-To":"","User-Agent":"Mutt/2.2.14 (2025-02-20)","X-Mimecast-Spam-Score":"0","X-Mimecast-MFC-PROC-ID":"DEDOJ69gmmT3MWqu7FAj_wTT-aMXyLLCrv8ncxdj-uo_1765990037","X-Mimecast-Originator":"redhat.com","Content-Type":"text/plain; charset=us-ascii","Content-Disposition":"inline","X-BeenThere":"gcc-patches@gcc.gnu.org","X-Mailman-Version":"2.1.30","Precedence":"list","List-Id":"Gcc-patches mailing list ","List-Unsubscribe":",\n ","List-Archive":"","List-Post":"","List-Help":"","List-Subscribe":",\n ","Errors-To":"gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org"},"content":"This contains the libstdc++ bits (including ).\n\n-- >8 --","diff":"diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am\nindex 80f0b8bebd8..4e2c3f4c096 100644\n--- a/libstdc++-v3/include/Makefile.am\n+++ b/libstdc++-v3/include/Makefile.am\n@@ -89,6 +89,7 @@ std_headers = \\\n \t${std_srcdir}/locale \\\n \t${std_srcdir}/map \\\n \t${std_srcdir}/memory_resource \\\n+\t${std_srcdir}/meta \\\n \t${std_srcdir}/mutex \\\n \t${std_srcdir}/ostream \\\n \t${std_srcdir}/print \\\ndiff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in\nindex d108eb0155b..1dfb40385f5 100644\n--- a/libstdc++-v3/include/Makefile.in\n+++ b/libstdc++-v3/include/Makefile.in\n@@ -448,6 +448,7 @@ std_freestanding = \\\n @GLIBCXX_HOSTED_TRUE@\t${std_srcdir}/locale \\\n @GLIBCXX_HOSTED_TRUE@\t${std_srcdir}/map \\\n @GLIBCXX_HOSTED_TRUE@\t${std_srcdir}/memory_resource \\\n+@GLIBCXX_HOSTED_TRUE@\t${std_srcdir}/meta \\\n @GLIBCXX_HOSTED_TRUE@\t${std_srcdir}/mutex \\\n @GLIBCXX_HOSTED_TRUE@\t${std_srcdir}/ostream \\\n @GLIBCXX_HOSTED_TRUE@\t${std_srcdir}/print \\\ndiff --git a/libstdc++-v3/include/bits/iterator_concepts.h b/libstdc++-v3/include/bits/iterator_concepts.h\nindex 40ac808f6b6..1dfeda06907 100644\n--- a/libstdc++-v3/include/bits/iterator_concepts.h\n+++ b/libstdc++-v3/include/bits/iterator_concepts.h\n@@ -1005,7 +1005,7 @@ namespace ranges\n // for use by __range_iter_t below.\n template\n requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&>\n- auto\n+ constexpr auto\n __begin(_Tp& __t)\n {\n \tif constexpr (is_array_v<_Tp>)\ndiff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def\nindex 6405fe5d8a6..551516b61a4 100644\n--- a/libstdc++-v3/include/bits/version.def\n+++ b/libstdc++-v3/include/bits/version.def\n@@ -2245,6 +2245,15 @@ ftms = {\n };\n };\n \n+ftms = {\n+ name = reflection;\n+ values = {\n+ v = 202506;\n+ cxxmin = 26;\n+ extra_cond = \"__cpp_impl_reflection >= 202506L\";\n+ };\n+};\n+\n ftms = {\n name = is_implicit_lifetime;\n values = {\ndiff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h\nindex 2334b2d8c40..bb6e70ad955 100644\n--- a/libstdc++-v3/include/bits/version.h\n+++ b/libstdc++-v3/include/bits/version.h\n@@ -2526,4 +2526,14 @@\n #endif /* !defined(__cpp_lib_is_implicit_lifetime) */\n #undef __glibcxx_want_is_implicit_lifetime\n \n+#if !defined(__cpp_lib_reflection)\n+# if (__cplusplus > 202302L) && (__cpp_impl_reflection >= 202506L)\n+# define __glibcxx_reflection 202506L\n+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_reflection)\n+# define __cpp_lib_reflection 202506L\n+# endif\n+# endif\n+#endif /* !defined(__cpp_lib_reflection) */\n+#undef __glibcxx_want_reflection\n+\n #undef __glibcxx_want_all\ndiff --git a/libstdc++-v3/include/precompiled/stdc++.h b/libstdc++-v3/include/precompiled/stdc++.h\nindex 54baed43a5e..30de85d8c37 100644\n--- a/libstdc++-v3/include/precompiled/stdc++.h\n+++ b/libstdc++-v3/include/precompiled/stdc++.h\n@@ -234,6 +234,7 @@\n #if __cplusplus > 202302L\n #include \n #include \n+#include \n #include \n #include \n #include \ndiff --git a/libstdc++-v3/include/std/meta b/libstdc++-v3/include/std/meta\nnew file mode 100644\nindex 00000000000..cc47da1c592\n--- /dev/null\n+++ b/libstdc++-v3/include/std/meta\n@@ -0,0 +1,653 @@\n+// -*- C++ -*-\n+\n+// Copyright (C) 2025 Free Software Foundation, Inc.\n+//\n+// This file is part of the GNU ISO C++ Library. This library is free\n+// software; you can redistribute it and/or modify it under the\n+// terms of the GNU General Public License as published by the\n+// Free Software Foundation; either version 3, or (at your option)\n+// any later version.\n+\n+// This library is distributed in the hope that it will be useful,\n+// but WITHOUT ANY WARRANTY; without even the implied warranty of\n+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n+// GNU General Public License for more details.\n+\n+// Under Section 7 of GPL version 3, you are granted additional\n+// permissions described in the GCC Runtime Library Exception, version\n+// 3.1, as published by the Free Software Foundation.\n+\n+// You should have received a copy of the GNU General Public License and\n+// a copy of the GCC Runtime Library Exception along with this program;\n+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see\n+// .\n+\n+/** @file include/meta\n+ * This is a Standard C++ Library header.\n+ */\n+\n+#ifndef _GLIBCXX_META\n+#define _GLIBCXX_META 1\n+\n+#ifdef _GLIBCXX_SYSHDR\n+#pragma GCC system_header\n+#endif\n+\n+#define __glibcxx_want_reflection\n+#include \n+\n+#if __glibcxx_reflection >= 202506L // C++ >= 26 && __cpp_impl_reflection\n+\n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+\n+namespace std _GLIBCXX_VISIBILITY(default)\n+{\n+_GLIBCXX_BEGIN_NAMESPACE_VERSION\n+\n+#if __has_builtin(__builtin_is_string_literal)\n+ // [meta.string.literal], checking string literals\n+ consteval bool is_string_literal(const char* __p)\n+ {\n+ return __builtin_is_string_literal(__p);\n+ }\n+\n+ consteval bool is_string_literal(const wchar_t* __p)\n+ {\n+ return __builtin_is_string_literal(__p);\n+ }\n+\n+#ifdef _GLIBCXX_USE_CHAR8_T\n+ consteval bool is_string_literal(const char8_t* __p)\n+ {\n+ return __builtin_is_string_literal(__p);\n+ }\n+#endif\n+\n+ consteval bool is_string_literal(const char16_t* __p)\n+ {\n+ return __builtin_is_string_literal(__p);\n+ }\n+\n+ consteval bool is_string_literal(const char32_t* __p)\n+ {\n+ return __builtin_is_string_literal(__p);\n+ }\n+#endif\n+\n+ namespace meta\n+ {\n+ using info = decltype(^^int);\n+\n+ // [meta.reflection.exception], class exception\n+ class exception : public std::exception {\n+ private:\n+ string _M_what;\n+ u8string _M_u8what;\n+ info _M_from;\n+ source_location _M_where;\n+\n+ public:\n+ consteval\n+ exception(u8string_view __what, info __from,\n+\t\tsource_location __where = source_location::current()) noexcept\n+\t: _M_what{_S_exception_cvt_from_utf8(__what)}, _M_u8what{__what},\n+\t _M_from{__from}, _M_where{__where} {}\n+\n+ consteval\n+ exception(string_view __what, info __from,\n+\t\tsource_location __where = source_location::current()) noexcept\n+\t: _M_what{__what}, _M_u8what{_S_exception_cvt_to_utf8(__what)},\n+\t _M_from{__from}, _M_where{__where} {}\n+\n+ consteval exception(const exception&) = default;\n+ consteval exception(exception&&) = default;\n+\n+ consteval exception& operator=(const exception&) = default;\n+ consteval exception& operator=(exception&&) = default;\n+\n+ consteval const char*\n+ what() const noexcept override\n+ {\n+\t// If u8string is not empty and string is empty, conversion\n+\t// from UTF-8 to ordinary literal encoding failed.\n+\t// In that case what() should be non-constant.\n+\tif (_M_what.size() == 0 && _M_u8what.size() != 0)\n+\t asm(\"\");\n+\treturn _M_what.c_str();\n+ }\n+ consteval u8string_view u8what() const noexcept { return _M_u8what; }\n+ consteval info from() const noexcept { return _M_from; }\n+ consteval source_location where() const noexcept { return _M_where; }\n+ private:\n+ // Helper special template metafunctions to convert from UTF-8 to\n+ // ordinary literal encoding and vice versa. On conversion failure\n+ // they just return an empty {,u8}string_view.\n+ template\n+\tstatic consteval u8string_view _S_exception_cvt_to_utf8(_Rg&&);\n+ template\n+\tstatic consteval string_view _S_exception_cvt_from_utf8(_Rg&&);\n+ };\n+\n+ // [meta.reflection.operators], operator representations\n+ enum class operators {\n+ op_new = 1,\n+ op_delete,\n+ op_array_new,\n+ op_array_delete,\n+ op_co_await,\n+ op_parentheses,\n+ op_square_brackets,\n+ op_arrow,\n+ op_arrow_star,\n+ op_tilde,\n+ op_exclamation,\n+ op_plus,\n+ op_minus,\n+ op_star,\n+ op_slash,\n+ op_percent,\n+ op_caret,\n+ op_ampersand,\n+ op_equals,\n+ op_pipe,\n+ op_plus_equals,\n+ op_minus_equals,\n+ op_star_equals,\n+ op_slash_equals,\n+ op_percent_equals,\n+ op_caret_equals,\n+ op_ampersand_equals,\n+ op_pipe_equals,\n+ op_equals_equals,\n+ op_exclamation_equals,\n+ op_less,\n+ op_greater,\n+ op_less_equals,\n+ op_greater_equals,\n+ op_spaceship,\n+ op_ampersand_ampersand,\n+ op_pipe_pipe,\n+ op_less_less,\n+ op_greater_greater,\n+ op_less_less_equals,\n+ op_greater_greater_equals,\n+ op_plus_plus,\n+ op_minus_minus,\n+ op_comma\n+ };\n+ using enum operators;\n+ consteval operators operator_of(info);\n+ consteval string_view symbol_of(operators);\n+ consteval u8string_view u8symbol_of(operators);\n+\n+ // [meta.reflection.names], reflection names and locations\n+ consteval bool has_identifier(info);\n+\n+ consteval string_view identifier_of(info);\n+ consteval u8string_view u8identifier_of(info);\n+\n+ consteval string_view display_string_of(info);\n+ consteval u8string_view u8display_string_of(info);\n+\n+ consteval source_location source_location_of(info);\n+\n+ // [meta.reflection.queries], reflection queries\n+ consteval info type_of(info);\n+ consteval info object_of(info);\n+ consteval info constant_of(info);\n+\n+ consteval bool is_public(info);\n+ consteval bool is_protected(info);\n+ consteval bool is_private(info);\n+\n+ consteval bool is_virtual(info);\n+ consteval bool is_pure_virtual(info);\n+ consteval bool is_override(info);\n+ consteval bool is_final(info);\n+\n+ consteval bool is_deleted(info);\n+ consteval bool is_defaulted(info);\n+ consteval bool is_user_provided(info);\n+ consteval bool is_user_declared(info);\n+ consteval bool is_explicit(info);\n+ consteval bool is_noexcept(info);\n+\n+ consteval bool is_bit_field(info);\n+ consteval bool is_enumerator(info);\n+ consteval bool is_annotation(info);\n+\n+ consteval bool is_const(info);\n+ consteval bool is_volatile(info);\n+ consteval bool is_mutable_member(info);\n+ consteval bool is_lvalue_reference_qualified(info);\n+ consteval bool is_rvalue_reference_qualified(info);\n+\n+ consteval bool has_static_storage_duration(info);\n+ consteval bool has_thread_storage_duration(info);\n+ consteval bool has_automatic_storage_duration(info);\n+\n+ consteval bool has_internal_linkage(info);\n+ consteval bool has_module_linkage(info);\n+ consteval bool has_external_linkage(info);\n+ consteval bool has_c_language_linkage(info);\n+ consteval bool has_linkage(info);\n+\n+ consteval bool is_complete_type(info);\n+ consteval bool is_enumerable_type(info);\n+\n+ consteval bool is_variable(info);\n+ consteval bool is_type(info);\n+ consteval bool is_namespace(info);\n+ consteval bool is_type_alias(info);\n+ consteval bool is_namespace_alias(info);\n+\n+ consteval bool is_function(info);\n+ consteval bool is_conversion_function(info);\n+ consteval bool is_operator_function(info);\n+ consteval bool is_literal_operator(info);\n+ consteval bool is_special_member_function(info);\n+ consteval bool is_constructor(info);\n+ consteval bool is_default_constructor(info);\n+ consteval bool is_copy_constructor(info);\n+ consteval bool is_move_constructor(info);\n+ consteval bool is_assignment(info);\n+ consteval bool is_copy_assignment(info);\n+ consteval bool is_move_assignment(info);\n+ consteval bool is_destructor(info);\n+\n+ consteval bool is_function_parameter(info);\n+ consteval bool is_explicit_object_parameter(info);\n+ consteval bool has_default_argument(info);\n+ consteval bool has_ellipsis_parameter(info);\n+\n+ consteval bool is_template(info);\n+ consteval bool is_function_template(info);\n+ consteval bool is_variable_template(info);\n+ consteval bool is_class_template(info);\n+ consteval bool is_alias_template(info);\n+ consteval bool is_conversion_function_template(info);\n+ consteval bool is_operator_function_template(info);\n+ consteval bool is_literal_operator_template(info);\n+ consteval bool is_constructor_template(info);\n+ consteval bool is_concept(info);\n+\n+ consteval bool is_value(info);\n+ consteval bool is_object(info);\n+\n+ consteval bool is_structured_binding(info);\n+\n+ consteval bool is_class_member(info);\n+ consteval bool is_namespace_member(info);\n+ consteval bool is_nonstatic_data_member(info);\n+ consteval bool is_static_member(info);\n+ consteval bool is_base(info);\n+\n+ consteval bool has_default_member_initializer(info);\n+\n+ consteval bool has_parent(info);\n+ consteval info parent_of(info);\n+\n+ consteval info dealias(info);\n+\n+ consteval bool has_template_arguments(info);\n+ consteval info template_of(info);\n+ consteval vector template_arguments_of(info);\n+ consteval vector parameters_of(info);\n+ consteval info variable_of(info);\n+ consteval info return_type_of(info);\n+\n+ // [meta.reflection.access.context], access control context\n+ struct access_context {\n+ private:\n+ consteval access_context(info __scope, info __designating_class) noexcept\n+\t: _M_scope{__scope}, _M_designating_class{__designating_class} { }\n+ public:\n+ access_context() = delete;\n+ consteval access_context(const access_context &) = default;\n+ consteval access_context(access_context &&) = default;\n+\n+ consteval info scope() const { return _M_scope; }\n+ consteval info designating_class() const { return _M_designating_class; }\n+\n+ static consteval access_context current() noexcept;\n+ static consteval access_context unprivileged() noexcept\n+ { return access_context { ^^::, info {} }; }\n+ static consteval access_context unchecked() noexcept\n+ { return access_context { info {}, info {} }; }\n+ consteval access_context via(info) const;\n+\n+ info _M_scope;\n+ info _M_designating_class;\n+ };\n+\n+ // [meta.reflection.access.queries], member accessibility queries\n+ consteval bool is_accessible(info, access_context);\n+ consteval bool has_inaccessible_nonstatic_data_members(info,\n+\t\t\t\t\t\t\t access_context);\n+ consteval bool has_inaccessible_bases(info, access_context);\n+ consteval bool has_inaccessible_subobjects(info, access_context);\n+\n+ // [meta.reflection.member.queries], reflection member queries\n+ consteval vector members_of(info, access_context);\n+ consteval vector bases_of(info, access_context);\n+ consteval vector static_data_members_of(info, access_context);\n+ consteval vector nonstatic_data_members_of(info, access_context);\n+ consteval vector subobjects_of(info, access_context);\n+ consteval vector enumerators_of(info);\n+\n+ // [meta.reflection.layout], reflection layout queries\n+ struct member_offset {\n+ ptrdiff_t bytes;\n+ ptrdiff_t bits;\n+\n+ constexpr ptrdiff_t\n+ total_bits() const\n+ { return bytes * __CHAR_BIT__ + bits; }\n+\n+ auto operator<=>(const member_offset&) const = default;\n+ };\n+\n+ consteval member_offset offset_of(info);\n+ consteval size_t size_of(info);\n+ consteval size_t alignment_of(info);\n+ consteval size_t bit_size_of(info);\n+\n+ // [meta.reflection.extract], value extraction\n+ template\n+ consteval _Tp extract(info);\n+\n+ // [meta.reflection.substitute], reflection substitution\n+ template\n+ concept reflection_range = ranges::input_range<_Rg>\n+\t&& same_as, info>\n+\t&& same_as>, info>;\n+\n+ template>\n+ consteval bool can_substitute(info, _Rg&&);\n+ template>\n+ consteval info substitute(info, _Rg&&);\n+\n+ // [meta.reflection.result], expression result reflection\n+ template\n+ requires (is_copy_constructible_v<_Tp>)\n+ consteval info reflect_constant(_Tp);\n+ template\n+ requires (!is_function_v>)\n+ consteval info reflect_object(_Tp&);\n+ template\n+ requires (is_function_v>)\n+ consteval info reflect_function(_Tp&);\n+\n+ // [meta.reflection.array], promoting to static storage arrays\n+ template\n+ consteval info reflect_constant_string(_Rg&&);\n+\n+ template\n+ consteval info reflect_constant_array(_Rg&&);\n+\n+ // [meta.reflection.define.aggregate], class definition generation\n+ struct data_member_options {\n+ struct _Name {\n+\ttemplate\n+\t requires constructible_from\n+\t consteval _Name(_Tp&& __n) : _M_is_u8(true), _M_u8s((_Tp&&) __n) {}\n+\n+\ttemplate\n+\t requires constructible_from\n+\t consteval _Name(_Tp&& __n) : _M_is_u8(false), _M_s((_Tp&&) __n) {}\n+\n+ private:\n+\tbool _M_is_u8;\n+\tu8string _M_u8s;\n+\tstring _M_s;\n+\tinfo _M_unused = {};\n+ };\n+\n+ optional<_Name> name;\n+ optional alignment;\n+ optional bit_width;\n+ bool no_unique_address = false;\n+ };\n+ consteval info data_member_spec(info, data_member_options);\n+ consteval bool is_data_member_spec(info);\n+ template>\n+ consteval info define_aggregate(info, _Rg&&);\n+\n+ // associated with [meta.unary.cat], primary type categories\n+ consteval bool is_void_type(info);\n+ consteval bool is_null_pointer_type(info);\n+ consteval bool is_integral_type(info);\n+ consteval bool is_floating_point_type(info);\n+ consteval bool is_array_type(info);\n+ consteval bool is_pointer_type(info);\n+ consteval bool is_lvalue_reference_type(info);\n+ consteval bool is_rvalue_reference_type(info);\n+ consteval bool is_member_object_pointer_type(info);\n+ consteval bool is_member_function_pointer_type(info);\n+ consteval bool is_enum_type(info);\n+ consteval bool is_union_type(info);\n+ consteval bool is_class_type(info);\n+ consteval bool is_function_type(info);\n+ consteval bool is_reflection_type(info);\n+\n+ // associated with [meta.unary.comp], composite type categories\n+ consteval bool is_reference_type(info);\n+ consteval bool is_arithmetic_type(info);\n+ consteval bool is_fundamental_type(info);\n+ consteval bool is_object_type(info);\n+ consteval bool is_scalar_type(info);\n+ consteval bool is_compound_type(info);\n+ consteval bool is_member_pointer_type(info);\n+\n+ // associated with [meta.unary.prop], type properties\n+ consteval bool is_const_type(info);\n+ consteval bool is_volatile_type(info);\n+ consteval bool is_trivially_copyable_type(info);\n+ consteval bool is_standard_layout_type(info);\n+ consteval bool is_empty_type(info);\n+ consteval bool is_polymorphic_type(info);\n+ consteval bool is_abstract_type(info);\n+ consteval bool is_final_type(info);\n+ consteval bool is_aggregate_type(info);\n+ consteval bool is_consteval_only_type(info);\n+ consteval bool is_signed_type(info);\n+ consteval bool is_unsigned_type(info);\n+ consteval bool is_bounded_array_type(info);\n+ consteval bool is_unbounded_array_type(info);\n+ consteval bool is_scoped_enum_type(info);\n+\n+ template>\n+ consteval bool is_constructible_type(info, _Rg&&);\n+ consteval bool is_default_constructible_type(info);\n+ consteval bool is_copy_constructible_type(info);\n+ consteval bool is_move_constructible_type(info);\n+\n+ consteval bool is_assignable_type(info, info);\n+ consteval bool is_copy_assignable_type(info);\n+ consteval bool is_move_assignable_type(info);\n+\n+ consteval bool is_swappable_with_type(info, info);\n+ consteval bool is_swappable_type(info);\n+\n+ consteval bool is_destructible_type(info);\n+\n+ template>\n+ consteval bool is_trivially_constructible_type(info, _Rg&&);\n+ consteval bool is_trivially_default_constructible_type(info);\n+ consteval bool is_trivially_copy_constructible_type(info);\n+ consteval bool is_trivially_move_constructible_type(info);\n+\n+ consteval bool is_trivially_assignable_type(info, info);\n+ consteval bool is_trivially_copy_assignable_type(info);\n+ consteval bool is_trivially_move_assignable_type(info);\n+ consteval bool is_trivially_destructible_type(info);\n+\n+ template>\n+ consteval bool is_nothrow_constructible_type(info, _Rg&&);\n+ consteval bool is_nothrow_default_constructible_type(info);\n+ consteval bool is_nothrow_copy_constructible_type(info);\n+ consteval bool is_nothrow_move_constructible_type(info);\n+\n+ consteval bool is_nothrow_assignable_type(info, info);\n+ consteval bool is_nothrow_copy_assignable_type(info);\n+ consteval bool is_nothrow_move_assignable_type(info);\n+\n+ consteval bool is_nothrow_swappable_with_type(info, info);\n+ consteval bool is_nothrow_swappable_type(info);\n+\n+ consteval bool is_nothrow_destructible_type(info);\n+\n+ consteval bool is_implicit_lifetime_type(info);\n+\n+ consteval bool has_virtual_destructor(info);\n+\n+ consteval bool has_unique_object_representations(info);\n+\n+ consteval bool reference_constructs_from_temporary(info, info);\n+ consteval bool reference_converts_from_temporary(info, info);\n+\n+ // associated with [meta.unary.prop.query], type property queries\n+ consteval size_t rank(info);\n+ consteval size_t extent(info, unsigned = 0);\n+\n+ // associated with [meta.rel], type relations\n+ consteval bool is_same_type(info, info);\n+ consteval bool is_base_of_type(info, info);\n+ consteval bool is_virtual_base_of_type(info, info);\n+ consteval bool is_convertible_type(info, info);\n+ consteval bool is_nothrow_convertible_type(info, info);\n+ consteval bool is_layout_compatible_type(info, info);\n+ consteval bool is_pointer_interconvertible_base_of_type(info, info);\n+\n+ template>\n+ consteval bool is_invocable_type(info, _Rg&&);\n+ template>\n+ consteval bool is_invocable_r_type(info, info, _Rg&&);\n+\n+ template>\n+ consteval bool is_nothrow_invocable_type(info, _Rg&&);\n+ template>\n+ consteval bool is_nothrow_invocable_r_type(info, info, _Rg&&);\n+\n+ // associated with [meta.trans.cv], const-volatile modifications\n+ consteval info remove_const(info);\n+ consteval info remove_volatile(info);\n+ consteval info remove_cv(info);\n+ consteval info add_const(info);\n+ consteval info add_volatile(info);\n+ consteval info add_cv(info);\n+\n+ // associated with [meta.trans.ref], reference modifications\n+ consteval info remove_reference(info);\n+ consteval info add_lvalue_reference(info);\n+ consteval info add_rvalue_reference(info);\n+\n+ // associated with [meta.trans.sign], sign modifications\n+ consteval info make_signed(info);\n+ consteval info make_unsigned(info);\n+\n+ // associated with [meta.trans.arr], array modifications\n+ consteval info remove_extent(info);\n+ consteval info remove_all_extents(info);\n+\n+ // associated with [meta.trans.ptr], pointer modifications\n+ consteval info remove_pointer(info);\n+ consteval info add_pointer(info);\n+\n+ // associated with [meta.trans.other], other transformations\n+ consteval info remove_cvref(info);\n+ consteval info decay(info);\n+ template>\n+ consteval info common_type(_Rg&&);\n+ template>\n+ consteval info common_reference(_Rg&&);\n+ consteval info underlying_type(info);\n+ template>\n+ consteval info invoke_result(info, _Rg&&);\n+ consteval info unwrap_reference(info);\n+ consteval info unwrap_ref_decay(info);\n+\n+ consteval size_t tuple_size(info);\n+ consteval info tuple_element(size_t, info);\n+\n+ consteval size_t variant_size(info);\n+ consteval info variant_alternative(size_t, info);\n+\n+ consteval strong_ordering type_order(info, info);\n+\n+ // [meta.reflection.annotation], annotation reflection\n+ consteval vector annotations_of(info);\n+ consteval vector annotations_of_with_type(info, info);\n+\n+ consteval access_context\n+ access_context::via(info __cls) const\n+ {\n+ if (__cls != info {}\n+\t && (!std::meta::is_class_type(__cls)\n+\t || !std::meta::is_complete_type(__cls)))\n+\t{\n+#if __cpp_exceptions\n+\t throw std::meta::exception(u8\"via argument other than null \"\n+\t\t\t\t \"or complete class type reflection\",\n+\t\t\t\t ^^access_context::via);\n+#else\n+\t asm(\"\");\n+\t return *this;\n+#endif\n+\t}\n+ return access_context { _M_scope, __cls };\n+ }\n+\n+ } // namespace meta\n+\n+ // [meta.define.static], promoting to static storage strings\n+ template\n+ consteval const ranges::range_value_t<_Rg>*\n+ define_static_string(_Rg&& __r)\n+ {\n+ auto __str = meta::reflect_constant_string(__r);\n+ return meta::extract*>(__str);\n+ }\n+\n+ template\n+ consteval span>\n+ define_static_array(_Rg&& __r)\n+ {\n+ using _Tp = ranges::range_value_t<_Rg>;\n+ auto __array = meta::reflect_constant_array(__r);\n+ auto __type = meta::type_of(__array);\n+ if (meta::is_array_type(__type))\n+\treturn span(meta::extract(__array),\n+\t\t\t meta::extent(__type, 0U));\n+ else\n+\treturn span();\n+ }\n+\n+ template\n+ consteval const remove_cvref_t<_Tp>*\n+ define_static_object(_Tp&& __t)\n+ {\n+ using _Up = remove_cvref_t<_Tp>;\n+ if constexpr (meta::is_class_type(^^_Up))\n+\t{\n+\t auto __cst = meta::reflect_constant(std::forward<_Tp>(__t));\n+\t return std::addressof(meta::extract(__cst));\n+\t}\n+ else\n+\treturn std::define_static_array(span(std::addressof(__t),\n+\t\t\t\t\t\t\t1)).data();\n+ }\n+\n+_GLIBCXX_END_NAMESPACE_VERSION\n+} // namespace std\n+\n+#endif // C++26\n+\n+#endif // _GLIBCXX_META\ndiff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits\nindex 8a7d123408f..4cae83a19f0 100644\n--- a/libstdc++-v3/include/std/type_traits\n+++ b/libstdc++-v3/include/std/type_traits\n@@ -749,6 +749,29 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n : public false_type { };\n #endif\n \n+#if __cpp_impl_reflection >= 202500L // C++ >= 26\n+ /// is_reflection\n+ template\n+ struct is_reflection\n+ : public false_type { };\n+\n+ template<>\n+ struct is_reflection\n+ : public true_type { };\n+\n+ template<>\n+ struct is_reflection\n+ : public true_type { };\n+\n+ template<>\n+ struct is_reflection\n+ : public true_type { };\n+\n+ template<>\n+ struct is_reflection\n+ : public true_type { };\n+#endif\n+\n #ifdef __cpp_lib_is_null_pointer // C++ >= 11\n /// is_null_pointer (LWG 2247).\n template\n@@ -814,7 +837,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n template\n struct is_fundamental\n : public __or_, is_void<_Tp>,\n-\t\t is_null_pointer<_Tp>>::type\n+\t\t is_null_pointer<_Tp>\n+#if __cpp_impl_reflection >= 202500L\n+\t\t , is_reflection<_Tp>\n+#endif\n+\t\t >::type\n { };\n \n /// is_object\n@@ -3528,6 +3555,19 @@ template \n is_member_function_pointer<_Tp>::value;\n #endif\n \n+#if __cpp_impl_reflection >= 202500L // C++ >= 26\n+template \n+ inline constexpr bool is_reflection_v = false;\n+template <>\n+ inline constexpr bool is_reflection_v = true;\n+template <>\n+ inline constexpr bool is_reflection_v = true;\n+template <>\n+ inline constexpr bool is_reflection_v = true;\n+template <>\n+ inline constexpr bool is_reflection_v = true;\n+#endif\n+\n template \n inline constexpr bool is_enum_v = __is_enum(_Tp);\n template \n@@ -3860,6 +3900,24 @@ template\n # endif\n #endif\n \n+#if __cpp_impl_reflection >= 202500L \\\n+ && _GLIBCXX_USE_BUILTIN_TRAIT(__builtin_is_consteval_only) // C++ >= 26\n+ /// is_consteval_only - true if the type is consteval-only.\n+ /// @since C++26\n+ template\n+ struct is_consteval_only\n+ : bool_constant<__builtin_is_consteval_only(_Tp)>\n+ { };\n+\n+ /** is_consteval_only_v - true if the type is consteval-only.\n+ * @ingroup variable_templates\n+ * @since C++26\n+ */\n+ template\n+ inline constexpr bool is_consteval_only_v\n+ = __builtin_is_consteval_only(_Tp);\n+#endif\n+\n /** * Remove references and cv-qualifiers.\n * @since C++20\n * @{\ndiff --git a/libstdc++-v3/src/c++23/std.cc.in b/libstdc++-v3/src/c++23/std.cc.in\nindex ef0da5d685a..e134e395bb6 100644\n--- a/libstdc++-v3/src/c++23/std.cc.in\n+++ b/libstdc++-v3/src/c++23/std.cc.in\n@@ -2057,6 +2057,261 @@ export namespace std::pmr\n using std::pmr::unsynchronized_pool_resource;\n }\n \n+// \n+#if __glibcxx_reflection >= 202506L\n+export namespace std\n+{\n+#if __has_builtin(__builtin_is_string_literal)\n+ using std::is_string_literal;\n+#endif\n+ using std::define_static_string;\n+ using std::define_static_array;\n+ using std::define_static_object;\n+ namespace meta\n+ {\n+ using std::meta::info;\n+ using std::meta::exception;\n+ using std::meta::operators;\n+ using enum std::meta::operators;\n+ using std::meta::operator_of;\n+ using std::meta::symbol_of;\n+ using std::meta::u8symbol_of;\n+ using std::meta::has_identifier;\n+ using std::meta::identifier_of;\n+ using std::meta::u8identifier_of;\n+ using std::meta::display_string_of;\n+ using std::meta::u8display_string_of;\n+ using std::meta::source_location_of;\n+ using std::meta::type_of;\n+ using std::meta::object_of;\n+ using std::meta::constant_of;\n+ using std::meta::is_public;\n+ using std::meta::is_protected;\n+ using std::meta::is_private;\n+ using std::meta::is_virtual;\n+ using std::meta::is_pure_virtual;\n+ using std::meta::is_override;\n+ using std::meta::is_final;\n+ using std::meta::is_deleted;\n+ using std::meta::is_defaulted;\n+ using std::meta::is_user_provided;\n+ using std::meta::is_user_declared;\n+ using std::meta::is_explicit;\n+ using std::meta::is_noexcept;\n+ using std::meta::is_bit_field;\n+ using std::meta::is_enumerator;\n+ using std::meta::is_annotation;\n+ using std::meta::is_const;\n+ using std::meta::is_volatile;\n+ using std::meta::is_mutable_member;\n+ using std::meta::is_lvalue_reference_qualified;\n+ using std::meta::is_rvalue_reference_qualified;\n+ using std::meta::has_static_storage_duration;\n+ using std::meta::has_thread_storage_duration;\n+ using std::meta::has_automatic_storage_duration;\n+ using std::meta::has_internal_linkage;\n+ using std::meta::has_module_linkage;\n+ using std::meta::has_external_linkage;\n+ using std::meta::has_c_language_linkage;\n+ using std::meta::has_linkage;\n+ using std::meta::is_complete_type;\n+ using std::meta::is_enumerable_type;\n+ using std::meta::is_variable;\n+ using std::meta::is_type;\n+ using std::meta::is_namespace;\n+ using std::meta::is_type_alias;\n+ using std::meta::is_namespace_alias;\n+ using std::meta::is_function;\n+ using std::meta::is_conversion_function;\n+ using std::meta::is_operator_function;\n+ using std::meta::is_literal_operator;\n+ using std::meta::is_special_member_function;\n+ using std::meta::is_constructor;\n+ using std::meta::is_default_constructor;\n+ using std::meta::is_copy_constructor;\n+ using std::meta::is_move_constructor;\n+ using std::meta::is_assignment;\n+ using std::meta::is_copy_assignment;\n+ using std::meta::is_move_assignment;\n+ using std::meta::is_destructor;\n+ using std::meta::is_function_parameter;\n+ using std::meta::is_explicit_object_parameter;\n+ using std::meta::has_default_argument;\n+ using std::meta::has_ellipsis_parameter;\n+ using std::meta::is_template;\n+ using std::meta::is_function_template;\n+ using std::meta::is_variable_template;\n+ using std::meta::is_class_template;\n+ using std::meta::is_alias_template;\n+ using std::meta::is_conversion_function_template;\n+ using std::meta::is_operator_function_template;\n+ using std::meta::is_literal_operator_template;\n+ using std::meta::is_constructor_template;\n+ using std::meta::is_concept;\n+ using std::meta::is_value;\n+ using std::meta::is_object;\n+ using std::meta::is_structured_binding;\n+ using std::meta::is_class_member;\n+ using std::meta::is_namespace_member;\n+ using std::meta::is_nonstatic_data_member;\n+ using std::meta::is_static_member;\n+ using std::meta::is_base;\n+ using std::meta::has_default_member_initializer;\n+ using std::meta::has_parent;\n+ using std::meta::parent_of;\n+ using std::meta::dealias;\n+ using std::meta::has_template_arguments;\n+ using std::meta::template_of;\n+ using std::meta::template_arguments_of;\n+ using std::meta::parameters_of;\n+ using std::meta::variable_of;\n+ using std::meta::return_type_of;\n+ using std::meta::access_context;\n+ using std::meta::is_accessible;\n+ using std::meta::has_inaccessible_nonstatic_data_members;\n+ using std::meta::has_inaccessible_bases;\n+ using std::meta::has_inaccessible_subobjects;\n+ using std::meta::members_of;\n+ using std::meta::bases_of;\n+ using std::meta::static_data_members_of;\n+ using std::meta::nonstatic_data_members_of;\n+ using std::meta::subobjects_of;\n+ using std::meta::enumerators_of;\n+ using std::meta::member_offset;\n+ using std::meta::offset_of;\n+ using std::meta::size_of;\n+ using std::meta::alignment_of;\n+ using std::meta::bit_size_of;\n+ using std::meta::extract;\n+ using std::meta::reflection_range;\n+ using std::meta::can_substitute;\n+ using std::meta::substitute;\n+ using std::meta::reflect_constant;\n+ using std::meta::reflect_object;\n+ using std::meta::reflect_function;\n+ using std::meta::reflect_constant_string;\n+ using std::meta::reflect_constant_array;\n+ using std::meta::data_member_options;\n+ using std::meta::data_member_spec;\n+ using std::meta::is_data_member_spec;\n+ using std::meta::define_aggregate;\n+ using std::meta::is_void_type;\n+ using std::meta::is_null_pointer_type;\n+ using std::meta::is_integral_type;\n+ using std::meta::is_floating_point_type;\n+ using std::meta::is_array_type;\n+ using std::meta::is_pointer_type;\n+ using std::meta::is_lvalue_reference_type;\n+ using std::meta::is_rvalue_reference_type;\n+ using std::meta::is_member_object_pointer_type;\n+ using std::meta::is_member_function_pointer_type;\n+ using std::meta::is_enum_type;\n+ using std::meta::is_union_type;\n+ using std::meta::is_class_type;\n+ using std::meta::is_function_type;\n+ using std::meta::is_reflection_type;\n+ using std::meta::is_reference_type;\n+ using std::meta::is_arithmetic_type;\n+ using std::meta::is_fundamental_type;\n+ using std::meta::is_object_type;\n+ using std::meta::is_scalar_type;\n+ using std::meta::is_compound_type;\n+ using std::meta::is_member_pointer_type;\n+ using std::meta::is_const_type;\n+ using std::meta::is_volatile_type;\n+ using std::meta::is_trivially_copyable_type;\n+ using std::meta::is_standard_layout_type;\n+ using std::meta::is_empty_type;\n+ using std::meta::is_polymorphic_type;\n+ using std::meta::is_abstract_type;\n+ using std::meta::is_final_type;\n+ using std::meta::is_aggregate_type;\n+ using std::meta::is_consteval_only_type;\n+ using std::meta::is_signed_type;\n+ using std::meta::is_unsigned_type;\n+ using std::meta::is_bounded_array_type;\n+ using std::meta::is_unbounded_array_type;\n+ using std::meta::is_scoped_enum_type;\n+ using std::meta::is_constructible_type;\n+ using std::meta::is_default_constructible_type;\n+ using std::meta::is_copy_constructible_type;\n+ using std::meta::is_move_constructible_type;\n+ using std::meta::is_assignable_type;\n+ using std::meta::is_copy_assignable_type;\n+ using std::meta::is_move_assignable_type;\n+ using std::meta::is_swappable_with_type;\n+ using std::meta::is_swappable_type;\n+ using std::meta::is_destructible_type;\n+ using std::meta::is_trivially_constructible_type;\n+ using std::meta::is_trivially_default_constructible_type;\n+ using std::meta::is_trivially_copy_constructible_type;\n+ using std::meta::is_trivially_move_constructible_type;\n+ using std::meta::is_trivially_assignable_type;\n+ using std::meta::is_trivially_copy_assignable_type;\n+ using std::meta::is_trivially_move_assignable_type;\n+ using std::meta::is_trivially_destructible_type;\n+ using std::meta::is_nothrow_constructible_type;\n+ using std::meta::is_nothrow_default_constructible_type;\n+ using std::meta::is_nothrow_copy_constructible_type;\n+ using std::meta::is_nothrow_move_constructible_type;\n+ using std::meta::is_nothrow_assignable_type;\n+ using std::meta::is_nothrow_copy_assignable_type;\n+ using std::meta::is_nothrow_move_assignable_type;\n+ using std::meta::is_nothrow_swappable_with_type;\n+ using std::meta::is_nothrow_swappable_type;\n+ using std::meta::is_nothrow_destructible_type;\n+ using std::meta::is_implicit_lifetime_type;\n+ using std::meta::has_virtual_destructor;\n+ using std::meta::has_unique_object_representations;\n+ using std::meta::reference_constructs_from_temporary;\n+ using std::meta::reference_converts_from_temporary;\n+ using std::meta::rank;\n+ using std::meta::extent;\n+ using std::meta::is_same_type;\n+ using std::meta::is_base_of_type;\n+ using std::meta::is_virtual_base_of_type;\n+ using std::meta::is_convertible_type;\n+ using std::meta::is_nothrow_convertible_type;\n+ using std::meta::is_layout_compatible_type;\n+ using std::meta::is_pointer_interconvertible_base_of_type;\n+ using std::meta::is_invocable_type;\n+ using std::meta::is_invocable_r_type;\n+ using std::meta::is_nothrow_invocable_type;\n+ using std::meta::is_nothrow_invocable_r_type;\n+ using std::meta::remove_const;\n+ using std::meta::remove_volatile;\n+ using std::meta::remove_cv;\n+ using std::meta::add_const;\n+ using std::meta::add_volatile;\n+ using std::meta::add_cv;\n+ using std::meta::remove_reference;\n+ using std::meta::add_lvalue_reference;\n+ using std::meta::add_rvalue_reference;\n+ using std::meta::make_signed;\n+ using std::meta::make_unsigned;\n+ using std::meta::remove_extent;\n+ using std::meta::remove_all_extents;\n+ using std::meta::remove_pointer;\n+ using std::meta::add_pointer;\n+ using std::meta::remove_cvref;\n+ using std::meta::decay;\n+ using std::meta::common_type;\n+ using std::meta::common_reference;\n+ using std::meta::underlying_type;\n+ using std::meta::invoke_result;\n+ using std::meta::unwrap_reference;\n+ using std::meta::unwrap_ref_decay;\n+ using std::meta::tuple_size;\n+ using std::meta::tuple_element;\n+ using std::meta::variant_size;\n+ using std::meta::variant_alternative;\n+ using std::meta::type_order;\n+ using std::meta::annotations_of;\n+ using std::meta::annotations_of_with_type;\n+ }\n+}\n+#endif\n+\n // \n export namespace std\n {\ndiff --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\nnew file mode 100644\nindex 00000000000..d890f144ef9\n--- /dev/null\n+++ b/libstdc++-v3/testsuite/20_util/is_consteval_only/requirements/explicit_instantiation.cc\n@@ -0,0 +1,12 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+// NB: This file is for testing type_traits with NO OTHER INCLUDES.\n+\n+#include \n+\n+namespace std\n+{\n+ typedef short test_type;\n+ template struct is_consteval_only;\n+}\ndiff --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\nnew file mode 100644\nindex 00000000000..29fb44c0dc1\n--- /dev/null\n+++ b/libstdc++-v3/testsuite/20_util/is_consteval_only/requirements/typedefs.cc\n@@ -0,0 +1,16 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+// NB: This file is for testing type_traits with NO OTHER INCLUDES.\n+\n+#include \n+\n+void test01()\n+{\n+ // Check for required typedefs\n+ typedef std::is_consteval_only test_type;\n+ typedef test_type::value_type value_type;\n+ typedef test_type::type type;\n+ typedef test_type::type::value_type type_value_type;\n+ typedef test_type::type::type type_type;\n+}\ndiff --git a/libstdc++-v3/testsuite/20_util/is_consteval_only/value.cc b/libstdc++-v3/testsuite/20_util/is_consteval_only/value.cc\nnew file mode 100644\nindex 00000000000..7852a618d31\n--- /dev/null\n+++ b/libstdc++-v3/testsuite/20_util/is_consteval_only/value.cc\n@@ -0,0 +1,30 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+#include \n+#include \n+\n+void test01()\n+{\n+ using std::is_consteval_only;\n+ using namespace __gnu_test;\n+ int v = 1;\n+ struct S1 { decltype(^^long) a; };\n+ union U2 { int a; decltype(^^test01) b; };\n+ struct S3 { const decltype(^^__gnu_test) *c; };\n+ struct S4 : public S3 {};\n+ struct S5 { int a; long *b; };\n+\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+\n+ // Sanity check.\n+ static_assert(test_category(false), \"\");\n+ static_assert(test_category(false), \"\");\n+}\ndiff --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\nnew file mode 100644\nindex 00000000000..6d53380600e\n--- /dev/null\n+++ b/libstdc++-v3/testsuite/20_util/is_reflection/requirements/explicit_instantiation.cc\n@@ -0,0 +1,12 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+// NB: This file is for testing type_traits with NO OTHER INCLUDES.\n+\n+#include \n+\n+namespace std\n+{\n+ typedef short test_type;\n+ template struct is_reflection;\n+}\ndiff --git a/libstdc++-v3/testsuite/20_util/is_reflection/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_reflection/requirements/typedefs.cc\nnew file mode 100644\nindex 00000000000..ab5c36659a9\n--- /dev/null\n+++ b/libstdc++-v3/testsuite/20_util/is_reflection/requirements/typedefs.cc\n@@ -0,0 +1,16 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+// NB: This file is for testing type_traits with NO OTHER INCLUDES.\n+\n+#include \n+\n+void test01()\n+{\n+ // Check for required typedefs\n+ typedef std::is_reflection test_type;\n+ typedef test_type::value_type value_type;\n+ typedef test_type::type type;\n+ typedef test_type::type::value_type type_value_type;\n+ typedef test_type::type::type type_type;\n+}\ndiff --git a/libstdc++-v3/testsuite/20_util/is_reflection/value.cc b/libstdc++-v3/testsuite/20_util/is_reflection/value.cc\nnew file mode 100644\nindex 00000000000..57f47d6a124\n--- /dev/null\n+++ b/libstdc++-v3/testsuite/20_util/is_reflection/value.cc\n@@ -0,0 +1,20 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+#include \n+#include \n+\n+void test01()\n+{\n+ using std::is_reflection;\n+ using namespace __gnu_test;\n+ int v = 1;\n+\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+ static_assert(test_category(true), \"\");\n+\n+ // Sanity check.\n+ static_assert(test_category(false), \"\");\n+}\ndiff --git a/libstdc++-v3/testsuite/20_util/variable_templates_for_traits.cc b/libstdc++-v3/testsuite/20_util/variable_templates_for_traits.cc\nindex b48958746e1..ca37533404b 100644\n--- a/libstdc++-v3/testsuite/20_util/variable_templates_for_traits.cc\n+++ b/libstdc++-v3/testsuite/20_util/variable_templates_for_traits.cc\n@@ -1,5 +1,6 @@\n // { dg-additional-options \"-Wno-deprecated-declarations\" { target c++2a } }\n // { dg-do compile { target c++17 } }\n+// { dg-additional-options \"-freflection\" { target c++26 } }\n \n // Copyright (C) 2014-2025 Free Software Foundation, Inc.\n //\n@@ -330,6 +331,15 @@ static_assert(is_convertible_v\n static_assert(!is_convertible_v\n \t && !is_convertible::value, \"\");\n \n+#if __cpp_impl_reflection >= 202500L\n+static_assert(is_reflection_v\n+\t && is_reflection::value, \"\");\n+static_assert(!is_reflection_v && !is_reflection::value, \"\");\n+static_assert(is_consteval_only_v\n+\t && is_consteval_only::value, \"\");\n+static_assert(!is_consteval_only_v && !is_consteval_only::value, \"\");\n+#endif\n+\n static_assert(negation_v, \"\");\n static_assert(!negation_v, \"\");\n static_assert(conjunction_v<>, \"\");\n","prefixes":["4/9","v2"]}