Patch Detail
get:
Show a patch.
patch:
Update a patch.
put:
Update a patch.
GET /api/1.0/patches/2175268/?format=api
{ "id": 2175268, "url": "http://patchwork.ozlabs.org/api/1.0/patches/2175268/?format=api", "project": { "id": 17, "url": "http://patchwork.ozlabs.org/api/1.0/projects/17/?format=api", "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": "<aULej7pJ334aqEsf@redhat.com>", "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=api", "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=api", "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": "<gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org>", "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 <incoming@patchwork.ozlabs.org>; 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 <incoming@patchwork.ozlabs.org>; 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 <gcc-patches@gcc.gnu.org>; 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 <gcc-patches@gcc.gnu.org>; 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 <polacek@redhat.com>", "To": "GCC Patches <gcc-patches@gcc.gnu.org>, Jason Merrill <jason@redhat.com>,\n Jakub Jelinek <jakub@redhat.com>, Jonathan Wakely <jwakely@redhat.com>", "Subject": "[PATCH 4/9 v2] c++: C++26 Reflection [PR120775]", "Message-ID": "<aULej7pJ334aqEsf@redhat.com>", "References": "<aULdgYtbcyGQIxK1@redhat.com>", "MIME-Version": "1.0", "In-Reply-To": "<aULdgYtbcyGQIxK1@redhat.com>", "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 <gcc-patches.gcc.gnu.org>", "List-Unsubscribe": "<https://gcc.gnu.org/mailman/options/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=unsubscribe>", "List-Archive": "<https://gcc.gnu.org/pipermail/gcc-patches/>", "List-Post": "<mailto:gcc-patches@gcc.gnu.org>", "List-Help": "<mailto:gcc-patches-request@gcc.gnu.org?subject=help>", "List-Subscribe": "<https://gcc.gnu.org/mailman/listinfo/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=subscribe>", "Errors-To": "gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org" }, "content": "This contains the libstdc++ bits (including <meta>).\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<typename _Tp>\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 <debugging>\n #include <inplace_vector>\n+#include <meta>\n #include <text_encoding>\n #include <stdbit.h>\n #include <stdckdint.h>\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+// <meta> -*- 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+// <http://www.gnu.org/licenses/>.\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 <bits/version.h>\n+\n+#if __glibcxx_reflection >= 202506L // C++ >= 26 && __cpp_impl_reflection\n+\n+#include <array>\n+#include <initializer_list>\n+#include <optional>\n+#include <source_location>\n+#include <span>\n+#include <string>\n+#include <string_view>\n+#include <vector>\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<ranges::input_range _Rg>\n+\tstatic consteval u8string_view _S_exception_cvt_to_utf8(_Rg&&);\n+ template<ranges::input_range _Rg>\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<info> template_arguments_of(info);\n+ consteval vector<info> 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<info> members_of(info, access_context);\n+ consteval vector<info> bases_of(info, access_context);\n+ consteval vector<info> static_data_members_of(info, access_context);\n+ consteval vector<info> nonstatic_data_members_of(info, access_context);\n+ consteval vector<info> subobjects_of(info, access_context);\n+ consteval vector<info> 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<class _Tp>\n+ consteval _Tp extract(info);\n+\n+ // [meta.reflection.substitute], reflection substitution\n+ template<class _Rg>\n+ concept reflection_range = ranges::input_range<_Rg>\n+\t&& same_as<ranges::range_value_t<_Rg>, info>\n+\t&& same_as<remove_cvref_t<ranges::range_reference_t<_Rg>>, info>;\n+\n+ template<reflection_range _Rg = initializer_list<info>>\n+ consteval bool can_substitute(info, _Rg&&);\n+ template<reflection_range _Rg = initializer_list<info>>\n+ consteval info substitute(info, _Rg&&);\n+\n+ // [meta.reflection.result], expression result reflection\n+ template<typename _Tp>\n+ requires (is_copy_constructible_v<_Tp>)\n+ consteval info reflect_constant(_Tp);\n+ template<typename _Tp>\n+ requires (!is_function_v<remove_reference_t<_Tp>>)\n+ consteval info reflect_object(_Tp&);\n+ template<typename _Tp>\n+ requires (is_function_v<remove_reference_t<_Tp>>)\n+ consteval info reflect_function(_Tp&);\n+\n+ // [meta.reflection.array], promoting to static storage arrays\n+ template<ranges::input_range _Rg>\n+ consteval info reflect_constant_string(_Rg&&);\n+\n+ template<ranges::input_range _Rg>\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<class _Tp>\n+\t requires constructible_from<u8string, _Tp>\n+\t consteval _Name(_Tp&& __n) : _M_is_u8(true), _M_u8s((_Tp&&) __n) {}\n+\n+\ttemplate<class _Tp>\n+\t requires constructible_from<string, _Tp>\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<int> alignment;\n+ optional<int> 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<reflection_range _Rg = initializer_list<info>>\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<reflection_range _Rg = initializer_list<info>>\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<reflection_range _Rg = initializer_list<info>>\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<reflection_range _Rg = initializer_list<info>>\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<reflection_range _Rg = initializer_list<info>>\n+ consteval bool is_invocable_type(info, _Rg&&);\n+ template<reflection_range _Rg = initializer_list<info>>\n+ consteval bool is_invocable_r_type(info, info, _Rg&&);\n+\n+ template<reflection_range _Rg = initializer_list<info>>\n+ consteval bool is_nothrow_invocable_type(info, _Rg&&);\n+ template<reflection_range _Rg = initializer_list<info>>\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<reflection_range _Rg = initializer_list<info>>\n+ consteval info common_type(_Rg&&);\n+ template<reflection_range _Rg = initializer_list<info>>\n+ consteval info common_reference(_Rg&&);\n+ consteval info underlying_type(info);\n+ template<reflection_range _Rg = initializer_list<info>>\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<info> annotations_of(info);\n+ consteval vector<info> 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<ranges::input_range _Rg>\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<const ranges::range_value_t<_Rg>*>(__str);\n+ }\n+\n+ template<ranges::input_range _Rg>\n+ consteval span<const ranges::range_value_t<_Rg>>\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<const _Tp>(meta::extract<const _Tp*>(__array),\n+\t\t\t meta::extent(__type, 0U));\n+ else\n+\treturn span<const _Tp>();\n+ }\n+\n+ template<class _Tp>\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<const _Up&>(__cst));\n+\t}\n+ else\n+\treturn std::define_static_array(span<const _Up>(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<typename _Tp>\n+ struct is_reflection\n+ : public false_type { };\n+\n+ template<>\n+ struct is_reflection<decltype(^^int)>\n+ : public true_type { };\n+\n+ template<>\n+ struct is_reflection<const decltype(^^int)>\n+ : public true_type { };\n+\n+ template<>\n+ struct is_reflection<volatile decltype(^^int)>\n+ : public true_type { };\n+\n+ template<>\n+ struct is_reflection<const volatile decltype(^^int)>\n+ : public true_type { };\n+#endif\n+\n #ifdef __cpp_lib_is_null_pointer // C++ >= 11\n /// is_null_pointer (LWG 2247).\n template<typename _Tp>\n@@ -814,7 +837,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n template<typename _Tp>\n struct is_fundamental\n : public __or_<is_arithmetic<_Tp>, 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 <typename _Tp>\n is_member_function_pointer<_Tp>::value;\n #endif\n \n+#if __cpp_impl_reflection >= 202500L // C++ >= 26\n+template <typename _Tp>\n+ inline constexpr bool is_reflection_v = false;\n+template <>\n+ inline constexpr bool is_reflection_v<decltype(^^int)> = true;\n+template <>\n+ inline constexpr bool is_reflection_v<const decltype(^^int)> = true;\n+template <>\n+ inline constexpr bool is_reflection_v<volatile decltype(^^int)> = true;\n+template <>\n+ inline constexpr bool is_reflection_v<const volatile decltype(^^int)> = true;\n+#endif\n+\n template <typename _Tp>\n inline constexpr bool is_enum_v = __is_enum(_Tp);\n template <typename _Tp>\n@@ -3860,6 +3900,24 @@ template<typename _Ret, typename _Fn, typename... _Args>\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<typename _Tp>\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<typename _Tp>\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+// <meta>\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 // <mutex>\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 <type_traits>\n+\n+namespace std\n+{\n+ typedef short test_type;\n+ template struct is_consteval_only<test_type>;\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 <type_traits>\n+\n+void test01()\n+{\n+ // Check for required typedefs\n+ typedef std::is_consteval_only<decltype (^^int)> 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 <type_traits>\n+#include <testsuite_tr1.h>\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<is_consteval_only, decltype(^^long)>(true), \"\");\n+ static_assert(test_category<is_consteval_only, const decltype(^^test01)>(true), \"\");\n+ static_assert(test_category<is_consteval_only, volatile decltype(^^__gnu_test)>(true), \"\");\n+ static_assert(test_category<is_consteval_only, const volatile decltype(^^v)>(true), \"\");\n+ static_assert(test_category<is_consteval_only, const S1>(true), \"\");\n+ static_assert(test_category<is_consteval_only, U2>(true), \"\");\n+ static_assert(test_category<is_consteval_only, S3>(true), \"\");\n+ static_assert(test_category<is_consteval_only, S4>(true), \"\");\n+\n+ // Sanity check.\n+ static_assert(test_category<is_consteval_only, int>(false), \"\");\n+ static_assert(test_category<is_consteval_only, S5>(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 <type_traits>\n+\n+namespace std\n+{\n+ typedef short test_type;\n+ template struct is_reflection<test_type>;\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 <type_traits>\n+\n+void test01()\n+{\n+ // Check for required typedefs\n+ typedef std::is_reflection<decltype (^^int)> 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 <type_traits>\n+#include <testsuite_tr1.h>\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<is_reflection, decltype(^^long)>(true), \"\");\n+ static_assert(test_category<is_reflection, const decltype(^^test01)>(true), \"\");\n+ static_assert(test_category<is_reflection, volatile decltype(^^__gnu_test)>(true), \"\");\n+ static_assert(test_category<is_reflection, const volatile decltype(^^v)>(true), \"\");\n+\n+ // Sanity check.\n+ static_assert(test_category<is_reflection, int>(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<int&, const int&>\n static_assert(!is_convertible_v<const int&, int&>\n \t && !is_convertible<const int&, int&>::value, \"\");\n \n+#if __cpp_impl_reflection >= 202500L\n+static_assert(is_reflection_v<decltype(^^int)>\n+\t && is_reflection<decltype(^^int)>::value, \"\");\n+static_assert(!is_reflection_v<int> && !is_reflection<int>::value, \"\");\n+static_assert(is_consteval_only_v<decltype(^^int)>\n+\t && is_consteval_only<decltype(^^int)>::value, \"\");\n+static_assert(!is_consteval_only_v<int> && !is_consteval_only<int>::value, \"\");\n+#endif\n+\n static_assert(negation_v<false_type>, \"\");\n static_assert(!negation_v<true_type>, \"\");\n static_assert(conjunction_v<>, \"\");\n", "prefixes": [ "4/9", "v2" ] }