{"id":2175269,"url":"http://patchwork.ozlabs.org/api/1.0/patches/2175269/?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:48:38","name":"[7/9,v2] c++: C++26 Reflection [PR120775]","commit_ref":null,"pull_url":null,"state":"new","archived":false,"hash":"840ec68876b6c4a1a2ed0d2f0a364873378c552d","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/aULe5lYWiY_kS1Kh@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/2175269/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=bE2EI5Nx;\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=bE2EI5Nx","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.129.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 4dWftG3P2Dz1xpw\n\tfor ; Thu, 18 Dec 2025 03:50:14 +1100 (AEDT)","from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 5EBFF4BA2E2D\n\tfor ; Wed, 17 Dec 2025 16:50:12 +0000 (GMT)","from us-smtp-delivery-124.mimecast.com\n (us-smtp-delivery-124.mimecast.com [170.10.129.124])\n by sourceware.org (Postfix) with ESMTP id 95F664BA2E26\n for ; Wed, 17 Dec 2025 16:48:49 +0000 (GMT)","from mail-qv1-f72.google.com (mail-qv1-f72.google.com\n [209.85.219.72]) by relay.mimecast.com with ESMTP with STARTTLS\n (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id\n us-mta-515-qm8_GwmDN0Wg5mDrkqn8Pg-1; Wed, 17 Dec 2025 11:48:46 -0500","by mail-qv1-f72.google.com with SMTP id\n 6a1803df08f44-88a31ce8214so89474076d6.2\n for ; Wed, 17 Dec 2025 08:48:46 -0800 (PST)","from redhat.com ([2603:7000:9500:10::1db4])\n by smtp.gmail.com with ESMTPSA id\n 6a1803df08f44-8899ea36210sm98129556d6.27.2025.12.17.08.48.39\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Wed, 17 Dec 2025 08:48:40 -0800 (PST)"],"DKIM-Filter":["OpenDKIM Filter v2.11.0 sourceware.org 5EBFF4BA2E2D","OpenDKIM Filter v2.11.0 sourceware.org 95F664BA2E26"],"DMARC-Filter":"OpenDMARC Filter v1.4.2 sourceware.org 95F664BA2E26","ARC-Filter":"OpenARC Filter v1.0.0 sourceware.org 95F664BA2E26","ARC-Seal":"i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1765990129; cv=none;\n b=rdQmoynyAd22qgsmX7i24JMfU9vI+xCxs+7cSpFTQM4zDVZKJgn2gFFPwAEP9KyrMirgFvJWqImXsRObPnNfAHNAsc4n94Ck7ORAKUhdXa5SHajSCUisnJZqF8NXiBVCLF6LUpBdiHmsq03IurkRkBWhsFoj4aY23TQDymFk7Pw=","ARC-Message-Signature":"i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1765990129; c=relaxed/simple;\n bh=mDnSliTy+W312Ns1dIxAFKLIxYAeloT410tSnYYzHNM=;\n h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version;\n b=hLlZSoWrlqfqEdVsh4QD3xcADA2gqOhtcBjVpgXViKDL5bmkxMiA6tzYrHV0F7IE2wQIEC6n89hmDtFTsnQyIaXBcZdmlYiuZrX6kF3NixuefZRNP4wxbzeGEn6APX1drZvOejBN0riUh68j0ECLIwNbr0Fg6nSxhYZifGiO7/g=","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=1765990129;\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 content-transfer-encoding:content-transfer-encoding:\n in-reply-to:in-reply-to:references:references;\n bh=KDUvWwcpVomE27pvBqxUnwa58zBX8edmf5b+1X1PmlA=;\n b=bE2EI5NxiPBhb96Li14YQL84BYI007LjgV5iZmeWehtqewhPkyeaOoI6uhbwbw6wmYeIWm\n R4p9S3R7Wz5jYhsHIH+QmizP3Z+pVBKvNwRIMaktDc/2lEwg4r9i1mktbQrfddicWuCBfK\n P3Uk9jf6/aUSr1dtOYw4Q5LZx6DJJ5U=","X-MC-Unique":"qm8_GwmDN0Wg5mDrkqn8Pg-1","X-Mimecast-MFC-AGG-ID":"qm8_GwmDN0Wg5mDrkqn8Pg_1765990126","X-Google-DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20230601; t=1765990126; x=1766594926;\n h=user-agent:in-reply-to:content-transfer-encoding\n :content-disposition:mime-version:references:message-id:subject:to\n :from:date:x-gm-gg:x-gm-message-state:from:to:cc:subject:date\n :message-id:reply-to;\n bh=KDUvWwcpVomE27pvBqxUnwa58zBX8edmf5b+1X1PmlA=;\n b=t7L3O0qIm+3gWE8dn8CxDIAIWDgBo6So7XHxfmzqCPIld2SptbtJDM3wiEOwnsBZVs\n X7DFnXlnumff0C+m8i4rO44XxTnMCbfXVHeQTvnQUmiCK1jdlzUk4TOsaV4ehZRejbzN\n hk2Mi50TVcXbIcYJB5KnWi5gooOvzY3a+IpWEzhKlrOuGc/oUhBj9VcRjL4s/0+MLjti\n W0NOPSUWVGe5JYkOcIJP5vIITYFTjGF8MLDOZ5M5aM03j4c+FN1t94qtS2KJqp44KKjZ\n l3gf4WUdtk8fkAyrnyUiHgmAedbBcccTIvdL88gcJORnwmybpHb/oRqL02VpyGBqDBPt\n rw1g==","X-Gm-Message-State":"AOJu0YyXQUOq0IMOEAKzQUqw9HLGG1EpyL6tu8rJ8DpSXvszMBzcckk0\n H/FtlE65AsyZgVOOoFFEWqRkgG8Ya6yV1vfKkCybfReLQNVOQ9E6q2CkKy9aT6QaKy60Uw9hklo\n Ndv+RDgriX0LH57qx3DAw4KE/IRufqB0I2YC4qjtK202lQb8Excm5D9aroKKa0UwIalwv7UnrEp\n /VhwtnUV4Xpn9dbbKl1RTiSREDZK/rsuE1WjQyCXmM0g==","X-Gm-Gg":"AY/fxX5Gm1m92ju4OtrGTFCC3kVelz4pvHzvzKm5QgwvNJj9YNuIetggYmLroHgmXNg\n vtD0rBac+du+p38fBaTvex0+R9DD5NCOMX6iW38WDsalKdnAw8yyNrr2kw4YnvVLIR3AqbiJeUu\n x8rGoGwmY3qfcb3yIR47maDIuJtMEFY5CScXrXLTOiFr1P0Z4pS0YFi1mwtbz72X/ot+8UhLJQ1\n wLl10CcKGnpMTUfjOU2yAs8s1jhHN4D+gYOp9yKJBePQtlaNHc+32cJNuBKR0j08+AbICU+3p+D\n WC8QBbjNEi7n/ienjDpywyNrTbjUKFWqh0eZ85cJvIdQzRMpzMmOOYSOX26NhuKa4A==","X-Received":["by 2002:ad4:5bcf:0:b0:880:5779:d489 with SMTP id\n 6a1803df08f44-8887e019eadmr288724046d6.3.1765990123665;\n Wed, 17 Dec 2025 08:48:43 -0800 (PST)","by 2002:ad4:5bcf:0:b0:880:5779:d489 with SMTP id\n 6a1803df08f44-8887e019eadmr288722056d6.3.1765990121106;\n Wed, 17 Dec 2025 08:48:41 -0800 (PST)"],"X-Google-Smtp-Source":"\n AGHT+IHjrxECvK2K8h6iuigjH2r244KWXgaxwpEhk96PxtsYf9lK4EX+ZrQIOdPRD6lRkoSvFhYcxw==","Date":"Wed, 17 Dec 2025 11:48:38 -0500","From":"Marek Polacek ","To":"GCC Patches , Jason Merrill ,\n Jakub Jelinek , Jonathan Wakely ","Subject":"[PATCH 7/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":"nkjXlttmtXTT5s8slN2OW9d7JPHBh-ZDW8C5IamtQu0_1765990126","X-Mimecast-Originator":"redhat.com","Content-Type":"text/plain; charset=iso-8859-1","Content-Disposition":"inline","Content-Transfer-Encoding":"8bit","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":"Testsuite bits part #3.\n\n-- >8 --","diff":"diff --git a/gcc/testsuite/g++.dg/reflect/is_function_template1.C b/gcc/testsuite/g++.dg/reflect/is_function_template1.C\nnew file mode 100644\nindex 00000000000..bdefc7e8901\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_function_template1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_function_template.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_function_template (null_reflection));\n+static_assert (!is_function_template (^^::));\n+static_assert (!is_function_template (^^ns));\n+static_assert (!is_function_template (^^ns_alias));\n+static_assert (!is_function_template (reflect_constant (3)));\n+static_assert (!is_function_template (^^cls));\n+static_assert (!is_function_template (^^cls::dm));\n+static_assert (!is_function_template (^^cls::ref_dm));\n+static_assert (!is_function_template (^^cls::static_dm));\n+static_assert (!is_function_template (^^cls::mem_fun));\n+static_assert (!is_function_template (^^cls::static_mem_fun));\n+static_assert (!is_function_template (^^cls::type));\n+static_assert (!is_function_template (^^cls_var));\n+static_assert (!is_function_template (^^onion));\n+static_assert (!is_function_template (^^anon));\n+static_assert (!is_function_template (^^fun));\n+static_assert (!is_function_template (^^alias));\n+static_assert (!is_function_template (^^var));\n+static_assert (!is_function_template (^^ref));\n+static_assert (!is_function_template (^^rref));\n+static_assert (!is_function_template (^^ptr));\n+static_assert (!is_function_template (^^cls_tmpl));\n+static_assert (!is_function_template (^^cls_tmpl));\n+static_assert (!is_function_template (^^incomplete_cls));\n+static_assert (is_function_template (^^fun_tmpl));\n+static_assert (!is_function_template (^^fun_tmpl));\n+static_assert (!is_function_template (^^conc));\n+static_assert (!is_function_template (substitute (^^conc, { ^^int })));\n+static_assert (!is_function_template (^^var_tmpl));\n+static_assert (!is_function_template (^^var_tmpl));\n+static_assert (!is_function_template (^^cls_tmpl_alias));\n+static_assert (!is_function_template (^^cls_tmpl_alias));\n+static_assert (!is_function_template (^^Enum));\n+static_assert (!is_function_template (^^Enum::A));\n+static_assert (!is_function_template (^^Enum_class));\n+static_assert (!is_function_template (^^Enum_class::A));\n+static_assert (!is_function_template (^^decomp));\n+static_assert (!is_function_template (^^decomp_ref));\n+static_assert (!is_function_template (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_function_template (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_function_template (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_function_template (^^T));\n+ static_assert (!is_function_template (R));\n+ static_assert (!is_function_template (R2));\n+ static_assert (is_function_template (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_function_template (^^p));\n+ static_assert (!is_function_template (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_function_template2.C b/gcc/testsuite/g++.dg/reflect/is_function_template2.C\nnew file mode 100644\nindex 00000000000..e104cf59ba9\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_function_template2.C\n@@ -0,0 +1,44 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_function_template.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+struct S {\n+ template\n+ void ovl (T) { }\n+\n+ template\n+ void static_ovl (T) { }\n+};\n+\n+static_assert (is_function_template (^^S::ovl));\n+static_assert (!is_function_template (^^S::ovl));\n+static_assert (is_function_template (^^S::static_ovl));\n+static_assert (!is_function_template (^^S::static_ovl));\n+\n+static_assert (!is_function_template (^^void()));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (is_function_template (R1));\n+ static_assert (!is_function_template (R2));\n+}\n+\n+template\n+void\n+g ()\n+{\n+ f<^^S::ovl, ^^S::ovl>();\n+ f<^^S::static_ovl, ^^S::static_ovl>();\n+}\n+\n+void\n+h ()\n+{\n+ g();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_function_type1.C b/gcc/testsuite/g++.dg/reflect/is_function_type1.C\nnew file mode 100644\nindex 00000000000..f8d07e35f39\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_function_type1.C\n@@ -0,0 +1,26 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_function_type.\n+\n+#include \n+using namespace std::meta;\n+\n+struct cls {\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+};\n+int fun (bool, char) noexcept { return 0; }\n+\n+static_assert (is_function_type (type_of (^^cls::mem_fun)));\n+static_assert (is_function_type (type_of (^^cls::static_mem_fun)));\n+static_assert (is_function_type (type_of (^^::fun)));\n+static_assert (!is_function_type (^^void(*)(short)));\n+static_assert (is_function_type (remove_pointer (^^void(*)(short))));\n+static_assert (!is_function_type (remove_pointer (^^void(**)(short))));\n+static_assert (is_function_type (remove_pointer (remove_pointer (^^void(**)(short)))));\n+static_assert (!is_function_type (^^void(&)()));\n+static_assert (is_function_type (remove_reference (^^void(&)())));\n+using U = void(*)(void);\n+static_assert (!is_function_type (^^U[3]));\n+static_assert (is_function_type (remove_pointer (remove_extent (^^U[3]))));\n+static_assert (!is_function_type (remove_pointer (^^int (cls::*)())));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_literal_operator1.C b/gcc/testsuite/g++.dg/reflect/is_literal_operator1.C\nnew file mode 100644\nindex 00000000000..0d180ae326e\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_literal_operator1.C\n@@ -0,0 +1,56 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_literal_operator.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+void foo ();\n+\n+struct S {\n+ S &operator+(const S&);\n+\n+ template \n+ S &operator-(const S&);\n+\n+ operator int();\n+\n+ void fn();\n+};\n+\n+struct T {\n+ template \n+ operator T();\n+};\n+\n+bool operator&&(const S&, const S&);\n+\n+template \n+bool operator||(const S&, const T&);\n+\n+int operator\"\"_a(const char *);\n+\n+template\n+int operator\"\"_b();\n+\n+constexpr auto conversion_template\n+ = (members_of (^^T, access_context::current ()) | std::views::filter (std::meta::is_template)).front ();\n+\n+static_assert (!is_literal_operator (null_reflection));\n+static_assert (!is_literal_operator (^^int));\n+static_assert (!is_literal_operator (^^::));\n+static_assert (!is_literal_operator (^^foo));\n+static_assert (!is_literal_operator (^^S::operator+));\n+static_assert (!is_literal_operator (^^operator&&));\n+static_assert (!is_literal_operator (^^operator||));\n+static_assert (!is_literal_operator (^^operator||));\n+static_assert (!is_literal_operator (^^S::operator-));\n+static_assert (!is_literal_operator (^^S::operator-));\n+static_assert (!is_literal_operator (^^S::operator int));\n+static_assert (!is_literal_operator (conversion_template));\n+static_assert (!is_literal_operator (^^S::fn));\n+static_assert (is_literal_operator (^^operator\"\"_a));\n+static_assert (!is_literal_operator (^^operator\"\"_b));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_literal_operator_template1.C b/gcc/testsuite/g++.dg/reflect/is_literal_operator_template1.C\nnew file mode 100644\nindex 00000000000..a6bd4102af5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_literal_operator_template1.C\n@@ -0,0 +1,56 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_literal_operator_template.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+void foo ();\n+\n+struct S {\n+ S &operator+(const S&);\n+\n+ template \n+ S &operator-(const S&);\n+\n+ operator int();\n+\n+ void fn();\n+};\n+\n+struct T {\n+ template \n+ operator T();\n+};\n+\n+bool operator&&(const S&, const S&);\n+\n+template \n+bool operator||(const S&, const T&);\n+\n+int operator\"\"_a(const char *);\n+\n+template\n+int operator\"\"_b();\n+\n+constexpr auto conversion_template\n+ = (members_of (^^T, access_context::current ()) | std::views::filter (is_template)).front ();\n+\n+static_assert (!is_literal_operator_template (null_reflection));\n+static_assert (!is_literal_operator_template (^^int));\n+static_assert (!is_literal_operator_template (^^::));\n+static_assert (!is_literal_operator_template (^^foo));\n+static_assert (!is_literal_operator_template (^^S::operator+));\n+static_assert (!is_literal_operator_template (^^operator&&));\n+static_assert (!is_literal_operator_template (^^operator||));\n+static_assert (!is_literal_operator_template (^^operator||));\n+static_assert (!is_literal_operator_template (^^S::operator-));\n+static_assert (!is_literal_operator_template (^^S::operator-));\n+static_assert (!is_literal_operator_template (^^S::operator int));\n+static_assert (!is_literal_operator_template (conversion_template));\n+static_assert (!is_literal_operator_template (^^S::fn));\n+static_assert (!is_literal_operator_template (^^operator\"\"_a));\n+static_assert (is_literal_operator_template (^^operator\"\"_b));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_lrvalue_reference_qualified1.C b/gcc/testsuite/g++.dg/reflect/is_lrvalue_reference_qualified1.C\nnew file mode 100644\nindex 00000000000..d97a2d0988a\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_lrvalue_reference_qualified1.C\n@@ -0,0 +1,93 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_[lr]value_reference_qualified.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+struct S {\n+ void fn1 ();\n+ void fn2 () &;\n+ void fn3 () &&;\n+ static void fn4 ();\n+ /* Static member functions cannot have ref-qualifiers. */\n+ template\n+ void fn5 ();\n+ template\n+ void fn6 () &;\n+ template\n+ void fn7 () &&;\n+};\n+\n+void foo ();\n+template\n+void bar ();\n+/* Non-member functions cannot have ref-qualifiers. */\n+\n+static_assert (!is_lvalue_reference_qualified (^^S::fn1));\n+static_assert (!is_rvalue_reference_qualified (^^S::fn1));\n+\n+static_assert (is_lvalue_reference_qualified (^^S::fn2));\n+static_assert (!is_rvalue_reference_qualified (^^S::fn2));\n+\n+static_assert (!is_lvalue_reference_qualified (^^S::fn3));\n+static_assert (is_rvalue_reference_qualified (^^S::fn3));\n+\n+static_assert (!is_lvalue_reference_qualified (^^S::fn4));\n+static_assert (!is_rvalue_reference_qualified (^^S::fn4));\n+\n+static_assert (!is_lvalue_reference_qualified (^^S::fn5));\n+static_assert (!is_rvalue_reference_qualified (^^S::fn5));\n+\n+static_assert (is_lvalue_reference_qualified (^^S::fn6));\n+static_assert (!is_rvalue_reference_qualified (^^S::fn6));\n+\n+static_assert (!is_lvalue_reference_qualified (^^S::fn7));\n+static_assert (is_rvalue_reference_qualified (^^S::fn7));\n+\n+static_assert (!is_lvalue_reference_qualified (^^::foo));\n+static_assert (!is_rvalue_reference_qualified (^^::foo));\n+\n+static_assert (!is_lvalue_reference_qualified (^^::bar));\n+static_assert (!is_rvalue_reference_qualified (^^::bar));\n+\n+static_assert (!is_lvalue_reference_qualified (type_of (^^S::fn1)));\n+static_assert (!is_rvalue_reference_qualified (type_of (^^S::fn1)));\n+\n+static_assert (is_lvalue_reference_qualified (type_of (^^S::fn2)));\n+static_assert (!is_rvalue_reference_qualified (type_of (^^S::fn2)));\n+\n+static_assert (!is_lvalue_reference_qualified (type_of (^^S::fn3)));\n+static_assert (is_rvalue_reference_qualified (type_of (^^S::fn3)));\n+\n+static_assert (!is_lvalue_reference_qualified (type_of (^^S::fn4)));\n+static_assert (!is_rvalue_reference_qualified (type_of (^^S::fn4)));\n+\n+static_assert (!is_lvalue_reference_qualified (type_of (^^S::fn5)));\n+static_assert (!is_rvalue_reference_qualified (type_of (^^S::fn5)));\n+\n+static_assert (is_lvalue_reference_qualified (type_of (^^S::fn6)));\n+static_assert (!is_rvalue_reference_qualified (type_of (^^S::fn6)));\n+\n+static_assert (!is_lvalue_reference_qualified (type_of (^^S::fn7)));\n+static_assert (is_rvalue_reference_qualified (type_of (^^S::fn7)));\n+\n+static_assert (!is_lvalue_reference_qualified (type_of (^^::foo)));\n+static_assert (!is_rvalue_reference_qualified (type_of (^^::foo)));\n+\n+static_assert (!is_lvalue_reference_qualified (type_of (^^::bar)));\n+static_assert (!is_rvalue_reference_qualified (type_of (^^::bar)));\n+\n+static_assert (!is_lvalue_reference_qualified (^^void (int)));\n+static_assert (!is_rvalue_reference_qualified (^^void (int)));\n+\n+static_assert (is_lvalue_reference_qualified (^^void (int) &));\n+static_assert (!is_rvalue_reference_qualified (^^void (int) &));\n+\n+static_assert (!is_lvalue_reference_qualified (^^void (int) &&));\n+static_assert (is_rvalue_reference_qualified (^^void (int) &&));\n+\n+static_assert (!is_lvalue_reference_qualified (std::meta::info {}));\n+static_assert (!is_lvalue_reference_qualified (^^int));\n+static_assert (!is_lvalue_reference_qualified (^^::));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_move_assignment1.C b/gcc/testsuite/g++.dg/reflect/is_move_assignment1.C\nnew file mode 100644\nindex 00000000000..6153b10a31e\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_move_assignment1.C\n@@ -0,0 +1,101 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_move_assignment.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+void foo ();\n+\n+struct S {\n+ S ()\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ }\n+ S (int)\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ }\n+ S (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ }\n+ S (S &&)\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ }\n+ S &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+ S &operator += (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+ void bar ()\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ }\n+ ~S ()\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ }\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct U {\n+ template \n+ U (T &)\n+ {\n+ T a;\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ }\n+ U &operator = (U &&)\n+ {\n+ int a;\n+ static_assert (is_move_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct V {\n+ V (int a = 42, long b = 18)\n+ {\n+ static_assert (!is_move_assignment (parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (!is_move_assignment (null_reflection));\n+static_assert (!is_move_assignment (^^int));\n+static_assert (!is_move_assignment (^^::));\n+static_assert (!is_move_assignment (^^foo));\n+static_assert (!is_move_assignment (^^S::bar));\n+static_assert (!is_move_assignment (^^S::operator =));\n+static_assert (!is_move_assignment (^^S::operator +=));\n+static_assert (!is_move_assignment (^^T::operator *=));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_move_constructor1.C b/gcc/testsuite/g++.dg/reflect/is_move_constructor1.C\nnew file mode 100644\nindex 00000000000..d60253fd2e0\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_move_constructor1.C\n@@ -0,0 +1,101 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_move_constructor.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+void foo ();\n+\n+struct S {\n+ S ()\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ }\n+ S (int)\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ }\n+ S (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ }\n+ S (S &&)\n+ {\n+ int a;\n+ static_assert (is_move_constructor (parent_of (^^a)));\n+ }\n+ S &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ S &operator += (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ void bar ()\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ }\n+ ~S ()\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ }\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &)\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct U {\n+ template \n+ U (T &)\n+ {\n+ T a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ }\n+ U &operator = (U &&)\n+ {\n+ int a;\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct V {\n+ V (int a = 42, long b = 18)\n+ {\n+ static_assert (!is_move_constructor (parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (!is_move_constructor (null_reflection));\n+static_assert (!is_move_constructor (^^int));\n+static_assert (!is_move_constructor (^^::));\n+static_assert (!is_move_constructor (^^foo));\n+static_assert (!is_move_constructor (^^S::bar));\n+static_assert (!is_move_constructor (^^S::operator =));\n+static_assert (!is_move_constructor (^^S::operator +=));\n+static_assert (!is_move_constructor (^^T::operator *=));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_mutable_member1.C b/gcc/testsuite/g++.dg/reflect/is_mutable_member1.C\nnew file mode 100644\nindex 00000000000..7db9ace5114\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_mutable_member1.C\n@@ -0,0 +1,133 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_mutable_member.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ mutable int dm2;\n+ using type = int;\n+ enum E {\n+ B, C, D\n+ };\n+ enum class F {\n+ G, H\n+ };\n+ struct S {};\n+ union U {};\n+ template \n+ void foo ();\n+ template \n+ static void bar ();\n+ mutable S dm3;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+static union { mutable int anon2; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_mutable_member (null_reflection));\n+static_assert (!is_mutable_member (^^::));\n+static_assert (!is_mutable_member (^^ns));\n+static_assert (!is_mutable_member (^^ns_alias));\n+static_assert (!is_mutable_member (reflect_constant (3)));\n+static_assert (!is_mutable_member (^^cls));\n+static_assert (!is_mutable_member (^^cls::dm));\n+static_assert (is_mutable_member (^^cls::dm2));\n+static_assert (is_mutable_member (^^cls::dm3));\n+static_assert (!is_mutable_member (^^cls::ref_dm));\n+static_assert (!is_mutable_member (^^cls::static_dm));\n+static_assert (!is_mutable_member (^^cls::mem_fun));\n+static_assert (!is_mutable_member (^^cls::static_mem_fun));\n+static_assert (!is_mutable_member (^^cls::type));\n+static_assert (!is_mutable_member (^^cls::E));\n+static_assert (!is_mutable_member (^^cls::B));\n+static_assert (!is_mutable_member (^^cls::C));\n+static_assert (!is_mutable_member (^^cls::D));\n+static_assert (!is_mutable_member (^^cls::F));\n+static_assert (!is_mutable_member (^^cls::F::G));\n+static_assert (!is_mutable_member (^^cls::F::H));\n+static_assert (!is_mutable_member (^^cls::S));\n+static_assert (!is_mutable_member (^^cls::U));\n+static_assert (!is_mutable_member (^^cls::foo));\n+static_assert (!is_mutable_member (^^cls::foo <0>));\n+static_assert (!is_mutable_member (^^cls::bar));\n+static_assert (!is_mutable_member (^^cls::bar <42>));\n+static_assert (!is_mutable_member (^^cls_var));\n+static_assert (!is_mutable_member (^^onion));\n+static_assert (!is_mutable_member (^^anon));\n+static_assert (is_mutable_member (^^anon2));\n+static_assert (!is_mutable_member (^^fun));\n+static_assert (!is_mutable_member (^^alias));\n+static_assert (!is_mutable_member (^^var));\n+static_assert (!is_mutable_member (^^ref));\n+static_assert (!is_mutable_member (^^rref));\n+static_assert (!is_mutable_member (^^ptr));\n+static_assert (!is_mutable_member (^^cls_tmpl));\n+static_assert (!is_mutable_member (^^cls_tmpl));\n+static_assert (!is_mutable_member (^^incomplete_cls));\n+static_assert (!is_mutable_member (^^fun_tmpl));\n+static_assert (!is_mutable_member (^^fun_tmpl));\n+static_assert (!is_mutable_member (^^conc));\n+static_assert (!is_mutable_member (substitute (^^conc, { ^^int })));\n+static_assert (!is_mutable_member (^^var_tmpl));\n+static_assert (!is_mutable_member (^^var_tmpl));\n+static_assert (!is_mutable_member (^^cls_tmpl_alias));\n+static_assert (!is_mutable_member (^^cls_tmpl_alias));\n+static_assert (!is_mutable_member (^^Enum));\n+static_assert (!is_mutable_member (^^Enum::A));\n+static_assert (!is_mutable_member (^^Enum_class));\n+static_assert (!is_mutable_member (^^Enum_class::A));\n+static_assert (!is_mutable_member (^^decomp));\n+static_assert (!is_mutable_member (^^decomp_ref));\n+static_assert (!is_mutable_member (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_mutable_member (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_mutable_member (bases_of (^^Derived, access_context::current ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_mutable_member (^^x));\n+ static_assert (!is_mutable_member (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_mutable_member (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_mutable_member (^^S));\n+ static_assert (!is_mutable_member (^^E));\n+ static_assert (!is_mutable_member (^^F));\n+ static_assert (!is_mutable_member (^^G));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_namespace1.C b/gcc/testsuite/g++.dg/reflect/is_namespace1.C\nnew file mode 100644\nindex 00000000000..794c6ebbb9c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_namespace1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_namespace.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_namespace (null_reflection));\n+static_assert (is_namespace (^^::));\n+static_assert (is_namespace (^^ns));\n+static_assert (is_namespace (^^ns_alias));\n+static_assert (!is_namespace (reflect_constant (3)));\n+static_assert (!is_namespace (^^cls));\n+static_assert (!is_namespace (^^cls::dm));\n+static_assert (!is_namespace (^^cls::ref_dm));\n+static_assert (!is_namespace (^^cls::static_dm));\n+static_assert (!is_namespace (^^cls::mem_fun));\n+static_assert (!is_namespace (^^cls::static_mem_fun));\n+static_assert (!is_namespace (^^cls::type));\n+static_assert (!is_namespace (^^cls_var));\n+static_assert (!is_namespace (^^onion));\n+static_assert (!is_namespace (^^anon));\n+static_assert (!is_namespace (^^fun));\n+static_assert (!is_namespace (^^alias));\n+static_assert (!is_namespace (^^var));\n+static_assert (!is_namespace (^^ref));\n+static_assert (!is_namespace (^^rref));\n+static_assert (!is_namespace (^^ptr));\n+static_assert (!is_namespace (^^cls_tmpl));\n+static_assert (!is_namespace (^^cls_tmpl));\n+static_assert (!is_namespace (^^incomplete_cls));\n+static_assert (!is_namespace (^^fun_tmpl));\n+static_assert (!is_namespace (^^fun_tmpl));\n+static_assert (!is_namespace (^^conc));\n+static_assert (!is_namespace (substitute (^^conc, { ^^int })));\n+static_assert (!is_namespace (^^var_tmpl));\n+static_assert (!is_namespace (^^var_tmpl));\n+static_assert (!is_namespace (^^cls_tmpl_alias));\n+static_assert (!is_namespace (^^cls_tmpl_alias));\n+static_assert (!is_namespace (^^Enum));\n+static_assert (!is_namespace (^^Enum::A));\n+static_assert (!is_namespace (^^Enum_class));\n+static_assert (!is_namespace (^^Enum_class::A));\n+static_assert (!is_namespace (^^decomp));\n+static_assert (!is_namespace (^^decomp_ref));\n+static_assert (!is_namespace (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_namespace (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_namespace (bases_of (^^Derived, access_context::unprivileged ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_namespace (^^T));\n+ static_assert (!is_namespace (R));\n+ static_assert (is_namespace (R2));\n+ static_assert (!is_namespace (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_namespace (^^p));\n+ static_assert (!is_namespace (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_namespace_alias1.C b/gcc/testsuite/g++.dg/reflect/is_namespace_alias1.C\nnew file mode 100644\nindex 00000000000..f77c507b15b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_namespace_alias1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_namespace_alias.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_namespace_alias (null_reflection));\n+static_assert (!is_namespace_alias (^^::));\n+static_assert (!is_namespace_alias (^^ns));\n+static_assert (is_namespace_alias (^^ns_alias));\n+static_assert (!is_namespace_alias (reflect_constant (3)));\n+static_assert (!is_namespace_alias (^^cls));\n+static_assert (!is_namespace_alias (^^cls::dm));\n+static_assert (!is_namespace_alias (^^cls::ref_dm));\n+static_assert (!is_namespace_alias (^^cls::static_dm));\n+static_assert (!is_namespace_alias (^^cls::mem_fun));\n+static_assert (!is_namespace_alias (^^cls::static_mem_fun));\n+static_assert (!is_namespace_alias (^^cls::type));\n+static_assert (!is_namespace_alias (^^cls_var));\n+static_assert (!is_namespace_alias (^^onion));\n+static_assert (!is_namespace_alias (^^anon));\n+static_assert (!is_namespace_alias (^^fun));\n+static_assert (!is_namespace_alias (^^alias));\n+static_assert (!is_namespace_alias (^^var));\n+static_assert (!is_namespace_alias (^^ref));\n+static_assert (!is_namespace_alias (^^rref));\n+static_assert (!is_namespace_alias (^^ptr));\n+static_assert (!is_namespace_alias (^^cls_tmpl));\n+static_assert (!is_namespace_alias (^^cls_tmpl));\n+static_assert (!is_namespace_alias (^^incomplete_cls));\n+static_assert (!is_namespace_alias (^^fun_tmpl));\n+static_assert (!is_namespace_alias (^^fun_tmpl));\n+static_assert (!is_namespace_alias (^^conc));\n+static_assert (!is_namespace_alias (substitute (^^conc, { ^^int })));\n+static_assert (!is_namespace_alias (^^var_tmpl));\n+static_assert (!is_namespace_alias (^^var_tmpl));\n+static_assert (!is_namespace_alias (^^cls_tmpl_alias));\n+static_assert (!is_namespace_alias (^^cls_tmpl_alias));\n+static_assert (!is_namespace_alias (^^Enum));\n+static_assert (!is_namespace_alias (^^Enum::A));\n+static_assert (!is_namespace_alias (^^Enum_class));\n+static_assert (!is_namespace_alias (^^Enum_class::A));\n+static_assert (!is_namespace_alias (^^decomp));\n+static_assert (!is_namespace_alias (^^decomp_ref));\n+static_assert (!is_namespace_alias (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_namespace_alias (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_namespace_alias (bases_of (^^Derived, access_context::unchecked ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_namespace_alias (^^T));\n+ static_assert (!is_namespace_alias (R));\n+ static_assert (!is_namespace_alias (R2));\n+ static_assert (is_namespace_alias (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_namespace_alias (^^p));\n+ static_assert (!is_namespace_alias (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_namespace_member1.C b/gcc/testsuite/g++.dg/reflect/is_namespace_member1.C\nnew file mode 100644\nindex 00000000000..3a00357dab6\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_namespace_member1.C\n@@ -0,0 +1,147 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_namespace_member.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+ enum E {\n+ B, C, D\n+ };\n+ enum class F {\n+ G, H\n+ };\n+ struct S {};\n+ union U {};\n+ template \n+ void foo ();\n+ template \n+ static void bar ();\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+namespace NN\n+{\n+ int a;\n+ int &b = a;\n+ int &&c = 42;\n+ int *d = &a;\n+ namespace ns {}\n+ namespace ns_alias = ns;\n+ enum E { F };\n+}\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_namespace_member (null_reflection));\n+static_assert (!is_namespace_member (^^::));\n+static_assert (is_namespace_member (^^ns));\n+static_assert (is_namespace_member (^^ns_alias));\n+static_assert (!is_namespace_member (reflect_constant (3)));\n+static_assert (is_namespace_member (^^cls));\n+static_assert (!is_namespace_member (^^cls::dm));\n+static_assert (!is_namespace_member (^^cls::ref_dm));\n+static_assert (!is_namespace_member (^^cls::static_dm));\n+static_assert (!is_namespace_member (^^cls::mem_fun));\n+static_assert (!is_namespace_member (^^cls::static_mem_fun));\n+static_assert (!is_namespace_member (^^cls::type));\n+static_assert (!is_namespace_member (^^cls::E));\n+static_assert (!is_namespace_member (^^cls::B));\n+static_assert (!is_namespace_member (^^cls::C));\n+static_assert (!is_namespace_member (^^cls::D));\n+static_assert (!is_namespace_member (^^cls::F));\n+static_assert (!is_namespace_member (^^cls::F::G));\n+static_assert (!is_namespace_member (^^cls::F::H));\n+static_assert (!is_namespace_member (^^cls::S));\n+static_assert (!is_namespace_member (^^cls::U));\n+static_assert (!is_namespace_member (^^cls::foo));\n+static_assert (!is_namespace_member (^^cls::foo <0>));\n+static_assert (!is_namespace_member (^^cls::bar));\n+static_assert (!is_namespace_member (^^cls::bar <42>));\n+static_assert (is_namespace_member (^^cls_var));\n+static_assert (is_namespace_member (^^onion));\n+static_assert (!is_namespace_member (^^anon));\n+static_assert (is_namespace_member (^^fun));\n+static_assert (is_namespace_member (^^alias));\n+static_assert (is_namespace_member (^^var));\n+static_assert (is_namespace_member (^^ref));\n+static_assert (is_namespace_member (^^rref));\n+static_assert (is_namespace_member (^^ptr));\n+static_assert (is_namespace_member (^^cls_tmpl));\n+static_assert (is_namespace_member (^^cls_tmpl));\n+static_assert (is_namespace_member (^^incomplete_cls));\n+static_assert (is_namespace_member (^^fun_tmpl));\n+static_assert (is_namespace_member (^^fun_tmpl));\n+static_assert (is_namespace_member (^^conc));\n+static_assert (!is_namespace_member (substitute (^^conc, { ^^int })));\n+static_assert (is_namespace_member (^^var_tmpl));\n+static_assert (is_namespace_member (^^var_tmpl));\n+static_assert (is_namespace_member (^^cls_tmpl_alias));\n+static_assert (is_namespace_member (^^cls_tmpl_alias));\n+static_assert (is_namespace_member (^^Enum));\n+static_assert (is_namespace_member (^^Enum::A));\n+static_assert (is_namespace_member (^^A));\n+static_assert (is_namespace_member (^^Enum_class));\n+static_assert (!is_namespace_member (^^Enum_class::A));\n+static_assert (is_namespace_member (^^decomp));\n+static_assert (is_namespace_member (^^decomp_ref));\n+static_assert (is_namespace_member (^^arr));\n+static_assert (is_namespace_member (^^NN::a));\n+static_assert (is_namespace_member (^^NN::a));\n+static_assert (is_namespace_member (^^NN::b));\n+static_assert (is_namespace_member (^^NN::c));\n+static_assert (is_namespace_member (^^NN::d));\n+static_assert (is_namespace_member (^^NN::ns));\n+static_assert (is_namespace_member (^^NN::ns_alias));\n+static_assert (is_namespace_member (^^NN::E));\n+static_assert (is_namespace_member (^^NN::F));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_namespace_member (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_namespace_member (bases_of (^^Derived, access_context::current ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_namespace_member (^^x));\n+ static_assert (!is_namespace_member (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_namespace_member (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_namespace_member (^^S));\n+ static_assert (!is_namespace_member (^^E));\n+ static_assert (!is_namespace_member (^^F));\n+ static_assert (!is_namespace_member (^^G));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_noexcept1.C b/gcc/testsuite/g++.dg/reflect/is_noexcept1.C\nnew file mode 100644\nindex 00000000000..c4bacec0cbd\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_noexcept1.C\n@@ -0,0 +1,180 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_noexcept.\n+\n+#include \n+\n+// Basic noexcept specifications\n+void noexcept_function () noexcept;\n+void noexcept_true_function () noexcept(true);\n+void noexcept_false_function () noexcept(false);\n+void not_noexcept_function ();\n+\n+static_assert(std::meta::is_noexcept (^^noexcept_function));\n+static_assert(std::meta::is_noexcept (^^noexcept_true_function));\n+static_assert(!std::meta::is_noexcept (^^noexcept_false_function));\n+static_assert(!std::meta::is_noexcept (^^not_noexcept_function));\n+\n+// throw()\n+void throw_function () throw();\n+// void func () throw(int) --> error: ISO C++17 does not allow dynamic exception specifications\n+\n+static_assert (std::meta::is_noexcept (^^throw_function));\n+\n+// Template functions\n+template \n+void noexcept_template_function(T param) noexcept(true);\n+\n+// Note 2 from P2996: If r represents a function template that is declared noexcept,\n+// is_noexcept(r) is still false because in general such queries\n+// for templates cannot be answered.\n+static_assert (!std::meta::is_noexcept (^^noexcept_template_function));\n+// Note 5 from P2996: A template specialization is not a template.\n+static_assert (std::meta::is_noexcept (^^noexcept_template_function));\n+\n+template \n+void template_function(T param);\n+\n+static_assert (!std::meta::is_noexcept (^^template_function));\n+static_assert (!std::meta::is_noexcept (^^template_function));\n+\n+template\n+void conditional_noexcept() noexcept(B);\n+\n+static_assert (!std::meta::is_noexcept (^^conditional_noexcept));\n+static_assert (std::meta::is_noexcept (^^conditional_noexcept));\n+static_assert (!std::meta::is_noexcept (^^conditional_noexcept));\n+\n+struct S {\n+ void noexcept_method() noexcept;\n+ void noexcept_true_method() noexcept(true);\n+ void noexcept_false_method() noexcept(false);\n+ void not_noexcept_method();\n+\n+ virtual void noexcept_virtual_method() noexcept {}\n+ virtual void noexcept_true_virtual_method() noexcept(true) {}\n+ virtual void noexcept_false_virtual_method() noexcept(false) {}\n+ virtual void not_noexcept_virtual_method() {}\n+\n+ template \n+ void noexcept_template_method() noexcept;\n+ template \n+ void noexcept_true_template_method() noexcept(true);\n+ template \n+ void noexcept_false_template_method() noexcept(false);\n+ template \n+ void noexcept_cond_template_method() noexcept(sizeof(T) > 4);\n+ template \n+ void not_noexcept_template_method();\n+};\n+\n+// Methods\n+static_assert (std::meta::is_noexcept (^^S::noexcept_method));\n+static_assert (std::meta::is_noexcept (^^S::noexcept_true_method));\n+static_assert (!std::meta::is_noexcept (^^S::noexcept_false_method));\n+static_assert (!std::meta::is_noexcept (^^S::not_noexcept_method));\n+\n+// Virtual methods\n+static_assert (std::meta::is_noexcept (^^S::noexcept_virtual_method));\n+static_assert (std::meta::is_noexcept (^^S::noexcept_true_virtual_method));\n+static_assert (!std::meta::is_noexcept (^^S::noexcept_false_virtual_method));\n+static_assert (!std::meta::is_noexcept (^^S::not_noexcept_virtual_method));\n+\n+// Template methods\n+static_assert (!std::meta::is_noexcept (^^S::noexcept_template_method));\n+static_assert (!std::meta::is_noexcept (^^S::noexcept_true_template_method));\n+static_assert (!std::meta::is_noexcept (^^S::noexcept_false_template_method));\n+static_assert (!std::meta::is_noexcept (^^S::noexcept_cond_template_method));\n+static_assert (!std::meta::is_noexcept (^^S::not_noexcept_template_method));\n+\n+static_assert (std::meta::is_noexcept (^^S::noexcept_template_method));\n+static_assert (std::meta::is_noexcept (^^S::noexcept_true_template_method));\n+static_assert (!std::meta::is_noexcept (^^S::noexcept_false_template_method));\n+static_assert (!std::meta::is_noexcept (^^S::not_noexcept_template_method));\n+\n+struct SS : public S {\n+\n+};\n+\n+// Inherited methods\n+static_assert (std::meta::is_noexcept (^^SS::noexcept_method));\n+static_assert (std::meta::is_noexcept (^^SS::noexcept_true_method));\n+static_assert (!std::meta::is_noexcept (^^SS::noexcept_false_method));\n+static_assert (!std::meta::is_noexcept (^^SS::not_noexcept_method));\n+\n+// Function types\n+static_assert (std::meta::is_noexcept (^^void() noexcept));\n+static_assert (!std::meta::is_noexcept (^^void()));\n+\n+using not_noexcept_func_type = void();\n+using noexcept_func_type = void() noexcept;\n+\n+static_assert (!std::meta::is_noexcept (^^not_noexcept_func_type));\n+static_assert (std::meta::is_noexcept (^^noexcept_func_type));\n+\n+template\n+using conditional_noexcept_func_type = void(T) noexcept(B);\n+\n+static_assert (!std::meta::is_noexcept (^^conditional_noexcept_func_type));\n+static_assert (!std::meta::is_noexcept (^^conditional_noexcept_func_type));\n+static_assert (std::meta::is_noexcept (^^conditional_noexcept_func_type));\n+\n+// Constructors\n+struct T {\n+ T() = default;\n+\n+ T(int) {\n+ int a;\n+ static_assert (!std::meta::is_noexcept (std::meta::parent_of (^^a)));\n+ }\n+\n+ T(double) noexcept {\n+ int a;\n+ static_assert (std::meta::is_noexcept (std::meta::parent_of (^^a)));\n+ }\n+\n+ T(bool) noexcept(true) {\n+ int a;\n+ static_assert (std::meta::is_noexcept (std::meta::parent_of (^^a)));\n+ }\n+\n+ T(S) noexcept(false) {\n+ int a;\n+ static_assert (!std::meta::is_noexcept (std::meta::parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (noexcept (T()));\n+static_assert (!noexcept (T(123)));\n+static_assert (noexcept (T(123.123)));\n+static_assert (noexcept (T(true)));\n+static_assert (!noexcept (T(S())));\n+\n+// Destructors\n+struct U { };\n+U u;\n+static_assert (std::meta::is_noexcept (^^U::~U));\n+static_assert (noexcept (u.~U()));\n+\n+struct V { ~V() = delete; };\n+static_assert (std::meta::is_noexcept (^^V::~V));\n+\n+struct W { ~W() = default; };\n+W w;\n+static_assert (std::meta::is_noexcept (^^W::~W));\n+static_assert (noexcept (w.~W()));\n+\n+struct X { ~X(); };\n+X x;\n+static_assert (std::meta::is_noexcept (^^X::~X));\n+static_assert (noexcept (x.~X()));\n+\n+struct Y { ~Y() noexcept(true); };\n+Y y;\n+static_assert (std::meta::is_noexcept (^^Y::~Y));\n+static_assert (noexcept (y.~Y()));\n+\n+struct Z { ~Z() noexcept(false); };\n+Z z;\n+static_assert(!std::meta::is_noexcept (^^Z::~Z));\n+static_assert(!noexcept (z.~Z()));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_noexcept2.C b/gcc/testsuite/g++.dg/reflect/is_noexcept2.C\nnew file mode 100644\nindex 00000000000..5bf90de5744\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_noexcept2.C\n@@ -0,0 +1,65 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_noexcept. Negative cases.\n+\n+#include \n+#include \n+\n+// Lambdas\n+const auto noexcept_lambda = []() noexcept {};\n+const auto not_noexcept_lambda = []{};\n+\n+static_assert (!std::meta::is_noexcept (^^noexcept_lambda));\n+static_assert (!std::meta::is_noexcept (^^not_noexcept_lambda));\n+\n+// Template lamdas\n+const auto noexcept_template_lambda = [](T arg) noexcept {};\n+const auto not_noexcept_template_lambda = [](T arg) {};\n+\n+static_assert (!std::meta::is_noexcept (^^noexcept_template_lambda));\n+static_assert (!std::meta::is_noexcept (^^not_noexcept_template_lambda));\n+\n+void noexcept_function () noexcept;\n+void not_noexcept_function ();\n+\n+// Function pointers\n+void (*noexcept_function_pointer)() noexcept = noexcept_function;\n+void (*not_noexcept_function_pointer)() = not_noexcept_function;\n+\n+static_assert (!std::meta::is_noexcept (^^noexcept_function_pointer));\n+static_assert (!std::meta::is_noexcept (^^not_noexcept_function_pointer));\n+\n+// Function reference\n+void (&noexcept_function_reference)() noexcept = noexcept_function;\n+void (¬_noexcept_function_reference)() = not_noexcept_function;\n+\n+static_assert (!std::meta::is_noexcept (^^noexcept_function_reference));\n+static_assert (!std::meta::is_noexcept (^^not_noexcept_function_reference));\n+\n+struct S {\n+};\n+\n+// Member function pointers\n+void (S::*noexcept_member_pointer)() noexcept;\n+void (S::*not_noexcept_member_pointer)();\n+\n+static_assert (!std::meta::is_noexcept (^^noexcept_member_pointer));\n+static_assert (!std::meta::is_noexcept (^^not_noexcept_member_pointer));\n+\n+// Function pointer as a parameter in function\n+void function_with_noexcept_function_pointer_as_input(void (*noexcept_function_pointer)() noexcept) {\n+ static_assert (!std::meta::is_noexcept (^^noexcept_function_pointer));\n+}\n+\n+void function_with_not_noexcept_function_pointer_as_input(void (*not_noexcept_function_pointer)()) {\n+ static_assert (!std::meta::is_noexcept (^^not_noexcept_function_pointer));\n+}\n+\n+// Misc\n+std::function f;\n+int n = 42;\n+\n+static_assert (!std::meta::is_noexcept (^^f));\n+static_assert (!std::meta::is_noexcept (^^n));\n+static_assert (!std::meta::is_noexcept (^^S));\n+static_assert (!std::meta::is_noexcept (^^::));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_noexcept3.C b/gcc/testsuite/g++.dg/reflect/is_noexcept3.C\nnew file mode 100644\nindex 00000000000..556fa7fa254\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_noexcept3.C\n@@ -0,0 +1,175 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_noexcept.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+struct S1 {\n+ void foo () noexcept {\n+ static_assert (is_noexcept (^^foo));\n+ }\n+\n+ void bar () {\n+ static_assert (!is_noexcept (^^bar));\n+ }\n+};\n+\n+template\n+struct S2 {\n+ void foo () noexcept {\n+ static_assert (is_noexcept (^^foo));\n+ }\n+\n+ void bar () {\n+ static_assert (!is_noexcept (^^bar));\n+ }\n+\n+ template\n+ void tfoo () noexcept {\n+ static_assert (is_noexcept (^^tfoo));\n+ }\n+\n+ template\n+ void tbar () {\n+ static_assert (!is_noexcept (^^tbar));\n+ }\n+};\n+\n+S2 s2;\n+\n+void fn1 ();\n+void fn2 () noexcept;\n+void fn3 () noexcept(false);\n+\n+static_assert (!is_noexcept (type_of (^^::fn1)));\n+static_assert (is_noexcept (type_of (^^::fn2)));\n+static_assert (!is_noexcept (type_of (^^::fn3)));\n+\n+static_assert (!is_noexcept (reflect_constant (&::fn1)));\n+static_assert (!is_noexcept (reflect_constant (&::fn2)));\n+static_assert (!is_noexcept (reflect_constant (&::fn3)));\n+\n+static_assert (!is_noexcept (type_of (reflect_constant (&::fn1))));\n+static_assert (!is_noexcept (type_of (reflect_constant (&::fn2))));\n+static_assert (!is_noexcept (type_of (reflect_constant (&::fn3))));\n+\n+template\n+void tfn1 ();\n+template\n+void tfn2 () noexcept;\n+template\n+void tfn3 () noexcept(false);\n+\n+static_assert (!is_noexcept (type_of (^^::tfn1)));\n+static_assert (is_noexcept (type_of (^^::tfn2)));\n+static_assert (!is_noexcept (type_of (^^::tfn3)));\n+\n+static_assert (!is_noexcept (reflect_constant (^^::tfn1)));\n+static_assert (!is_noexcept (reflect_constant (^^::tfn2)));\n+static_assert (!is_noexcept (reflect_constant (^^::tfn3)));\n+\n+static_assert (!is_noexcept (type_of (reflect_constant (^^::tfn1))));\n+static_assert (!is_noexcept (type_of (reflect_constant (^^::tfn2))));\n+static_assert (!is_noexcept (type_of (reflect_constant (^^::tfn3))));\n+\n+struct S {\n+ void memfn1 ();\n+ void memfn2 () noexcept;\n+ void memfn3 () noexcept(false);\n+\n+ virtual void vmemfn1 () {}\n+ virtual void vmemfn2 () noexcept {}\n+ virtual void vmemfn3 () noexcept(false) {}\n+\n+ template\n+ void tmemfn1 ();\n+ template\n+ void tmemfn2 () noexcept;\n+ template\n+ void tmemfn3 () noexcept(false);\n+};\n+\n+static_assert (!is_noexcept (type_of (^^S::memfn1)));\n+static_assert (is_noexcept (type_of (^^S::memfn2)));\n+static_assert (!is_noexcept (type_of (^^S::memfn3)));\n+\n+static_assert (!is_noexcept (type_of (^^S::vmemfn1)));\n+static_assert (is_noexcept (type_of (^^S::vmemfn2)));\n+static_assert (!is_noexcept (type_of (^^S::vmemfn3)));\n+\n+static_assert (!is_noexcept (type_of (^^S::tmemfn1)));\n+static_assert (is_noexcept (type_of (^^S::tmemfn2)));\n+static_assert (!is_noexcept (type_of (^^S::tmemfn3)));\n+\n+static_assert (!is_noexcept (reflect_constant (&S::memfn1)));\n+static_assert (!is_noexcept (reflect_constant (&S::memfn2)));\n+static_assert (!is_noexcept (reflect_constant (&S::memfn3)));\n+\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::memfn1))));\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::memfn2))));\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::memfn3))));\n+\n+static_assert (!is_noexcept (reflect_constant (&S::vmemfn1)));\n+static_assert (!is_noexcept (reflect_constant (&S::vmemfn2)));\n+static_assert (!is_noexcept (reflect_constant (&S::vmemfn3)));\n+\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::vmemfn1))));\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::vmemfn2))));\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::vmemfn3))));\n+\n+static_assert (!is_noexcept (reflect_constant (&S::tmemfn1)));\n+static_assert (!is_noexcept (reflect_constant (&S::tmemfn2)));\n+static_assert (!is_noexcept (reflect_constant (&S::tmemfn3)));\n+\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::tmemfn1))));\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::tmemfn2))));\n+static_assert (!is_noexcept (type_of (reflect_constant (&S::tmemfn3))));\n+\n+constexpr auto noexcept_lambda = []() noexcept {};\n+constexpr auto not_noexcept_lambda = []{};\n+static_assert (!is_noexcept (type_of (^^noexcept_lambda)));\n+static_assert (!is_noexcept (type_of (^^not_noexcept_lambda)));\n+\n+constexpr auto noexcept_generic_lambda = []() noexcept {};\n+constexpr auto not_noexcept_generic_lambda = []() {};\n+static_assert (!is_noexcept (type_of (^^noexcept_generic_lambda)));\n+static_assert (!is_noexcept (type_of (^^not_noexcept_generic_lambda)));\n+\n+struct T {\n+ static const int static_mem = 1;\n+ int non_static_mem = 2;\n+};\n+\n+template \n+struct TT {};\n+\n+enum class EC { X };\n+enum E { X };\n+\n+static auto static_x = 1;\n+auto non_static_x = static_x;\n+auto t = T();\n+auto template_t = TT();\n+int c_array[] = {1, 2};\n+auto [sb1, sb2] = c_array;\n+\n+static_assert (!is_noexcept (^^static_x));\n+static_assert (!is_noexcept (type_of (^^static_x)));\n+static_assert (!is_noexcept (^^non_static_x));\n+static_assert (!is_noexcept (type_of (^^non_static_x)));\n+static_assert (!is_noexcept (^^T::static_mem));\n+static_assert (!is_noexcept (type_of (^^T::static_mem)));\n+static_assert (!is_noexcept (^^sb1));\n+static_assert (!is_noexcept (^^T::non_static_mem));\n+static_assert (!is_noexcept (type_of (^^T::non_static_mem)));\n+static_assert (!is_noexcept (^^TT));\n+static_assert (!is_noexcept (^^template_t));\n+static_assert (!is_noexcept (type_of (^^template_t)));\n+static_assert (!is_noexcept (^^EC));\n+static_assert (!is_noexcept (^^EC::X));\n+static_assert (!is_noexcept (type_of (^^EC::X)));\n+static_assert (!is_noexcept (^^E));\n+static_assert (!is_noexcept (^^X));\n+static_assert (!is_noexcept (type_of (^^X)));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_noexcept4.C b/gcc/testsuite/g++.dg/reflect/is_noexcept4.C\nnew file mode 100644\nindex 00000000000..9b4b2b892ca\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_noexcept4.C\n@@ -0,0 +1,120 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_noexcept.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+template\n+struct Mem {\n+ Mem() noexcept(Noex);\n+ Mem(Mem const&) noexcept(Noex);\n+ Mem(Mem&&) noexcept(Noex);\n+ Mem& operator=(Mem const&) noexcept(Noex);\n+ Mem& operator=(Mem&&) noexcept(Noex);\n+ ~Mem() noexcept(Noex);\n+\n+ bool operator==(const Mem&) const noexcept(Noex);\n+ std::strong_ordering operator<=>(const Mem&) const noexcept(Noex);\n+};\n+\n+template\n+consteval info\n+select_mem(info clazz, F f)\n+{\n+ for (info x : members_of(clazz, access_context::unchecked()))\n+ if (f(x))\n+ return x;\n+}\n+\n+template\n+struct ExplicitDef\n+{\n+ ExplicitDef() = default;\n+ ExplicitDef(const ExplicitDef&) = default;\n+ ExplicitDef(ExplicitDef&&) = default;\n+\n+ ExplicitDef& operator=(const ExplicitDef&) = default;\n+ ExplicitDef& operator=(ExplicitDef&&) = default;\n+\n+ ~ExplicitDef() = default;\n+\n+ Mem d;\n+};\n+\n+static_assert (is_noexcept (select_mem (^^ExplicitDef, is_default_constructor)));\n+static_assert (is_noexcept (select_mem (^^ExplicitDef, is_copy_constructor)));\n+static_assert (is_noexcept (select_mem (^^ExplicitDef, is_move_constructor)));\n+static_assert (is_noexcept (select_mem (^^ExplicitDef, is_copy_assignment)));\n+static_assert (is_noexcept (select_mem (^^ExplicitDef, is_move_assignment)));\n+static_assert (is_noexcept (select_mem (^^ExplicitDef, is_destructor)));\n+\n+static_assert (!is_noexcept (select_mem (^^ExplicitDef, is_default_constructor)));\n+static_assert (!is_noexcept (select_mem (^^ExplicitDef, is_copy_constructor)));\n+static_assert (!is_noexcept (select_mem (^^ExplicitDef, is_move_constructor)));\n+static_assert (!is_noexcept (select_mem (^^ExplicitDef, is_copy_assignment)));\n+static_assert (!is_noexcept (select_mem (^^ExplicitDef, is_move_assignment)));\n+static_assert (!is_noexcept (select_mem (^^ExplicitDef, is_destructor)));\n+\n+template\n+struct ImplicitDef\n+{\n+ Mem d;\n+};\n+\n+static_assert (is_noexcept (select_mem (^^ImplicitDef, is_default_constructor)));\n+static_assert (is_noexcept (select_mem (^^ImplicitDef, is_copy_constructor)));\n+static_assert (is_noexcept (select_mem (^^ImplicitDef, is_move_constructor)));\n+static_assert (is_noexcept (select_mem (^^ImplicitDef, is_copy_assignment)));\n+static_assert (is_noexcept (select_mem (^^ImplicitDef, is_move_assignment)));\n+static_assert (is_noexcept (select_mem (^^ImplicitDef, is_destructor)));\n+\n+static_assert (!is_noexcept (select_mem (^^ImplicitDef, is_default_constructor)));\n+static_assert (!is_noexcept (select_mem (^^ImplicitDef, is_copy_constructor)));\n+static_assert (!is_noexcept (select_mem (^^ImplicitDef, is_move_constructor)));\n+static_assert (!is_noexcept (select_mem (^^ImplicitDef, is_copy_assignment)));\n+static_assert (!is_noexcept (select_mem (^^ImplicitDef, is_move_assignment)));\n+static_assert (!is_noexcept (select_mem (^^ImplicitDef, is_destructor)));\n+\n+template\n+struct ExplicitRelOps\n+{\n+ bool operator==(const ExplicitRelOps&) const = default;\n+ auto operator<=>(const ExplicitRelOps&) const = default;\n+\n+ Mem d;\n+};\n+static_assert (is_noexcept (^^ExplicitRelOps::operator==));\n+static_assert (is_noexcept (^^ExplicitRelOps::operator<=>));\n+\n+ExplicitRelOps x1;\n+static_assert (noexcept (x1 == x1));\n+static_assert (noexcept (x1 <=> x1));\n+static_assert (is_noexcept (^^ExplicitRelOps::operator==));\n+static_assert (is_noexcept (^^ExplicitRelOps::operator<=>));\n+\n+static_assert (!is_noexcept (^^ExplicitRelOps::operator==));\n+static_assert (!is_noexcept (^^ExplicitRelOps::operator<=>));\n+\n+template\n+struct ImplicitRelOps\n+{\n+ // operator== is implicitly declared\n+ auto operator<=>(const ImplicitRelOps&) const = default;\n+\n+ Mem d;\n+};\n+\n+static_assert (is_noexcept (^^ImplicitRelOps::operator==));\n+static_assert (is_noexcept (^^ImplicitRelOps::operator<=>));\n+\n+ImplicitRelOps x2;\n+static_assert (noexcept (x2 == x2));\n+static_assert (noexcept (x2 <=> x2));\n+static_assert (is_noexcept (^^ImplicitRelOps::operator==));\n+static_assert (is_noexcept (^^ImplicitRelOps::operator<=>));\n+\n+static_assert (!is_noexcept (^^ImplicitRelOps::operator==));\n+static_assert (!is_noexcept (^^ImplicitRelOps::operator<=>));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_nonstatic_data_member1.C b/gcc/testsuite/g++.dg/reflect/is_nonstatic_data_member1.C\nnew file mode 100644\nindex 00000000000..13137d8b1d5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_nonstatic_data_member1.C\n@@ -0,0 +1,127 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_nonstatic_data_member.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+ enum E {\n+ B, C, D\n+ };\n+ enum class F {\n+ G, H\n+ };\n+ struct S {};\n+ union U {};\n+ template \n+ void foo ();\n+ template \n+ static void bar ();\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_nonstatic_data_member (null_reflection));\n+static_assert (!is_nonstatic_data_member (^^::));\n+static_assert (!is_nonstatic_data_member (^^ns));\n+static_assert (!is_nonstatic_data_member (^^ns_alias));\n+static_assert (!is_nonstatic_data_member (reflect_constant (3)));\n+static_assert (!is_nonstatic_data_member (^^cls));\n+static_assert (is_nonstatic_data_member (^^cls::dm));\n+static_assert (is_nonstatic_data_member (^^cls::ref_dm));\n+static_assert (!is_nonstatic_data_member (^^cls::static_dm));\n+static_assert (!is_nonstatic_data_member (^^cls::mem_fun));\n+static_assert (!is_nonstatic_data_member (^^cls::static_mem_fun));\n+static_assert (!is_nonstatic_data_member (^^cls::type));\n+static_assert (!is_nonstatic_data_member (^^cls::E));\n+static_assert (!is_nonstatic_data_member (^^cls::B));\n+static_assert (!is_nonstatic_data_member (^^cls::C));\n+static_assert (!is_nonstatic_data_member (^^cls::D));\n+static_assert (!is_nonstatic_data_member (^^cls::F));\n+static_assert (!is_nonstatic_data_member (^^cls::F::G));\n+static_assert (!is_nonstatic_data_member (^^cls::F::H));\n+static_assert (!is_nonstatic_data_member (^^cls::S));\n+static_assert (!is_nonstatic_data_member (^^cls::U));\n+static_assert (!is_nonstatic_data_member (^^cls::foo));\n+static_assert (!is_nonstatic_data_member (^^cls::foo <0>));\n+static_assert (!is_nonstatic_data_member (^^cls::bar));\n+static_assert (!is_nonstatic_data_member (^^cls::bar <42>));\n+static_assert (!is_nonstatic_data_member (^^cls_var));\n+static_assert (!is_nonstatic_data_member (^^onion));\n+static_assert (is_nonstatic_data_member (^^anon));\n+static_assert (!is_nonstatic_data_member (^^fun));\n+static_assert (!is_nonstatic_data_member (^^alias));\n+static_assert (!is_nonstatic_data_member (^^var));\n+static_assert (!is_nonstatic_data_member (^^ref));\n+static_assert (!is_nonstatic_data_member (^^rref));\n+static_assert (!is_nonstatic_data_member (^^ptr));\n+static_assert (!is_nonstatic_data_member (^^cls_tmpl));\n+static_assert (!is_nonstatic_data_member (^^cls_tmpl));\n+static_assert (!is_nonstatic_data_member (^^incomplete_cls));\n+static_assert (!is_nonstatic_data_member (^^fun_tmpl));\n+static_assert (!is_nonstatic_data_member (^^fun_tmpl));\n+static_assert (!is_nonstatic_data_member (^^conc));\n+static_assert (!is_nonstatic_data_member (substitute (^^conc, { ^^int })));\n+static_assert (!is_nonstatic_data_member (^^var_tmpl));\n+static_assert (!is_nonstatic_data_member (^^var_tmpl));\n+static_assert (!is_nonstatic_data_member (^^cls_tmpl_alias));\n+static_assert (!is_nonstatic_data_member (^^cls_tmpl_alias));\n+static_assert (!is_nonstatic_data_member (^^Enum));\n+static_assert (!is_nonstatic_data_member (^^Enum::A));\n+static_assert (!is_nonstatic_data_member (^^Enum_class));\n+static_assert (!is_nonstatic_data_member (^^Enum_class::A));\n+static_assert (!is_nonstatic_data_member (^^decomp));\n+static_assert (!is_nonstatic_data_member (^^decomp_ref));\n+static_assert (!is_nonstatic_data_member (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_nonstatic_data_member (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_nonstatic_data_member (bases_of (^^Derived, access_context::current ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_nonstatic_data_member (^^x));\n+ static_assert (!is_nonstatic_data_member (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_nonstatic_data_member (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_nonstatic_data_member (^^S));\n+ static_assert (!is_nonstatic_data_member (^^E));\n+ static_assert (!is_nonstatic_data_member (^^F));\n+ static_assert (!is_nonstatic_data_member (^^G));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_object1.C b/gcc/testsuite/g++.dg/reflect/is_object1.C\nnew file mode 100644\nindex 00000000000..e7ee628a367\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_object1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_object.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_object (null_reflection));\n+static_assert (!is_object (^^::));\n+static_assert (!is_object (^^ns));\n+static_assert (!is_object (^^ns_alias));\n+static_assert (!is_object (reflect_constant (3)));\n+static_assert (!is_object (^^cls));\n+static_assert (!is_object (^^cls::dm));\n+static_assert (!is_object (^^cls::ref_dm));\n+static_assert (!is_object (^^cls::static_dm));\n+static_assert (!is_object (^^cls::mem_fun));\n+static_assert (!is_object (^^cls::static_mem_fun));\n+static_assert (!is_object (^^cls::type));\n+static_assert (!is_object (^^cls_var));\n+static_assert (!is_object (^^onion));\n+static_assert (!is_object (^^anon));\n+static_assert (!is_object (^^fun));\n+static_assert (!is_object (^^alias));\n+static_assert (!is_object (^^var));\n+static_assert (!is_object (^^ref));\n+static_assert (!is_object (^^rref));\n+static_assert (!is_object (^^ptr));\n+static_assert (!is_object (^^cls_tmpl));\n+static_assert (!is_object (^^cls_tmpl));\n+static_assert (!is_object (^^incomplete_cls));\n+static_assert (!is_object (^^fun_tmpl));\n+static_assert (!is_object (^^fun_tmpl));\n+static_assert (!is_object (^^conc));\n+static_assert (!is_object (substitute (^^conc, { ^^int })));\n+static_assert (!is_object (^^var_tmpl));\n+static_assert (!is_object (^^var_tmpl));\n+static_assert (!is_object (^^cls_tmpl_alias));\n+static_assert (!is_object (^^cls_tmpl_alias));\n+static_assert (!is_object (^^Enum));\n+static_assert (!is_object (^^Enum::A));\n+static_assert (!is_object (^^Enum_class));\n+static_assert (!is_object (^^Enum_class::A));\n+static_assert (!is_object (^^decomp));\n+static_assert (!is_object (^^decomp_ref));\n+static_assert (!is_object (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_object (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_object (bases_of (^^Derived, access_context::unchecked ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_object (^^T));\n+ static_assert (!is_object (R));\n+ static_assert (!is_object (R2));\n+ static_assert (!is_object (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_object (^^p));\n+ static_assert (!is_object (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_object2.C b/gcc/testsuite/g++.dg/reflect/is_object2.C\nnew file mode 100644\nindex 00000000000..c61f9864548\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_object2.C\n@@ -0,0 +1,15 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_object.\n+\n+#include \n+using namespace std::meta;\n+\n+void f();\n+\n+template \n+consteval void tfn() { }\n+\n+static_assert (!is_object (template_arguments_of (^^tfn)[0]));\n+static_assert (!is_object (^^f));\n+static_assert (template_arguments_of (^^tfn)[0] == ^^f);\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_operator_function1.C b/gcc/testsuite/g++.dg/reflect/is_operator_function1.C\nnew file mode 100644\nindex 00000000000..69084c598e5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_operator_function1.C\n@@ -0,0 +1,56 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_operator_function.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+void foo ();\n+\n+struct S {\n+ S &operator+(const S&);\n+\n+ template \n+ S &operator-(const S&);\n+\n+ operator int();\n+\n+ void fn();\n+};\n+\n+struct T {\n+ template \n+ operator T();\n+};\n+\n+bool operator&&(const S&, const S&);\n+\n+template \n+bool operator||(const S&, const T&);\n+\n+int operator\"\"_a(const char *);\n+\n+template\n+int operator\"\"_b();\n+\n+constexpr auto conversion_template\n+ = (members_of (^^T, access_context::current ()) | std::views::filter (is_template)).front ();\n+\n+static_assert (!is_operator_function (null_reflection));\n+static_assert (!is_operator_function (^^int));\n+static_assert (!is_operator_function (^^::));\n+static_assert (!is_operator_function (^^foo));\n+static_assert (is_operator_function (^^S::operator+));\n+static_assert (is_operator_function (^^operator&&));\n+static_assert (!is_operator_function (^^operator||));\n+static_assert (is_operator_function (^^operator||));\n+static_assert (!is_operator_function (^^S::operator-));\n+static_assert (is_operator_function (^^S::operator-));\n+static_assert (!is_operator_function (^^S::operator int));\n+static_assert (!is_operator_function (conversion_template));\n+static_assert (!is_operator_function (^^S::fn));\n+static_assert (!is_operator_function (^^operator\"\"_a));\n+static_assert (!is_operator_function (^^operator\"\"_b));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_operator_function_template1.C b/gcc/testsuite/g++.dg/reflect/is_operator_function_template1.C\nnew file mode 100644\nindex 00000000000..12def21c61a\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_operator_function_template1.C\n@@ -0,0 +1,57 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_operator_function_template.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+void foo ();\n+\n+struct S {\n+ S &operator+(const S&);\n+\n+ template \n+ S &operator-(const S&);\n+\n+ operator int();\n+\n+ void fn();\n+};\n+\n+struct T {\n+ template \n+ operator T ();\n+};\n+\n+bool operator&&(const S&, const S&);\n+\n+template \n+bool operator||(const S&, const T&);\n+\n+int operator\"\"_a(const char *);\n+\n+template\n+int operator\"\"_b();\n+\n+constexpr auto conversion_template\n+ = (members_of (^^T, access_context::current ()) | std::views::filter (is_template)).front ();\n+\n+static_assert (!is_operator_function_template (null_reflection));\n+static_assert (!is_operator_function_template (^^int));\n+static_assert (!is_operator_function_template (^^::));\n+static_assert (!is_operator_function_template (^^foo));\n+static_assert (!is_operator_function_template (^^S::operator+));\n+static_assert (!is_operator_function_template (^^operator&&));\n+static_assert (is_operator_function_template (^^operator||));\n+static_assert (!is_operator_function_template (^^operator||));\n+static_assert (is_operator_function_template (^^S::operator-));\n+static_assert (!is_operator_function_template (^^S::operator-));\n+static_assert (is_operator_function_template (template_of (^^S::operator-)));\n+static_assert (!is_operator_function_template (^^S::operator int));\n+static_assert (!is_operator_function_template (conversion_template));\n+static_assert (!is_operator_function_template (^^S::fn));\n+static_assert (!is_operator_function_template (^^operator\"\"_a));\n+static_assert (!is_operator_function_template (^^operator\"\"_b));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_override1.C b/gcc/testsuite/g++.dg/reflect/is_override1.C\nnew file mode 100644\nindex 00000000000..e55cb7fb934\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_override1.C\n@@ -0,0 +1,154 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_override.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_override (null_reflection));\n+static_assert (!is_override (^^::));\n+static_assert (!is_override (^^ns));\n+static_assert (!is_override (^^ns_alias));\n+static_assert (!is_override (reflect_constant (3)));\n+static_assert (!is_override (^^cls));\n+static_assert (!is_override (^^cls::dm));\n+static_assert (!is_override (^^cls::ref_dm));\n+static_assert (!is_override (^^cls::static_dm));\n+static_assert (!is_override (^^cls::mem_fun));\n+static_assert (!is_override (^^cls::static_mem_fun));\n+static_assert (!is_override (^^cls::type));\n+static_assert (!is_override (^^cls_var));\n+static_assert (!is_override (^^onion));\n+static_assert (!is_override (^^anon));\n+static_assert (!is_override (^^fun));\n+static_assert (!is_override (^^alias));\n+static_assert (!is_override (^^var));\n+static_assert (!is_override (^^ref));\n+static_assert (!is_override (^^rref));\n+static_assert (!is_override (^^ptr));\n+static_assert (!is_override (^^cls_tmpl));\n+static_assert (!is_override (^^cls_tmpl));\n+static_assert (!is_override (^^incomplete_cls));\n+static_assert (!is_override (^^fun_tmpl));\n+static_assert (!is_override (^^fun_tmpl));\n+static_assert (!is_override (^^conc));\n+static_assert (!is_override (substitute (^^conc, { ^^int })));\n+static_assert (!is_override (^^var_tmpl));\n+static_assert (!is_override (^^var_tmpl));\n+static_assert (!is_override (^^cls_tmpl_alias));\n+static_assert (!is_override (^^cls_tmpl_alias));\n+static_assert (!is_override (^^Enum));\n+static_assert (!is_override (^^Enum::A));\n+static_assert (!is_override (^^Enum_class));\n+static_assert (!is_override (^^Enum_class::A));\n+static_assert (!is_override (^^decomp));\n+static_assert (!is_override (^^decomp_ref));\n+static_assert (!is_override (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_override (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_override (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_override (^^T));\n+ static_assert (!is_override (R));\n+ static_assert (!is_override (R2));\n+ static_assert (!is_override (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_override (^^p));\n+ static_assert (!is_override (^^c));\n+}\n+\n+struct Base2 {\n+ void foo ();\n+ virtual void bar ();\n+ virtual void baz ();\n+ virtual void qux ();\n+ virtual void corge () = 0;\n+ virtual void garply ();\n+ virtual ~Base2 ();\n+};\n+\n+struct Derived2 : Base2 {\n+ void foo ();\n+ virtual void baz ();\n+ virtual void qux () override;\n+ virtual void corge ();\n+ virtual void freddy ();\n+};\n+\n+struct Derived3 : Derived2 {\n+ void foo ();\n+ virtual void qux () override;\n+ virtual void corge ();\n+ virtual void freddy ();\n+};\n+\n+static_assert (!is_override (^^Base2::foo));\n+static_assert (!is_override (^^Base2::bar));\n+static_assert (!is_override (^^Base2::baz));\n+static_assert (!is_override (^^Base2::qux));\n+static_assert (!is_override (^^Base2::corge));\n+static_assert (!is_override (^^Base2::garply));\n+static_assert (!is_override (^^Base2::~Base2));\n+static_assert (!is_override (^^Derived2::foo));\n+static_assert (!is_override (^^Derived2::bar));\n+static_assert (is_override (^^Derived2::baz));\n+static_assert (is_override (^^Derived2::qux));\n+static_assert (is_override (^^Derived2::corge));\n+static_assert (!is_override (^^Derived2::garply));\n+static_assert (!is_override (^^Derived2::freddy));\n+static_assert (is_override (^^Derived2::~Derived2));\n+static_assert (!is_override (^^Derived3::foo));\n+static_assert (!is_override (^^Derived3::bar));\n+static_assert (is_override (^^Derived3::baz));\n+static_assert (is_override (^^Derived3::qux));\n+static_assert (is_override (^^Derived3::corge));\n+static_assert (!is_override (^^Derived3::garply));\n+static_assert (is_override (^^Derived3::freddy));\n+static_assert (is_override (^^Derived3::~Derived3));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_pure_virtual1.C b/gcc/testsuite/g++.dg/reflect/is_pure_virtual1.C\nnew file mode 100644\nindex 00000000000..ed775d19ab6\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_pure_virtual1.C\n@@ -0,0 +1,48 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_pure_virtual.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+void func() {}\n+\n+struct B {\n+ void nonvirt();\n+ virtual void virt_no_override();\n+ virtual void virt_implicit_override();\n+ virtual void virt_explicit_override();\n+ virtual void pure_virt() = 0;\n+ virtual ~B() = 0;\n+};\n+\n+struct D : B {\n+ void nonvirt();\n+ void virt_implicit_override();\n+ void virt_explicit_override() override;\n+ void pure_virt();\n+ virtual ~D() = 0;\n+};\n+\n+struct DD {\n+ ~DD() = delete;\n+};\n+\n+static_assert (!is_pure_virtual (^^func));\n+\n+static_assert (!is_pure_virtual (^^B::nonvirt));\n+static_assert (!is_pure_virtual (^^B::virt_no_override));\n+static_assert (!is_pure_virtual (^^B::virt_implicit_override));\n+static_assert (!is_pure_virtual (^^B::virt_explicit_override));\n+static_assert (is_pure_virtual (^^B::pure_virt));\n+static_assert (is_pure_virtual (^^B::~B));\n+\n+static_assert (!is_pure_virtual (^^D::nonvirt));\n+static_assert (!is_pure_virtual (^^D::virt_no_override));\n+static_assert (!is_pure_virtual (^^D::virt_implicit_override));\n+static_assert (!is_pure_virtual (^^D::virt_explicit_override));\n+static_assert (!is_pure_virtual (^^D::pure_virt));\n+static_assert (is_pure_virtual (^^D::~D));\n+\n+static_assert (!is_pure_virtual (^^DD::~DD));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_special_member_function1.C b/gcc/testsuite/g++.dg/reflect/is_special_member_function1.C\nnew file mode 100644\nindex 00000000000..3b63259dcef\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_special_member_function1.C\n@@ -0,0 +1,101 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_special_member_function.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+void foo ();\n+\n+struct S {\n+ S ()\n+ {\n+ int a;\n+ static_assert (is_special_member_function (parent_of (^^a)));\n+ }\n+ S (int)\n+ {\n+ int a;\n+ static_assert (!is_special_member_function (parent_of (^^a)));\n+ }\n+ S (const S &)\n+ {\n+ int a;\n+ static_assert (is_special_member_function (parent_of (^^a)));\n+ }\n+ S (S &&)\n+ {\n+ int a;\n+ static_assert (is_special_member_function (parent_of (^^a)));\n+ }\n+ S &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (is_special_member_function (parent_of (^^a)));\n+ return *this;\n+ }\n+ S &operator += (const S &)\n+ {\n+ int a;\n+ static_assert (!is_special_member_function (parent_of (^^a)));\n+ return *this;\n+ }\n+ void bar ()\n+ {\n+ int a;\n+ static_assert (!is_special_member_function (parent_of (^^a)));\n+ }\n+ ~S ()\n+ {\n+ int a;\n+ static_assert (is_special_member_function (parent_of (^^a)));\n+ }\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_special_member_function (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &)\n+ {\n+ int a;\n+ static_assert (!is_special_member_function (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct U {\n+ template \n+ U (T &)\n+ {\n+ T a;\n+ static_assert (is_constructor (parent_of (^^a)));\n+ }\n+ U &operator = (U &&)\n+ {\n+ int a;\n+ static_assert (is_special_member_function (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct V {\n+ V (int a = 42, long b = 18)\n+ {\n+ static_assert (is_special_member_function (parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (!is_special_member_function (null_reflection));\n+static_assert (!is_special_member_function (^^int));\n+static_assert (!is_special_member_function (^^::));\n+static_assert (!is_special_member_function (^^foo));\n+static_assert (!is_special_member_function (^^S::bar));\n+static_assert (is_special_member_function (^^S::operator =));\n+static_assert (!is_special_member_function (^^S::operator +=));\n+static_assert (!is_special_member_function (^^T::operator *=));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_static_member1.C b/gcc/testsuite/g++.dg/reflect/is_static_member1.C\nnew file mode 100644\nindex 00000000000..c87aedc8e4c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_static_member1.C\n@@ -0,0 +1,127 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_static_member.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+ enum E {\n+ B, C, D\n+ };\n+ enum class F {\n+ G, H\n+ };\n+ struct S {};\n+ union U {};\n+ template \n+ void foo ();\n+ template \n+ static void bar ();\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_static_member (null_reflection));\n+static_assert (!is_static_member (^^::));\n+static_assert (!is_static_member (^^ns));\n+static_assert (!is_static_member (^^ns_alias));\n+static_assert (!is_static_member (reflect_constant (3)));\n+static_assert (!is_static_member (^^cls));\n+static_assert (!is_static_member (^^cls::dm));\n+static_assert (!is_static_member (^^cls::ref_dm));\n+static_assert (is_static_member (^^cls::static_dm));\n+static_assert (!is_static_member (^^cls::mem_fun));\n+static_assert (is_static_member (^^cls::static_mem_fun));\n+static_assert (!is_static_member (^^cls::type));\n+static_assert (!is_static_member (^^cls::E));\n+static_assert (!is_static_member (^^cls::B));\n+static_assert (!is_static_member (^^cls::C));\n+static_assert (!is_static_member (^^cls::D));\n+static_assert (!is_static_member (^^cls::F));\n+static_assert (!is_static_member (^^cls::F::G));\n+static_assert (!is_static_member (^^cls::F::H));\n+static_assert (!is_static_member (^^cls::S));\n+static_assert (!is_static_member (^^cls::U));\n+static_assert (!is_static_member (^^cls::foo));\n+static_assert (!is_static_member (^^cls::foo <0>));\n+static_assert (is_static_member (^^cls::bar));\n+static_assert (is_static_member (^^cls::bar <42>));\n+static_assert (!is_static_member (^^cls_var));\n+static_assert (!is_static_member (^^onion));\n+static_assert (!is_static_member (^^anon));\n+static_assert (!is_static_member (^^fun));\n+static_assert (!is_static_member (^^alias));\n+static_assert (!is_static_member (^^var));\n+static_assert (!is_static_member (^^ref));\n+static_assert (!is_static_member (^^rref));\n+static_assert (!is_static_member (^^ptr));\n+static_assert (!is_static_member (^^cls_tmpl));\n+static_assert (!is_static_member (^^cls_tmpl));\n+static_assert (!is_static_member (^^incomplete_cls));\n+static_assert (!is_static_member (^^fun_tmpl));\n+static_assert (!is_static_member (^^fun_tmpl));\n+static_assert (!is_static_member (^^conc));\n+static_assert (!is_static_member (substitute (^^conc, { ^^int })));\n+static_assert (!is_static_member (^^var_tmpl));\n+static_assert (!is_static_member (^^var_tmpl));\n+static_assert (!is_static_member (^^cls_tmpl_alias));\n+static_assert (!is_static_member (^^cls_tmpl_alias));\n+static_assert (!is_static_member (^^Enum));\n+static_assert (!is_static_member (^^Enum::A));\n+static_assert (!is_static_member (^^Enum_class));\n+static_assert (!is_static_member (^^Enum_class::A));\n+static_assert (!is_static_member (^^decomp));\n+static_assert (!is_static_member (^^decomp_ref));\n+static_assert (!is_static_member (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_static_member (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_static_member (bases_of (^^Derived, access_context::unprivileged ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_static_member (^^x));\n+ static_assert (!is_static_member (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_static_member (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_static_member (^^S));\n+ static_assert (!is_static_member (^^E));\n+ static_assert (!is_static_member (^^F));\n+ static_assert (!is_static_member (^^G));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_string_literal1.C b/gcc/testsuite/g++.dg/reflect/is_string_literal1.C\nnew file mode 100644\nindex 00000000000..443c6d663f4\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_string_literal1.C\n@@ -0,0 +1,40 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::is_string_literal.\n+\n+#include \n+\n+constexpr char a = '\\0';\n+constexpr wchar_t b = L'\\0';\n+constexpr char16_t c = u'\\0';\n+constexpr char32_t d = U'\\0';\n+constexpr char8_t e = u8'\\0';\n+constexpr char f[] = \"foobar\";\n+static_assert (!std::is_string_literal (&a));\n+static_assert (!std::is_string_literal (&b));\n+static_assert (!std::is_string_literal (&c));\n+static_assert (!std::is_string_literal (&d));\n+static_assert (!std::is_string_literal (&e));\n+static_assert (!std::is_string_literal (&f[0]));\n+static_assert (!std::is_string_literal (f + 2));\n+static_assert (!std::is_string_literal (&f[2] + 3));\n+static_assert (std::is_string_literal (\"abcd\"));\n+static_assert (std::is_string_literal (&\"abcd\"[4]));\n+static_assert (std::is_string_literal (\"abcd\" + 2));\n+static_assert (std::is_string_literal (&\"abcd\"[1] + 1));\n+static_assert (std::is_string_literal (L\"foobar\"));\n+static_assert (std::is_string_literal (&L\"foobar\"[4]));\n+static_assert (std::is_string_literal (L\"foobar\" + 2));\n+static_assert (std::is_string_literal (&L\"foobar\"[1] + 1));\n+static_assert (std::is_string_literal (u\"corge\"));\n+static_assert (std::is_string_literal (&u\"corge\"[4]));\n+static_assert (std::is_string_literal (u\"corge\" + 2));\n+static_assert (std::is_string_literal (&u\"corge\"[1] + 1));\n+static_assert (std::is_string_literal (U\"garply\"));\n+static_assert (std::is_string_literal (&U\"garply\"[4]));\n+static_assert (std::is_string_literal (U\"garply\" + 2));\n+static_assert (std::is_string_literal (&U\"garply\"[1] + 1));\n+static_assert (std::is_string_literal (u8\"Certe, inquam, pértinax non ero tibíque, si mihi probábis ea, quæ dices, libénter asséntiar.\"));\n+static_assert (std::is_string_literal (&u8\"Certe, inquam, pértinax non ero tibíque, si mihi probábis ea, quæ dices, libénter asséntiar.\"[4]));\n+static_assert (std::is_string_literal (u8\"Certe, inquam, pértinax non ero tibíque, si mihi probábis ea, quæ dices, libénter asséntiar.\" + 2));\n+static_assert (std::is_string_literal (&u8\"Certe, inquam, pértinax non ero tibíque, si mihi probábis ea, quæ dices, libénter asséntiar.\"[1] + 1));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_structured_binding1.C b/gcc/testsuite/g++.dg/reflect/is_structured_binding1.C\nnew file mode 100644\nindex 00000000000..10bbeb16721\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_structured_binding1.C\n@@ -0,0 +1,99 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+#include \n+#include \n+\n+struct S\n+{\n+ int a;\n+ int b;\n+ double c;\n+};\n+\n+int\n+main ()\n+{\n+ {\n+ // The initializer for the structured binding declaration has array type.\n+ const int struct_binding[] = { 1, 2, 3 };\n+\n+ auto [x, y, z] = struct_binding;\n+\n+ static_assert (std::meta::is_structured_binding (^^x));\n+ static_assert (std::meta::is_structured_binding (^^y));\n+ static_assert (std::meta::is_structured_binding (^^z));\n+ }\n+\n+ {\n+ // The initializer for the structured binding declaration is tuple-like.\n+ auto struct_binding = std::make_tuple (1, 2, 3);\n+\n+ auto [x, y, z] = struct_binding;\n+\n+ static_assert (std::meta::is_structured_binding (^^x));\n+ static_assert (std::meta::is_structured_binding (^^y));\n+ static_assert (std::meta::is_structured_binding (^^z));\n+ }\n+\n+ {\n+ // The initializer for the structured binding declaration is a struct\n+ auto struct_binding = S{ 1, 2, 3.14 };\n+ auto [x, y, z] = struct_binding;\n+\n+ static_assert (std::meta::is_structured_binding (^^x));\n+ static_assert (std::meta::is_structured_binding (^^y));\n+ static_assert (std::meta::is_structured_binding (^^z));\n+ }\n+\n+ {\n+ // const auto structured binding\n+ const int struct_binding[] = { 10, 20 };\n+ const auto [x, y] = struct_binding;\n+\n+ static_assert (std::meta::is_structured_binding (^^x));\n+ static_assert (std::meta::is_structured_binding (^^y));\n+ }\n+\n+ {\n+ // auto& structured binding\n+ int struct_binding[] = { 30, 40 };\n+ auto &[x, y] = struct_binding;\n+\n+ static_assert (std::meta::is_structured_binding (^^x));\n+ static_assert (std::meta::is_structured_binding (^^y));\n+ }\n+\n+ {\n+ // const auto& structured binding\n+ const int struct_binding[] = { 50, 60 };\n+ const auto &[x, y] = struct_binding;\n+\n+ static_assert (std::meta::is_structured_binding (^^x));\n+ static_assert (std::meta::is_structured_binding (^^y));\n+ }\n+\n+ {\n+ // auto&& with rvalue\n+ auto &&[x, y] = std::make_tuple (90, 100);\n+\n+ static_assert (std::meta::is_structured_binding (^^x));\n+ static_assert (std::meta::is_structured_binding (^^y));\n+ }\n+\n+ {\n+ // Negative cases\n+ int var = 42;\n+ const int const_var = 43;\n+ int &ref_var = var;\n+\n+ S s{ 1, 2, 3.14 };\n+\n+ static_assert (!std::meta::is_structured_binding (^^var));\n+ static_assert (!std::meta::is_structured_binding (^^const_var));\n+ static_assert (!std::meta::is_structured_binding (^^ref_var));\n+ static_assert (!std::meta::is_structured_binding (^^s));\n+ static_assert (!std::meta::is_structured_binding (^^S));\n+ static_assert (!std::meta::is_structured_binding (^^int));\n+ static_assert (!std::meta::is_structured_binding (^^::));\n+ }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_structured_binding2.C b/gcc/testsuite/g++.dg/reflect/is_structured_binding2.C\nnew file mode 100644\nindex 00000000000..14a401a26d6\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_structured_binding2.C\n@@ -0,0 +1,35 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+#include \n+\n+struct S\n+{\n+ int a, b;\n+ explicit operator bool () const noexcept { return a == b; }\n+};\n+\n+template \n+void\n+bar ()\n+{\n+ if (auto [i, j] = S{ 7, 7 })\n+ {\n+ constexpr auto ri = ^^i;\n+ constexpr auto rj = ^^j;\n+\n+ static_assert (std::meta::is_structured_binding (ri));\n+ static_assert (std::meta::is_structured_binding (rj));\n+\n+ static_assert (std::meta::is_structured_binding (^^i));\n+ static_assert (std::meta::is_structured_binding (^^j));\n+\n+ static_assert (!std::meta::is_structured_binding (^^S));\n+ }\n+}\n+\n+int\n+main ()\n+{\n+ bar ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_template1.C b/gcc/testsuite/g++.dg/reflect/is_template1.C\nnew file mode 100644\nindex 00000000000..74180100ed0\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_template1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_template.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_template (null_reflection));\n+static_assert (!is_template (^^::));\n+static_assert (!is_template (^^ns));\n+static_assert (!is_template (^^ns_alias));\n+static_assert (!is_template (reflect_constant (3)));\n+static_assert (!is_template (^^cls));\n+static_assert (!is_template (^^cls::dm));\n+static_assert (!is_template (^^cls::ref_dm));\n+static_assert (!is_template (^^cls::static_dm));\n+static_assert (!is_template (^^cls::mem_fun));\n+static_assert (!is_template (^^cls::static_mem_fun));\n+static_assert (!is_template (^^cls::type));\n+static_assert (!is_template (^^cls_var));\n+static_assert (!is_template (^^onion));\n+static_assert (!is_template (^^anon));\n+static_assert (!is_template (^^fun));\n+static_assert (!is_template (^^alias));\n+static_assert (!is_template (^^var));\n+static_assert (!is_template (^^ref));\n+static_assert (!is_template (^^rref));\n+static_assert (!is_template (^^ptr));\n+static_assert (is_template (^^cls_tmpl));\n+static_assert (!is_template (^^cls_tmpl));\n+static_assert (!is_template (^^incomplete_cls));\n+static_assert (is_template (^^fun_tmpl));\n+static_assert (!is_template (^^fun_tmpl));\n+static_assert (is_template (^^conc));\n+static_assert (!is_template (substitute (^^conc, { ^^int })));\n+static_assert (is_template (^^var_tmpl));\n+static_assert (!is_template (^^var_tmpl));\n+static_assert (is_template (^^cls_tmpl_alias));\n+static_assert (!is_template (^^cls_tmpl_alias));\n+static_assert (!is_template (^^Enum));\n+static_assert (!is_template (^^Enum::A));\n+static_assert (!is_template (^^Enum_class));\n+static_assert (!is_template (^^Enum_class::A));\n+static_assert (!is_template (^^decomp));\n+static_assert (!is_template (^^decomp_ref));\n+static_assert (!is_template (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_template (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_template (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_template (^^T));\n+ static_assert (!is_template (R));\n+ static_assert (!is_template (R2));\n+ static_assert (is_template (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_template (^^p));\n+ static_assert (!is_template (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_template2.C b/gcc/testsuite/g++.dg/reflect/is_template2.C\nnew file mode 100644\nindex 00000000000..51ce6bf07c8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_template2.C\n@@ -0,0 +1,9 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_template.\n+\n+#include \n+#include \n+\n+static_assert (std::meta::is_template (^^std::vector));\n+static_assert (!std::meta::is_template (^^std::vector));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_type1.C b/gcc/testsuite/g++.dg/reflect/is_type1.C\nnew file mode 100644\nindex 00000000000..d2cdf777c90\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_type1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_type.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_type (null_reflection));\n+static_assert (!is_type (^^::));\n+static_assert (!is_type (^^ns));\n+static_assert (!is_type (^^ns_alias));\n+static_assert (!is_type (reflect_constant (3)));\n+static_assert (is_type (^^cls));\n+static_assert (!is_type (^^cls::dm));\n+static_assert (!is_type (^^cls::ref_dm));\n+static_assert (!is_type (^^cls::static_dm));\n+static_assert (!is_type (^^cls::mem_fun));\n+static_assert (!is_type (^^cls::static_mem_fun));\n+static_assert (is_type (^^cls::type));\n+static_assert (!is_type (^^cls_var));\n+static_assert (is_type (^^onion));\n+static_assert (!is_type (^^anon));\n+static_assert (!is_type (^^fun));\n+static_assert (is_type (^^alias));\n+static_assert (!is_type (^^var));\n+static_assert (!is_type (^^ref));\n+static_assert (!is_type (^^rref));\n+static_assert (!is_type (^^ptr));\n+static_assert (!is_type (^^cls_tmpl));\n+static_assert (is_type (^^cls_tmpl));\n+static_assert (is_type (^^incomplete_cls));\n+static_assert (!is_type (^^fun_tmpl));\n+static_assert (!is_type (^^fun_tmpl));\n+static_assert (!is_type (^^conc));\n+static_assert (!is_type (substitute (^^conc, { ^^int })));\n+static_assert (!is_type (^^var_tmpl));\n+static_assert (!is_type (^^var_tmpl));\n+static_assert (!is_type (^^cls_tmpl_alias));\n+static_assert (is_type (^^cls_tmpl_alias));\n+static_assert (is_type (^^Enum));\n+static_assert (!is_type (^^Enum::A));\n+static_assert (is_type (^^Enum_class));\n+static_assert (!is_type (^^Enum_class::A));\n+static_assert (!is_type (^^decomp));\n+static_assert (!is_type (^^decomp_ref));\n+static_assert (!is_type (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_type (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_type (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (is_type (^^T));\n+ static_assert (!is_type (R));\n+ static_assert (!is_type (R2));\n+ static_assert (is_type (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_type (^^p));\n+ static_assert (!is_type (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_type_alias1.C b/gcc/testsuite/g++.dg/reflect/is_type_alias1.C\nnew file mode 100644\nindex 00000000000..a404a5ccb34\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_type_alias1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_type_alias.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_type_alias (null_reflection));\n+static_assert (!is_type_alias (^^::));\n+static_assert (!is_type_alias (^^ns));\n+static_assert (!is_type_alias (^^ns_alias));\n+static_assert (!is_type_alias (reflect_constant (3)));\n+static_assert (!is_type_alias (^^cls));\n+static_assert (!is_type_alias (^^cls::dm));\n+static_assert (!is_type_alias (^^cls::ref_dm));\n+static_assert (!is_type_alias (^^cls::static_dm));\n+static_assert (!is_type_alias (^^cls::mem_fun));\n+static_assert (!is_type_alias (^^cls::static_mem_fun));\n+static_assert (is_type_alias (^^cls::type));\n+static_assert (!is_type_alias (^^cls_var));\n+static_assert (!is_type_alias (^^onion));\n+static_assert (!is_type_alias (^^anon));\n+static_assert (!is_type_alias (^^fun));\n+static_assert (is_type_alias (^^alias));\n+static_assert (!is_type_alias (^^var));\n+static_assert (!is_type_alias (^^ref));\n+static_assert (!is_type_alias (^^rref));\n+static_assert (!is_type_alias (^^ptr));\n+static_assert (!is_type_alias (^^cls_tmpl));\n+static_assert (!is_type_alias (^^cls_tmpl));\n+static_assert (!is_type_alias (^^incomplete_cls));\n+static_assert (!is_type_alias (^^fun_tmpl));\n+static_assert (!is_type_alias (^^fun_tmpl));\n+static_assert (!is_type_alias (^^conc));\n+static_assert (!is_type_alias (substitute (^^conc, { ^^int })));\n+static_assert (!is_type_alias (^^var_tmpl));\n+static_assert (!is_type_alias (^^var_tmpl));\n+static_assert (!is_type_alias (^^cls_tmpl_alias));\n+static_assert (is_type_alias (^^cls_tmpl_alias));\n+static_assert (!is_type_alias (^^Enum));\n+static_assert (!is_type_alias (^^Enum::A));\n+static_assert (!is_type_alias (^^Enum_class));\n+static_assert (!is_type_alias (^^Enum_class::A));\n+static_assert (!is_type_alias (^^decomp));\n+static_assert (!is_type_alias (^^decomp_ref));\n+static_assert (!is_type_alias (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_type_alias (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_type_alias (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_type_alias (^^T));\n+ static_assert (!is_type_alias (R));\n+ static_assert (!is_type_alias (R2));\n+ static_assert (!is_type_alias (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_type_alias (^^p));\n+ static_assert (!is_type_alias (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_type_alias2.C b/gcc/testsuite/g++.dg/reflect/is_type_alias2.C\nnew file mode 100644\nindex 00000000000..0fa0a46868c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_type_alias2.C\n@@ -0,0 +1,29 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_type_alias.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+template\n+struct S { };\n+\n+using U = S;\n+\n+template\n+using V = S;\n+\n+typedef int T;\n+\n+static_assert (!is_type_alias (^^S));\n+static_assert (is_type_alias (^^U));\n+static_assert (!is_type_alias (^^V));\n+static_assert (is_type_alias (^^V));\n+static_assert (is_type_alias (^^T));\n+static_assert (!is_type_alias (^^wchar_t));\n+static_assert (is_type_alias (^^size_t));\n+\n+using A = void(int, int);\n+static_assert (is_type_alias (^^A));\n+static_assert (!is_type_alias (dealias(^^A)));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_type_alias3.C b/gcc/testsuite/g++.dg/reflect/is_type_alias3.C\nnew file mode 100644\nindex 00000000000..7f73fba6a47\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_type_alias3.C\n@@ -0,0 +1,77 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_type_alias.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+typedef int I;\n+static_assert (is_type_alias (^^I));\n+static_assert (!is_type_alias (^^const I));\n+static_assert (!is_type_alias (^^I const));\n+static_assert (!is_type_alias (^^I &&));\n+static_assert (^^I != ^^int);\n+static_assert (^^const I == ^^const int);\n+static_assert (^^I const == ^^const int);\n+static_assert (^^I && == ^^int &&);\n+\n+typedef const int J;\n+static_assert (is_type_alias (^^J));\n+static_assert (!is_type_alias (^^const J));\n+static_assert (!is_type_alias (^^J const));\n+static_assert (!is_type_alias (^^J &));\n+static_assert (^^J != ^^const int);\n+static_assert (^^const J == ^^const int);\n+static_assert (^^J const == ^^const int);\n+static_assert (^^J & == ^^const int &);\n+\n+template struct cls_tmpl {};\n+template using cls_tmpl_alias = const cls_tmpl ;\n+\n+static_assert (is_type_alias (^^cls_tmpl_alias ));\n+static_assert (!is_type_alias (^^const cls_tmpl_alias ));\n+static_assert (!is_type_alias (^^cls_tmpl_alias const));\n+static_assert (!is_type_alias (^^cls_tmpl_alias &&));\n+static_assert (^^cls_tmpl_alias != ^^const cls_tmpl );\n+static_assert (^^cls_tmpl_alias != ^^const cls_tmpl_alias );\n+static_assert (^^const cls_tmpl_alias == ^^const cls_tmpl );\n+static_assert (^^cls_tmpl_alias const == ^^const cls_tmpl );\n+static_assert (^^cls_tmpl_alias && == ^^const cls_tmpl &&);\n+\n+namespace N1\n+{\n+ template struct cls_tmpl {};\n+ template using cls_tmpl_alias = const cls_tmpl ;\n+\n+ static_assert (is_type_alias (^^N1::cls_tmpl_alias ));\n+ static_assert (!is_type_alias (^^const N1::cls_tmpl_alias ));\n+ static_assert (!is_type_alias (^^N1::cls_tmpl_alias const));\n+ static_assert (!is_type_alias (^^N1::cls_tmpl_alias &&));\n+ static_assert (^^N1::cls_tmpl_alias != ^^const N1::cls_tmpl );\n+ static_assert (^^N1::cls_tmpl_alias != ^^const N1::cls_tmpl_alias );\n+ static_assert (^^const N1::cls_tmpl_alias == ^^const N1::cls_tmpl );\n+ static_assert (^^N1::cls_tmpl_alias const == ^^const N1::cls_tmpl );\n+ static_assert (^^N1::cls_tmpl_alias && == ^^const N1::cls_tmpl &&);\n+ static_assert (is_type_alias (^^N1:: template cls_tmpl_alias ));\n+ static_assert (!is_type_alias (^^const N1:: template cls_tmpl_alias ));\n+ static_assert (!is_type_alias (^^N1:: template cls_tmpl_alias const));\n+ static_assert (!is_type_alias (^^N1:: template cls_tmpl_alias &&));\n+ static_assert (^^N1:: template cls_tmpl_alias != ^^const N1:: template cls_tmpl );\n+ static_assert (^^N1:: template cls_tmpl_alias != ^^const N1:: template cls_tmpl_alias );\n+ static_assert (^^const N1:: template cls_tmpl_alias == ^^const N1:: template cls_tmpl );\n+ static_assert (^^N1:: template cls_tmpl_alias const == ^^const N1:: template cls_tmpl );\n+ static_assert (^^N1:: template cls_tmpl_alias && == ^^const N1:: template cls_tmpl &&);\n+}\n+\n+const I a = 42;\n+static_assert (!is_type_alias (type_of (^^a)));\n+static_assert (type_of (^^a) == ^^const int);\n+\n+J b = 42;\n+static_assert (!is_type_alias (type_of (^^b)));\n+static_assert (type_of (^^b) == ^^const int);\n+\n+cls_tmpl_alias c;\n+static_assert (!is_type_alias (type_of (^^c)));\n+static_assert (type_of (^^c) == ^^const cls_tmpl );\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_user_declared1.C b/gcc/testsuite/g++.dg/reflect/is_user_declared1.C\nnew file mode 100644\nindex 00000000000..0695fb43109\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_user_declared1.C\n@@ -0,0 +1,210 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_user_declared.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+ enum E {\n+ B, C, D\n+ };\n+ enum class F {\n+ G, H\n+ };\n+ struct S {};\n+ union U {};\n+ template \n+ void foo ();\n+ template \n+ static void bar ();\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_user_declared (null_reflection));\n+static_assert (!is_user_declared (^^::));\n+static_assert (!is_user_declared (^^ns));\n+static_assert (!is_user_declared (^^ns_alias));\n+static_assert (!is_user_declared (reflect_constant (3)));\n+static_assert (!is_user_declared (^^cls));\n+static_assert (!is_user_declared (^^cls::dm));\n+static_assert (!is_user_declared (^^cls::ref_dm));\n+static_assert (!is_user_declared (^^cls::static_dm));\n+static_assert (is_user_declared (^^cls::mem_fun));\n+static_assert (is_user_declared (^^cls::static_mem_fun));\n+static_assert (!is_user_declared (^^cls::type));\n+static_assert (!is_user_declared (^^cls::E));\n+static_assert (!is_user_declared (^^cls::B));\n+static_assert (!is_user_declared (^^cls::C));\n+static_assert (!is_user_declared (^^cls::D));\n+static_assert (!is_user_declared (^^cls::F));\n+static_assert (!is_user_declared (^^cls::F::G));\n+static_assert (!is_user_declared (^^cls::F::H));\n+static_assert (!is_user_declared (^^cls::S));\n+static_assert (!is_user_declared (^^cls::U));\n+static_assert (!is_user_declared (^^cls::foo));\n+static_assert (is_user_declared (^^cls::foo <0>));\n+static_assert (!is_user_declared (^^cls::bar));\n+static_assert (is_user_declared (^^cls::bar <42>));\n+static_assert (!is_user_declared (^^cls_var));\n+static_assert (!is_user_declared (^^onion));\n+static_assert (!is_user_declared (^^anon));\n+static_assert (is_user_declared (^^fun));\n+static_assert (!is_user_declared (^^alias));\n+static_assert (!is_user_declared (^^var));\n+static_assert (!is_user_declared (^^ref));\n+static_assert (!is_user_declared (^^rref));\n+static_assert (!is_user_declared (^^ptr));\n+static_assert (!is_user_declared (^^cls_tmpl));\n+static_assert (!is_user_declared (^^cls_tmpl));\n+static_assert (!is_user_declared (^^incomplete_cls));\n+static_assert (!is_user_declared (^^fun_tmpl));\n+static_assert (is_user_declared (^^fun_tmpl));\n+static_assert (!is_user_declared (^^conc));\n+static_assert (!is_user_declared (substitute (^^conc, { ^^int })));\n+static_assert (!is_user_declared (^^var_tmpl));\n+static_assert (!is_user_declared (^^var_tmpl));\n+static_assert (!is_user_declared (^^cls_tmpl_alias));\n+static_assert (!is_user_declared (^^cls_tmpl_alias));\n+static_assert (!is_user_declared (^^Enum));\n+static_assert (!is_user_declared (^^Enum::A));\n+static_assert (!is_user_declared (^^Enum_class));\n+static_assert (!is_user_declared (^^Enum_class::A));\n+static_assert (!is_user_declared (^^decomp));\n+static_assert (!is_user_declared (^^decomp_ref));\n+static_assert (!is_user_declared (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_user_declared (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_user_declared (bases_of (^^Derived, access_context::current ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_user_declared (^^x));\n+ static_assert (!is_user_declared (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_user_declared (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_user_declared (^^S));\n+ static_assert (!is_user_declared (^^E));\n+ static_assert (!is_user_declared (^^F));\n+ static_assert (!is_user_declared (^^G));\n+}\n+\n+void bar (int, long) = delete;\n+void baz (int) = delete (\"foobar\");\n+static_assert (is_user_declared (^^bar));\n+static_assert (is_user_declared (^^baz));\n+\n+struct S\n+{\n+ bool operator == (const S &) const = default;\n+ auto operator <=> (const S &) const = default;\n+ S &operator = (const S &) = default;\n+ int s;\n+ void foo ();\n+ template \n+ void bar ();\n+};\n+\n+struct V\n+{\n+ V (const V &);\n+};\n+\n+struct W\n+{\n+ W (const W &);\n+ bool operator == (const W &) const;\n+ auto operator <=> (const W &) const;\n+ W &operator = (const W &) { return *this; }\n+};\n+\n+struct X\n+{\n+ X (const X &);\n+ bool operator == (const X &) const = delete;\n+ auto operator <=> (const X &) const = delete;\n+ X &operator = (const X &) = delete;\n+ void foo () = delete;\n+ template \n+ void bar () = delete;\n+};\n+\n+static_assert (is_user_declared (^^S::operator ==));\n+static_assert (is_user_declared (^^S::operator <=>));\n+static_assert (is_user_declared (^^S::operator =));\n+static_assert (is_user_declared (^^S::foo));\n+static_assert (!is_user_declared (^^S::bar));\n+static_assert (is_user_declared (^^S::bar <42>));\n+static_assert (!is_user_declared (^^V::operator =));\n+static_assert (is_user_declared (^^W::operator ==));\n+static_assert (is_user_declared (^^W::operator <=>));\n+static_assert (is_user_declared (^^W::operator =));\n+static_assert (is_user_declared (^^X::operator ==));\n+static_assert (is_user_declared (^^X::operator <=>));\n+static_assert (is_user_declared (^^X::operator =));\n+static_assert (is_user_declared (^^X::foo));\n+static_assert (!is_user_declared (^^X::bar));\n+\n+struct Y\n+{\n+ ~Y () = default;\n+ int y;\n+};\n+static_assert (is_user_declared (^^Y::~Y));\n+\n+struct Z\n+{\n+ int z;\n+};\n+static_assert (!is_user_declared (^^Z::~Z));\n+\n+struct R\n+{\n+ ~R ();\n+ int r;\n+};\n+static_assert (is_user_declared (^^R::~R));\n+\n+struct H\n+{\n+ ~H () = delete;\n+ int h;\n+};\n+static_assert (is_user_declared (^^H::~H));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_user_declared2.C b/gcc/testsuite/g++.dg/reflect/is_user_declared2.C\nnew file mode 100644\nindex 00000000000..959a89ec72c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_user_declared2.C\n@@ -0,0 +1,91 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_deleted.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+template\n+consteval info\n+select_mem(info clazz, F f)\n+{\n+ for (info x : members_of(clazz, access_context::unchecked()))\n+ if (f(x))\n+ return x;\n+}\n+\n+struct ExplicitDef\n+{\n+ ExplicitDef() = default;\n+ ExplicitDef(const ExplicitDef&) = default;\n+ ExplicitDef(ExplicitDef&&) = default;\n+\n+ ExplicitDef& operator=(const ExplicitDef&) = default;\n+ ExplicitDef& operator=(ExplicitDef&&) = default;\n+ \n+ ~ExplicitDef() = default;\n+};\n+\n+static_assert (is_user_declared (select_mem (^^ExplicitDef, is_default_constructor)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDef, is_copy_constructor)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDef, is_move_constructor)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDef, is_copy_assignment)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDef, is_move_assignment)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDef, is_destructor)));\n+\n+struct ExplicitDel\n+{\n+ ExplicitDel() = default;\n+ ExplicitDel(const ExplicitDel&) = default;\n+ ExplicitDel(ExplicitDel&&) = default;\n+\n+ ExplicitDel& operator=(const ExplicitDel&) = default;\n+ ExplicitDel& operator=(ExplicitDel&&) = default;\n+ \n+ ~ExplicitDel() = default;\n+};\n+\n+static_assert (is_user_declared (select_mem (^^ExplicitDel, is_default_constructor)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDel, is_copy_constructor)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDel, is_move_constructor)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDel, is_copy_assignment)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDel, is_move_assignment)));\n+static_assert (is_user_declared (select_mem (^^ExplicitDel, is_destructor)));\n+\n+struct ImplicitDef\n+{\n+};\n+\n+static_assert (!is_user_declared (select_mem (^^ImplicitDef, is_default_constructor)));\n+static_assert (!is_user_declared (select_mem (^^ImplicitDef, is_copy_constructor)));\n+static_assert (!is_user_declared (select_mem (^^ImplicitDef, is_move_constructor)));\n+static_assert (!is_user_declared (select_mem (^^ImplicitDef, is_copy_assignment)));\n+static_assert (!is_user_declared (select_mem (^^ImplicitDef, is_move_assignment)));\n+static_assert (!is_user_declared (select_mem (^^ImplicitDef, is_destructor)));\n+\n+struct ExplicitRelOps\n+{\n+ bool operator==(const ExplicitRelOps&) const = default;\n+ auto operator<=>(const ExplicitRelOps&) const = default;\n+};\n+static_assert (is_user_declared (^^ExplicitRelOps::operator==));\n+static_assert (is_user_declared (^^ExplicitRelOps::operator<=>));\n+\n+struct DelRelOps\n+{\n+ bool operator==(const DelRelOps&) const = delete;\n+ auto operator<=>(const DelRelOps&) const = delete;\n+};\n+static_assert (is_user_declared (^^DelRelOps::operator==));\n+static_assert (is_user_declared (^^DelRelOps::operator<=>));\n+\n+struct ImplicitRelOps\n+{\n+ // operator== is implicitly declared\n+ auto operator<=>(const ImplicitRelOps&) const = default;\n+};\n+static_assert (!is_user_declared (^^ImplicitRelOps::operator==));\n+static_assert (is_user_declared (^^ImplicitRelOps::operator<=>));\n+\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_user_provided1.C b/gcc/testsuite/g++.dg/reflect/is_user_provided1.C\nnew file mode 100644\nindex 00000000000..8298ea569ca\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_user_provided1.C\n@@ -0,0 +1,210 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_user_provided.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+ enum E {\n+ B, C, D\n+ };\n+ enum class F {\n+ G, H\n+ };\n+ struct S {};\n+ union U {};\n+ template \n+ void foo ();\n+ template \n+ static void bar ();\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_user_provided (null_reflection));\n+static_assert (!is_user_provided (^^::));\n+static_assert (!is_user_provided (^^ns));\n+static_assert (!is_user_provided (^^ns_alias));\n+static_assert (!is_user_provided (reflect_constant (3)));\n+static_assert (!is_user_provided (^^cls));\n+static_assert (!is_user_provided (^^cls::dm));\n+static_assert (!is_user_provided (^^cls::ref_dm));\n+static_assert (!is_user_provided (^^cls::static_dm));\n+static_assert (is_user_provided (^^cls::mem_fun));\n+static_assert (is_user_provided (^^cls::static_mem_fun));\n+static_assert (!is_user_provided (^^cls::type));\n+static_assert (!is_user_provided (^^cls::E));\n+static_assert (!is_user_provided (^^cls::B));\n+static_assert (!is_user_provided (^^cls::C));\n+static_assert (!is_user_provided (^^cls::D));\n+static_assert (!is_user_provided (^^cls::F));\n+static_assert (!is_user_provided (^^cls::F::G));\n+static_assert (!is_user_provided (^^cls::F::H));\n+static_assert (!is_user_provided (^^cls::S));\n+static_assert (!is_user_provided (^^cls::U));\n+static_assert (!is_user_provided (^^cls::foo));\n+static_assert (is_user_provided (^^cls::foo <0>));\n+static_assert (!is_user_provided (^^cls::bar));\n+static_assert (is_user_provided (^^cls::bar <42>));\n+static_assert (!is_user_provided (^^cls_var));\n+static_assert (!is_user_provided (^^onion));\n+static_assert (!is_user_provided (^^anon));\n+static_assert (is_user_provided (^^fun));\n+static_assert (!is_user_provided (^^alias));\n+static_assert (!is_user_provided (^^var));\n+static_assert (!is_user_provided (^^ref));\n+static_assert (!is_user_provided (^^rref));\n+static_assert (!is_user_provided (^^ptr));\n+static_assert (!is_user_provided (^^cls_tmpl));\n+static_assert (!is_user_provided (^^cls_tmpl));\n+static_assert (!is_user_provided (^^incomplete_cls));\n+static_assert (!is_user_provided (^^fun_tmpl));\n+static_assert (is_user_provided (^^fun_tmpl));\n+static_assert (!is_user_provided (^^conc));\n+static_assert (!is_user_provided (substitute (^^conc, { ^^int })));\n+static_assert (!is_user_provided (^^var_tmpl));\n+static_assert (!is_user_provided (^^var_tmpl));\n+static_assert (!is_user_provided (^^cls_tmpl_alias));\n+static_assert (!is_user_provided (^^cls_tmpl_alias));\n+static_assert (!is_user_provided (^^Enum));\n+static_assert (!is_user_provided (^^Enum::A));\n+static_assert (!is_user_provided (^^Enum_class));\n+static_assert (!is_user_provided (^^Enum_class::A));\n+static_assert (!is_user_provided (^^decomp));\n+static_assert (!is_user_provided (^^decomp_ref));\n+static_assert (!is_user_provided (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_user_provided (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_user_provided (bases_of (^^Derived, access_context::current ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_user_provided (^^x));\n+ static_assert (!is_user_provided (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_user_provided (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_user_provided (^^S));\n+ static_assert (!is_user_provided (^^E));\n+ static_assert (!is_user_provided (^^F));\n+ static_assert (!is_user_provided (^^G));\n+}\n+\n+void bar (int, long) = delete;\n+void baz (int) = delete (\"foobar\");\n+static_assert (!is_user_provided (^^bar));\n+static_assert (!is_user_provided (^^baz));\n+\n+struct S\n+{\n+ bool operator == (const S &) const = default;\n+ auto operator <=> (const S &) const = default;\n+ S &operator = (const S &) = default;\n+ int s;\n+ void foo ();\n+ template \n+ void bar ();\n+};\n+\n+struct V\n+{\n+ V (const V &);\n+};\n+\n+struct W\n+{\n+ W (const W &);\n+ bool operator == (const W &) const;\n+ auto operator <=> (const W &) const;\n+ W &operator = (const W &) { return *this; }\n+};\n+\n+struct X\n+{\n+ X (const X &);\n+ bool operator == (const X &) const = delete;\n+ auto operator <=> (const X &) const = delete;\n+ X &operator = (const X &) = delete;\n+ void foo () = delete;\n+ template \n+ void bar () = delete;\n+};\n+\n+static_assert (!is_user_provided (^^S::operator ==));\n+static_assert (!is_user_provided (^^S::operator <=>));\n+static_assert (!is_user_provided (^^S::operator =));\n+static_assert (is_user_provided (^^S::foo));\n+static_assert (!is_user_provided (^^S::bar));\n+static_assert (is_user_provided (^^S::bar <42>));\n+static_assert (!is_user_provided (^^V::operator =));\n+static_assert (is_user_provided (^^W::operator ==));\n+static_assert (is_user_provided (^^W::operator <=>));\n+static_assert (is_user_provided (^^W::operator =));\n+static_assert (!is_user_provided (^^X::operator ==));\n+static_assert (!is_user_provided (^^X::operator <=>));\n+static_assert (!is_user_provided (^^X::operator =));\n+static_assert (!is_user_provided (^^X::foo));\n+static_assert (!is_user_provided (^^X::bar));\n+\n+struct Y\n+{\n+ ~Y () = default;\n+ int y;\n+};\n+static_assert (!is_user_provided (^^Y::~Y));\n+\n+struct Z\n+{\n+ int z;\n+};\n+static_assert (!is_user_provided (^^Z::~Z));\n+\n+struct R\n+{\n+ ~R ();\n+ int r;\n+};\n+static_assert (is_user_provided (^^R::~R));\n+\n+struct H\n+{\n+ ~H () = delete;\n+ int h;\n+};\n+static_assert (!is_user_provided (^^H::~H));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_user_provided2.C b/gcc/testsuite/g++.dg/reflect/is_user_provided2.C\nnew file mode 100644\nindex 00000000000..03a3e6eecc9\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_user_provided2.C\n@@ -0,0 +1,91 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_deleted.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+template\n+consteval info\n+select_mem(info clazz, F f)\n+{\n+ for (info x : members_of(clazz, access_context::unchecked()))\n+ if (f(x))\n+ return x;\n+}\n+\n+struct ExplicitDef\n+{\n+ ExplicitDef() = default;\n+ ExplicitDef(const ExplicitDef&) = default;\n+ ExplicitDef(ExplicitDef&&) = default;\n+\n+ ExplicitDef& operator=(const ExplicitDef&) = default;\n+ ExplicitDef& operator=(ExplicitDef&&) = default;\n+ \n+ ~ExplicitDef() = default;\n+};\n+\n+static_assert (!is_user_provided (select_mem (^^ExplicitDef, is_default_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDef, is_copy_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDef, is_move_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDef, is_copy_assignment)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDef, is_move_assignment)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDef, is_destructor)));\n+\n+struct ExplicitDel\n+{\n+ ExplicitDel() = default;\n+ ExplicitDel(const ExplicitDel&) = default;\n+ ExplicitDel(ExplicitDel&&) = default;\n+\n+ ExplicitDel& operator=(const ExplicitDel&) = default;\n+ ExplicitDel& operator=(ExplicitDel&&) = default;\n+ \n+ ~ExplicitDel() = default;\n+};\n+\n+static_assert (!is_user_provided (select_mem (^^ExplicitDel, is_default_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDel, is_copy_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDel, is_move_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDel, is_copy_assignment)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDel, is_move_assignment)));\n+static_assert (!is_user_provided (select_mem (^^ExplicitDel, is_destructor)));\n+\n+struct ImplicitDef\n+{\n+};\n+\n+static_assert (!is_user_provided (select_mem (^^ImplicitDef, is_default_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ImplicitDef, is_copy_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ImplicitDef, is_move_constructor)));\n+static_assert (!is_user_provided (select_mem (^^ImplicitDef, is_copy_assignment)));\n+static_assert (!is_user_provided (select_mem (^^ImplicitDef, is_move_assignment)));\n+static_assert (!is_user_provided (select_mem (^^ImplicitDef, is_destructor)));\n+\n+struct ExplicitRelOps\n+{\n+ bool operator==(const ExplicitRelOps&) const = default;\n+ auto operator<=>(const ExplicitRelOps&) const = default;\n+};\n+static_assert (!is_user_provided (^^ExplicitRelOps::operator==));\n+static_assert (!is_user_provided (^^ExplicitRelOps::operator<=>));\n+\n+struct DelRelOps\n+{\n+ bool operator==(const DelRelOps&) const = delete;\n+ auto operator<=>(const DelRelOps&) const = delete;\n+};\n+static_assert (!is_user_provided (^^DelRelOps::operator==));\n+static_assert (!is_user_provided (^^DelRelOps::operator<=>));\n+\n+struct ImplicitRelOps\n+{\n+ // operator== is implicitly declared\n+ auto operator<=>(const ImplicitRelOps&) const = default;\n+};\n+static_assert (!is_user_provided (^^ImplicitRelOps::operator==));\n+static_assert (!is_user_provided (^^ImplicitRelOps::operator<=>));\n+\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_variable1.C b/gcc/testsuite/g++.dg/reflect/is_variable1.C\nnew file mode 100644\nindex 00000000000..4260a44ced2\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_variable1.C\n@@ -0,0 +1,104 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_variable.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_variable (null_reflection));\n+static_assert (!is_variable (^^::));\n+static_assert (!is_variable (^^ns));\n+static_assert (!is_variable (^^ns_alias));\n+static_assert (!is_variable (reflect_constant (3)));\n+static_assert (!is_variable (^^cls));\n+static_assert (!is_variable (^^cls::dm));\n+static_assert (!is_variable (^^cls::ref_dm));\n+static_assert (is_variable (^^cls::static_dm));\n+static_assert (!is_variable (^^cls::mem_fun));\n+static_assert (!is_variable (^^cls::static_mem_fun));\n+static_assert (!is_variable (^^cls::type));\n+static_assert (is_variable (^^cls_var));\n+static_assert (!is_variable (^^onion));\n+static_assert (!is_variable (^^anon));\n+static_assert (!is_variable (^^fun));\n+static_assert (!is_variable (^^alias));\n+static_assert (is_variable (^^var));\n+// ??? EDG says this is _not_ a variable.\n+static_assert (is_variable (^^ref));\n+static_assert (is_variable (^^rref));\n+static_assert (is_variable (^^ptr));\n+static_assert (!is_variable (^^cls_tmpl));\n+static_assert (!is_variable (^^cls_tmpl));\n+static_assert (!is_variable (^^incomplete_cls));\n+static_assert (!is_variable (^^fun_tmpl));\n+static_assert (!is_variable (^^fun_tmpl));\n+static_assert (!is_variable (^^conc));\n+static_assert (!is_variable (substitute (^^conc, { ^^int })));\n+static_assert (!is_variable (^^var_tmpl));\n+static_assert (is_variable (^^var_tmpl));\n+static_assert (!is_variable (^^cls_tmpl_alias));\n+static_assert (!is_variable (^^cls_tmpl_alias));\n+static_assert (!is_variable (^^Enum));\n+static_assert (!is_variable (^^Enum::A));\n+static_assert (!is_variable (^^Enum_class));\n+static_assert (!is_variable (^^Enum_class::A));\n+static_assert (!is_variable (^^decomp));\n+static_assert (!is_variable (^^decomp_ref));\n+static_assert (is_variable (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_variable (dms));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_variable (^^T));\n+ static_assert (is_variable (R));\n+ static_assert (!is_variable (R2));\n+ static_assert (!is_variable (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (is_variable (^^p));\n+ static_assert (is_variable (^^c));\n+ static_assert (!is_variable (parameters_of (^^g)[0]));\n+ static_assert (!is_variable (parameters_of (^^g)[1]));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_variable_template1.C b/gcc/testsuite/g++.dg/reflect/is_variable_template1.C\nnew file mode 100644\nindex 00000000000..0fa772bdcbb\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_variable_template1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_variable_template.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_variable_template (null_reflection));\n+static_assert (!is_variable_template (^^::));\n+static_assert (!is_variable_template (^^ns));\n+static_assert (!is_variable_template (^^ns_alias));\n+static_assert (!is_variable_template (reflect_constant (3)));\n+static_assert (!is_variable_template (^^cls));\n+static_assert (!is_variable_template (^^cls::dm));\n+static_assert (!is_variable_template (^^cls::ref_dm));\n+static_assert (!is_variable_template (^^cls::static_dm));\n+static_assert (!is_variable_template (^^cls::mem_fun));\n+static_assert (!is_variable_template (^^cls::static_mem_fun));\n+static_assert (!is_variable_template (^^cls::type));\n+static_assert (!is_variable_template (^^cls_var));\n+static_assert (!is_variable_template (^^onion));\n+static_assert (!is_variable_template (^^anon));\n+static_assert (!is_variable_template (^^fun));\n+static_assert (!is_variable_template (^^alias));\n+static_assert (!is_variable_template (^^var));\n+static_assert (!is_variable_template (^^ref));\n+static_assert (!is_variable_template (^^rref));\n+static_assert (!is_variable_template (^^ptr));\n+static_assert (!is_variable_template (^^cls_tmpl));\n+static_assert (!is_variable_template (^^cls_tmpl));\n+static_assert (!is_variable_template (^^incomplete_cls));\n+static_assert (!is_variable_template (^^fun_tmpl));\n+static_assert (!is_variable_template (^^fun_tmpl));\n+static_assert (!is_variable_template (^^conc));\n+static_assert (!is_variable_template (substitute (^^conc, { ^^int })));\n+static_assert (is_variable_template (^^var_tmpl));\n+static_assert (!is_variable_template (^^var_tmpl));\n+static_assert (!is_variable_template (^^cls_tmpl_alias));\n+static_assert (!is_variable_template (^^cls_tmpl_alias));\n+static_assert (!is_variable_template (^^Enum));\n+static_assert (!is_variable_template (^^Enum::A));\n+static_assert (!is_variable_template (^^Enum_class));\n+static_assert (!is_variable_template (^^Enum_class::A));\n+static_assert (!is_variable_template (^^decomp));\n+static_assert (!is_variable_template (^^decomp_ref));\n+static_assert (!is_variable_template (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_variable_template (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_variable_template (bases_of (^^Derived, access_context::unchecked ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_variable_template (^^T));\n+ static_assert (!is_variable_template (R));\n+ static_assert (!is_variable_template (R2));\n+ static_assert (is_variable_template (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_variable_template (^^p));\n+ static_assert (!is_variable_template (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_virtual1.C b/gcc/testsuite/g++.dg/reflect/is_virtual1.C\nnew file mode 100644\nindex 00000000000..bf12250ebd5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_virtual1.C\n@@ -0,0 +1,60 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_virtual.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+void func () {}\n+\n+struct B {\n+ void nonvirt ();\n+ virtual void virt_no_override ();\n+ virtual void virt_implicit_override ();\n+ virtual void virt_explicit_override ();\n+ virtual void pure_virt () = 0;\n+ virtual ~B ();\n+};\n+\n+struct D : B {\n+ void nonvirt ();\n+ void virt_implicit_override ();\n+ void virt_explicit_override () override;\n+ void pure_virt ();\n+ ~D ();\n+};\n+\n+static_assert (!is_virtual (^^func));\n+static_assert (!is_virtual (^^B::nonvirt));\n+static_assert (is_virtual (^^B::virt_no_override));\n+static_assert (is_virtual (^^B::virt_implicit_override));\n+static_assert (is_virtual (^^B::virt_explicit_override));\n+static_assert (is_virtual (^^B::pure_virt));\n+static_assert (is_virtual (^^B::~B));\n+\n+static_assert (!is_virtual (^^D::nonvirt));\n+static_assert (is_virtual (^^D::virt_no_override));\n+static_assert (is_virtual (^^D::virt_implicit_override));\n+static_assert (is_virtual (^^D::virt_explicit_override));\n+static_assert (is_virtual (^^D::pure_virt));\n+static_assert (is_virtual (^^D::~D));\n+\n+struct E {\n+ ~E () = delete;\n+};\n+\n+struct F {\n+ virtual ~F () = delete;\n+};\n+\n+static_assert (!is_virtual (^^E::~E));\n+static_assert (is_virtual (^^F::~F));\n+\n+struct B1 {};\n+struct B2 {};\n+struct D2 : B1, virtual B2 { };\n+constexpr auto ctx = access_context::unchecked ();\n+\n+static_assert (!is_virtual (bases_of (^^D2, ctx)[0]));\n+static_assert (is_virtual (bases_of (^^D2, ctx)[1]));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_volatile1.C b/gcc/testsuite/g++.dg/reflect/is_volatile1.C\nnew file mode 100644\nindex 00000000000..cf945ca224b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_volatile1.C\n@@ -0,0 +1,116 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_volatile.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+int arr[] = {1, 2, 3};\n+auto [a1, a2, a3] = arr;\n+void fn();\n+auto &fn2();\n+enum Enum { A };\n+using Alias = int;\n+struct B {};\n+struct S : B {\n+ int mem;\n+ int : 0;\n+};\n+struct T {\n+ T ();\n+ T (const T &);\n+ ~T ();\n+};\n+struct U {\n+ int u;\n+};\n+template struct TCls {};\n+template void TFn();\n+template int TVar;\n+template concept Concept = requires { true; };\n+namespace NS {};\n+namespace NSAlias = NS;\n+\n+constexpr auto ctx = std::meta::access_context::current ();\n+\n+static_assert (!is_volatile (std::meta::reflect_constant (42)));\n+static_assert (!is_volatile (std::meta::reflect_object (arr[1])));\n+static_assert (!is_volatile (^^arr));\n+static_assert (!is_volatile (^^a3));\n+static_assert (!is_volatile (^^fn));\n+static_assert (!is_volatile (^^fn2));\n+static_assert (!is_volatile (^^Enum::A));\n+static_assert (!is_volatile (^^Alias));\n+static_assert (!is_volatile (^^S));\n+static_assert (!is_volatile (^^S::mem));\n+static_assert (!is_volatile (std::meta::members_of (^^S, ctx)[1]));\n+static_assert (!is_volatile (^^TCls));\n+static_assert (!is_volatile (^^TFn));\n+static_assert (!is_volatile (^^TVar));\n+static_assert (!is_volatile (^^Concept));\n+static_assert (!is_volatile (^^NSAlias));\n+static_assert (!is_volatile (^^NS));\n+static_assert (!is_volatile (std::meta::bases_of (^^S, ctx)[0]));\n+static_assert (!is_volatile (std::meta::data_member_spec (^^int, { .name = \"member\" })));\n+\n+int\n+foo (int a, const long b, T c, int d[4], T &e)\n+{\n+ static_assert (!is_volatile (^^a));\n+ static_assert (!is_volatile (^^b));\n+ static_assert (!is_volatile (^^c));\n+ static_assert (!is_volatile (^^d));\n+ static_assert (!is_volatile (^^e));\n+ static_assert (!is_const (parameters_of (^^foo)[0]));\n+ static_assert (!is_const (parameters_of (^^foo)[1]));\n+ static_assert (!is_const (parameters_of (^^foo)[2]));\n+ static_assert (!is_const (parameters_of (^^foo)[3]));\n+ static_assert (!is_const (parameters_of (^^foo)[4]));\n+ return 0;\n+}\n+\n+static_assert (!is_volatile (std::meta::reflect_constant (42)));\n+static_assert (!is_volatile (std::meta::reflect_constant (42.0)));\n+//static_assert (!is_volatile (std::meta::reflect_constant (U { 42 })));\n+static_assert (!is_volatile (std::meta::reflect_object (arr[1])));\n+static_assert (!is_volatile (^^arr));\n+static_assert (!is_volatile (^^fn));\n+static_assert (!is_volatile (^^Enum::A));\n+static_assert (!is_volatile (^^A));\n+static_assert (!is_volatile (^^S::mem));\n+\n+volatile int vi = 42;\n+static_assert (is_volatile (^^vi));\n+using uvi = volatile int;\n+static_assert (is_volatile (^^uvi));\n+const volatile long vl = 42L;\n+static_assert (is_volatile (^^vl));\n+extern const volatile short cv = 2;\n+static_assert (is_volatile (^^cv));\n+struct V { volatile int a; static volatile int b; };\n+static_assert (is_volatile (^^V::a));\n+static_assert (is_volatile (^^V::b));\n+\n+volatile int arr2[] = {3, 4, 5};\n+volatile int arr3[2][2][2] = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};\n+struct W {\n+ void foo () volatile {}\n+ void bar () const {}\n+};\n+static_assert (is_volatile (^^arr2));\n+static_assert (is_volatile (^^arr3));\n+static_assert (is_volatile (^^W::foo));\n+static_assert (!is_volatile (^^W::bar));\n+static_assert (!is_volatile (^^int));\n+static_assert (!is_volatile (^^const int));\n+static_assert (is_volatile (^^volatile int));\n+static_assert (is_volatile (^^const volatile int));\n+static_assert (!is_volatile (^^int [2]));\n+static_assert (!is_volatile (^^const int [2]));\n+static_assert (is_volatile (^^volatile int [2]));\n+static_assert (is_volatile (^^const volatile int [2]));\n+static_assert (!is_volatile (^^int (int)));\n+static_assert (!is_volatile (^^int (int) const));\n+static_assert (is_volatile (^^int (int) volatile));\n+static_assert (is_volatile (^^int (int) const volatile));\ndiff --git a/gcc/testsuite/g++.dg/reflect/lex1.C b/gcc/testsuite/g++.dg/reflect/lex1.C\nnew file mode 100644\nindex 00000000000..ec01d7a0ced\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/lex1.C\n@@ -0,0 +1,13 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test lexical aspects of reflection.\n+\n+constexpr int sz = 2;\n+\n+void\n+g ()\n+{\n+ int arr[10];\n+ arr[::sz] = 42;\n+ int arr2[:> = { 1, 2 };\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/lex2.C b/gcc/testsuite/g++.dg/reflect/lex2.C\nnew file mode 100644\nindex 00000000000..8431c040486\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/lex2.C\n@@ -0,0 +1,21 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^int);\n+\n+namespace colon_parsing {\n+constexpr int x = 4;\n+constexpr auto rx = ^^x;\n+static_assert([:rx:] == 4);\n+\n+constexpr unsigned Idx = 1;\n+constexpr int arr[] = {1, 2, 3};\n+static_assert(arr[::colon_parsing::Idx] == 2);\n+\n+constexpr info rIdx = ^^Idx;\n+static_assert([:::colon_parsing::rIdx:] == 1);\n+\n+struct WithIndexOperator {\n+ bool operator[:>(int); // Test interaction with ':>'-digraph (i.e., ']').\n+};\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/mangle1.C b/gcc/testsuite/g++.dg/reflect/mangle1.C\nnew file mode 100644\nindex 00000000000..27d5edf02bf\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/mangle1.C\n@@ -0,0 +1,252 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection -O0\" }\n+\n+#include \n+#include \n+\n+int arr[] = {1, 2, 3};\n+auto [a1, a2, a3] = arr;\n+[[=1]] void fn (int n);\n+enum Enum { A };\n+using Alias = int;\n+struct B {};\n+struct S : B {\n+ int mem;\n+ int : 0;\n+ static int var;\n+};\n+template struct TCls {};\n+template void TFn ();\n+template int TVar;\n+template using TAlias = TCls ;\n+template concept Concept = requires { true; };\n+namespace NS {};\n+namespace NSAlias = NS;\n+namespace NS2 {\n+ int arr[] = {1, 2, 3};\n+ auto [a1, a2, a3] = arr;\n+ [[=1]] void fn (int n, long m);\n+ enum Enum { A };\n+ using Alias = decltype (^^int);\n+ struct B {};\n+ struct S : B {\n+ int mem;\n+ int : 0;\n+ int : 3;\n+ int : 5;\n+ static int var;\n+ template static T TVar;\n+ };\n+ template struct TCls {};\n+ template void TFn ();\n+ template int TVar;\n+ template using TAlias = TCls ;\n+ template concept Concept = requires { true; };\n+ struct V { int a, b, c; };\n+ S s;\n+ namespace NS3 {\n+ auto [a1, a2, a3] = arr;\n+ }\n+ namespace NSAlias = NS3;\n+ enum { C };\n+ template \n+ struct W : B, ::B {};\n+ static union { int au; };\n+ struct X {\n+ union { int a; };\n+ X &operator + (const X &);\n+ operator int ();\n+ };\n+ template \n+ struct Y {\n+ union { T a; };\n+ };\n+ struct Z {\n+ };\n+}\n+\n+constexpr auto ctx = std::meta::access_context::current ();\n+\n+template \n+void\n+foo ()\n+{\n+}\n+\n+template \n+void\n+bar ()\n+{\n+}\n+\n+void\n+baz (int x)\n+{\n+ int v = 42;\n+ foo <1, std::meta::info> ();\n+ foo <2, const std::meta::info> ();\n+ bar <110, std::meta::info {}> (); // null reflection\n+ bar <120, std::meta::reflect_constant (42)> (); // value\n+ bar <121, std::meta::reflect_constant (42.0)> (); // value\n+ bar <122, std::meta::reflect_constant (NS2::V { 1, 2, 3 })> (); // value\n+ bar <130, std::meta::reflect_object (arr[1])> (); // object\n+ bar <131, std::meta::reflect_object (NS2::arr[1])> (); // object\n+ bar <132, std::meta::reflect_object (NS2::s.mem)> (); // object\n+ bar <140, ^^arr> (); // variable\n+ bar <141, ^^NS2::arr> (); // variable\n+ bar <142, ^^x> (); // variable\n+ bar <143, ^^v> (); // variable\n+ bar <144, members_of (^^NS2::NS3, ctx)[0]> (); // variable\n+ bar <145, ^^S::var> (); // variable\n+ bar <146, ^^NS2::S::var> (); // variable\n+ bar <147, ^^TVar <42>> (); // variable\n+ bar <148, ^^TVar <42>> (); // variable\n+ bar <149, ^^NS2::S::TVar > (); // variable\n+ bar <150, ^^a3> (); // structured binding\n+ bar <151, ^^NS2::a3> (); // structured binding\n+ bar <160, ^^fn> (); // function\n+ bar <161, ^^NS2::fn> (); // function\n+// TODO: These don't work, is_function is false for them.\n+// Unsure if they should be instantiated when reflected or what.\n+// bar <162, ^^TFn <42>> (); // function\n+// bar <163, ^^NS2::TFn <0U>> (); // function\n+// bar <164, ^^NS2::TFn <^^int>> (); // function\n+ bar <165, ^^NS2::X::operator+> (); // function\n+ bar <166, (members_of (^^NS2::Z, ctx) | std::views::filter (std::meta::is_default_constructor) | std::ranges::to ())[0]> (); // function\n+ bar <167, (members_of (^^NS2::Z, ctx) | std::views::filter (std::meta::is_copy_constructor) | std::ranges::to ())[0]> (); // function\n+ bar <168, (members_of (^^NS2::Z, ctx) | std::views::filter (std::meta::is_copy_assignment) | std::ranges::to ())[0]> (); // function\n+ bar <169, (members_of (^^NS2::Z, ctx) | std::views::filter (std::meta::is_destructor) | std::ranges::to ())[0]> (); // function\n+ bar <170, parameters_of (^^fn)[0]> (); // function parameter\n+ bar <171, parameters_of (^^NS2::fn)[0]> (); // function parameter\n+ bar <172, parameters_of (^^NS2::fn)[1]> (); // function parameter\n+ bar <180, ^^Enum::A> (); // enumerator\n+ bar <181, ^^NS2::Enum::A> (); // enumerator\n+ bar <182, ^^NS2::C> (); // enumerator\n+ bar <190, annotations_of (^^fn)[0]> (); // annotation\n+ bar <200, ^^Alias> (); // type alias\n+ bar <201, ^^NS2::Alias> (); // type alias\n+ bar <202, ^^TAlias <42>> (); // type alias\n+ bar <203, ^^NS2::TAlias <0U>> (); // type alias\n+ bar <210, ^^S> (); // type\n+ bar <211, ^^NS2::S> (); // type\n+ bar <212, ^^const int> (); // type\n+ bar <213, ^^decltype (nullptr)> (); // type\n+ bar <214, ^^decltype (^^::)> (); // type\n+ bar <215, ^^TCls <42>> (); // type\n+ bar <216, ^^NS2::TCls <42>> (); // type\n+ bar <220, ^^S::mem> (); // non-static data member\n+ bar <221, ^^NS2::S::mem> (); // non-static data member\n+ bar <222, ^^NS2::au> (); // non-static data member\n+ bar <223, ^^NS2::X::a> (); // non-static data member\n+ bar <224, ^^NS2::Y ::a> (); // non-static data member\n+ bar <230, members_of (^^S, ctx)[1]> (); // unnamed bit-field\n+ bar <231, members_of (^^NS2::S, ctx)[1]> (); // unnamed bit-field\n+ bar <232, members_of (^^NS2::S, ctx)[2]> (); // unnamed bit-field\n+ bar <233, members_of (^^NS2::S, ctx)[3]> (); // unnamed bit-field\n+ bar <240, ^^TCls> (); // class template\n+ bar <241, ^^NS2::TCls> (); // class template\n+ bar <250, ^^TFn> (); // function template\n+ bar <251, ^^NS2::TFn> (); // function template\n+ bar <260, ^^TVar> (); // variable template\n+ bar <261, ^^NS2::TVar> (); // variable template\n+ bar <270, ^^TAlias> (); // alias template\n+ bar <271, ^^NS2::TAlias> (); // alias template\n+ bar <280, ^^Concept> (); // concept\n+ bar <281, ^^NS2::Concept> (); // concept\n+ bar <290, ^^NSAlias> (); // namespace alias\n+ bar <291, ^^NS2::NSAlias> (); // namespace alias\n+ bar <300, ^^NS> (); // namespace\n+ bar <301, ^^NS2::NS3> (); // namespace\n+ bar <310, ^^::> (); // global namespace\n+ bar <320, bases_of (^^S, ctx)[0]> (); // direct base class relationship\n+ bar <321, bases_of (^^NS2::S, ctx)[0]> (); // direct base class relationship\n+ bar <322, bases_of (^^NS2::W , ctx)[0]> (); // direct base class relationship\n+ bar <323, bases_of (^^NS2::W , ctx)[1]> (); // direct base class relationship\n+ bar <330, data_member_spec (^^S, { .name = \"member\" })> (); // data member description\n+ bar <331, data_member_spec (^^NS2::S, { .name = \"m\", .alignment = 16, .no_unique_address = true })> (); // data member description\n+ bar <332, data_member_spec (^^unsigned short, { .name = \"b\", .bit_width = 5 })> (); // data member description\n+ bar <333, data_member_spec (^^long, { .bit_width = 3 })> (); // data member description\n+ bar <334, data_member_spec (^^int, { .bit_width = 0 })> (); // data member description\n+ bar <340, ^^NS2::X::~X> (); // function\n+}\n+\n+// { dg-final { scan-assembler \"_Z3fooILi1EDmEvv\" } }\n+// { dg-final { scan-assembler \"_Z3fooILi2EKDmEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi110ELDmnuEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi120ELDmvlLi42EEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi121ELDmvlLd4045000000000000EEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi122ELDmobL_Z29_ZTAXtlN3NS21VELi1ELi2ELi3EEEEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi130ELDmobixL_Z3arrELl1EEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi131ELDmobixL_ZN3NS23arrEELl1EEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi132ELDmobdtL_ZN3NS21sEE3memEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi140ELDmvr3arrEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi141ELDmvrN3NS23arrEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi142ELDmvrZ3baziE1xEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi143ELDmvrZ3baziE1vEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi144ELDmvrN3NS23NS324_ZN3NS23NS3DC2a12a22a3EEEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi145ELDmvrN1S3varEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi146ELDmvrN3NS21S3varEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi147ELDmvr4TVarILi42EEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi148ELDmvr4TVarILi42EEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi149ELDmvrN3NS21S4TVarIiEEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi150ELDmsb2a3EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi151ELDmsbN3NS22a3EEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi160ELDmfn2fniEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi161ELDmfnN3NS22fnEilEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi165ELDmfnN3NS21XplERKS1_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi166ELDmfnN3NS21ZC4EvEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi167ELDmfnN3NS21ZC4ERKS1_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi168ELDmfnN3NS21ZaSERKS1_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi169ELDmfnN3NS21ZD4EvEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi170ELDmpa_2fniEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi171ELDmpa_N3NS22fnEilEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi172ELDmpa0_N3NS22fnEilEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi180ELDmen4Enum1AEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi181ELDmen3NS24Enum1AEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi182ELDmen3NS2Uej1C1CEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi190ELDman_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi200ELDmta5AliasEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi201ELDmta3NS25AliasEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi202ELDmta6TAliasILi42EEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi203ELDmta3NS26TAliasILj0EEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi210ELDmty1SEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi211ELDmtyN3NS21SEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi212ELDmtyKiEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi213ELDmtyDnEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi214ELDmtyDmEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi215ELDmty4TClsILi42EEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi216ELDmtyN3NS24TClsILi42EEEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi220ELDmdm1S3memEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi221ELDmdm3NS21S3memEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi222ELDmdm2auEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi223ELDmdm3NS21XUt_1aEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi224ELDmdm3NS21YIiEUt_1aEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi230ELDmun1S_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi231ELDmun3NS21S_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi232ELDmun3NS21S0_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi233ELDmun3NS21S1_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi240ELDmct4TClsEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi241ELDmct3NS24TClsEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi250ELDmft3TFnEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi251ELDmft3NS23TFnEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi260ELDmvt4TVarEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi261ELDmvt3NS24TVarEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi270ELDmat6TAliasEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi271ELDmat3NS26TAliasEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi280ELDmco7ConceptEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi281ELDmco3NS27ConceptEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi290ELDmna7NSAliasEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi291ELDmna3NS27NSAliasEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi300ELDmns2NSEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi301ELDmns3NS23NS3EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi310ELDmngEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi320ELDmba_1SEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi321ELDmba_N3NS21SEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi322ELDmba_N3NS21WIiEEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi323ELDmba0_N3NS21WIfEEEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi330ELDmds1S_6member___EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi331ELDmdsN3NS21SE_1m_16__nEEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi332ELDmdst_1b__5_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi333ELDmdsl___3_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi334ELDmdsi___0_EEvv\" } }\n+// { dg-final { scan-assembler \"_Z3barILi340ELDmfnN3NS21XD4EvEEvv\" } }\ndiff --git a/gcc/testsuite/g++.dg/reflect/member-visibility1.C b/gcc/testsuite/g++.dg/reflect/member-visibility1.C\nnew file mode 100644\nindex 00000000000..ff10c510c78\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member-visibility1.C\n@@ -0,0 +1,412 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Tests std::meta::is_public, std::meta::is_private, std::meta::is_protected\n+#include \n+\n+class PublicBase { };\n+class ProtectedBase { };\n+class PrivateBase { };\n+class VirtualBase { };\n+class VirtualProtectedBase { };\n+\n+class A : public PublicBase, protected ProtectedBase, private PrivateBase, \n+\t virtual VirtualBase, protected virtual VirtualProtectedBase\n+{\n+ void test_bases_visibility()\n+ {\n+ constexpr auto ctx = std::meta::access_context::unchecked();\n+ static_assert (std::meta::bases_of (^^A, ctx).size() == 5);\n+\n+ static_assert (std::meta::is_public (std::meta::bases_of (^^A, ctx)[0]));\n+ static_assert (std::meta::is_protected (std::meta::bases_of (^^A, ctx)[1]));\n+ static_assert (std::meta::is_private (std::meta::bases_of (^^A, ctx)[2]));\n+ static_assert (std::meta::is_private (std::meta::bases_of (^^A, ctx)[3]));\n+ static_assert (std::meta::is_protected (std::meta::bases_of (^^A, ctx)[4]));\n+ }\n+\n+// private:\n+ A(int)\n+ {\n+ int a;\n+ static_assert (!std::meta::is_public (std::meta::parent_of (^^a)));\n+ static_assert (!std::meta::is_protected (std::meta::parent_of (^^a)));\n+ static_assert (std::meta::is_private (std::meta::parent_of (^^a)));\n+ }\n+\n+protected:\n+ A(bool)\n+ {\n+ int a;\n+ static_assert (!std::meta::is_public (std::meta::parent_of (^^a)));\n+ static_assert (std::meta::is_protected (std::meta::parent_of (^^a)));\n+ static_assert (!std::meta::is_private (std::meta::parent_of (^^a)));\n+ }\n+\n+ ~A() = default;\n+\n+public:\n+ A()\n+ {\n+ int a;\n+ static_assert (std::meta::is_public (std::meta::parent_of (^^a)));\n+ static_assert (!std::meta::is_protected (std::meta::parent_of (^^a)));\n+ static_assert (!std::meta::is_private (std::meta::parent_of (^^a)));\n+ }\n+\n+ int public_field;\n+ static int public_static_field;\n+\n+ int public_function();\n+ static int public_static_function();\n+ virtual void public_virtual_function() = 0;\n+\n+ template \n+ void public_template_function();\n+ template \n+ static void public_static_template_function();\n+\n+ using public_type_alias = int;\n+\n+ struct PublicCls {};\n+\n+ enum PublicEnum {\n+ B, C, D\n+ };\n+\n+ enum class PublicEnumClass {\n+ E, F\n+ };\n+\n+ union PublicUnion {};\n+\n+protected:\n+\n+ int protected_field;\n+ static int protected_static_field;\n+\n+ int protected_function();\n+ static int protected_static_function();\n+ virtual void protected_virtual_function() = 0;\n+\n+ template \n+ void protected_template_function();\n+ template \n+ static void protected_static_template_function();\n+\n+ using protected_type_alias = int;\n+\n+ struct ProtectedCls {};\n+\n+ enum ProtectedEnum {\n+ G, H\n+ };\n+\n+ enum class ProtectedEnumClass {\n+ I, J\n+ };\n+\n+ union ProtectedUnion {};\n+\n+private:\n+\n+ int private_field;\n+ static int private_static_field;\n+\n+ int private_function();\n+ static int private_static_function();\n+ virtual void private_virtual_function() = 0;\n+\n+ template \n+ void private_template_function();\n+ template \n+ static void private_static_template_function();\n+\n+ using private_type_alias = int;\n+\n+ struct PrivateCls {};\n+\n+ enum PrivateEnum {\n+ K, L\n+ };\n+\n+ enum class PrivateEnumClass {\n+ M, N\n+ };\n+\n+ union PrivateUnion {};\n+\n+\n+ void test_is_public()\n+ {\n+ // positive cases for public class members\n+ static_assert (std::meta::is_public (^^public_field));\n+ static_assert (std::meta::is_public (^^public_static_field));\n+\n+ static_assert (std::meta::is_public(^^public_function));\n+ static_assert (std::meta::is_public (^^public_static_function));\n+ static_assert (std::meta::is_public (^^public_virtual_function));\n+\n+ static_assert (std::meta::is_public (^^public_template_function));\n+ static_assert (std::meta::is_public (^^public_template_function));\n+\n+ static_assert (std::meta::is_public (^^public_static_template_function));\n+ static_assert (std::meta::is_public (^^public_static_template_function));\n+\n+ static_assert (std::meta::is_public (^^public_type_alias));\n+ static_assert (std::meta::is_public (^^PublicCls));\n+ static_assert (std::meta::is_public (^^PublicUnion));\n+\n+ static_assert (std::meta::is_public (^^PublicEnum));\n+ static_assert (std::meta::is_public (^^PublicEnumClass)); \n+\n+ static_assert (std::meta::is_public (^^B));\n+ static_assert (std::meta::is_public (^^C));\n+ static_assert (std::meta::is_public (^^D));\n+\n+ // negative test cases\n+ static_assert (!std::meta::is_public (^^A));\n+\n+ // scoped enum values are not class members\n+ static_assert (!std::meta::is_public (^^PublicEnumClass::E));\n+ static_assert (!std::meta::is_public (^^PublicEnumClass::F));\n+\n+ static_assert (!std::meta::is_public (^^ProtectedEnumClass::I));\n+ static_assert (!std::meta::is_public (^^ProtectedEnumClass::J));\n+\n+ static_assert (!std::meta::is_public (^^PrivateEnumClass::M));\n+ static_assert (!std::meta::is_public (^^PrivateEnumClass::N));\n+\n+ // protected class members\n+ static_assert (!std::meta::is_public (^^~A));\n+\n+ static_assert (!std::meta::is_public (^^protected_field));\n+ static_assert (!std::meta::is_public (^^protected_static_field));\n+\n+ static_assert (!std::meta::is_public (^^protected_function));\n+ static_assert (!std::meta::is_public (^^protected_static_function));\n+ static_assert (!std::meta::is_public (^^protected_virtual_function));\n+\n+ static_assert (!std::meta::is_public (^^protected_template_function));\n+ static_assert (!std::meta::is_public (^^protected_template_function));\n+\n+ static_assert (!std::meta::is_public (^^protected_static_template_function));\n+ static_assert (!std::meta::is_public (^^protected_static_template_function));\n+\n+ static_assert (!std::meta::is_public (^^protected_type_alias)); \n+ static_assert (!std::meta::is_public (^^ProtectedCls)); \n+ static_assert (!std::meta::is_public (^^ProtectedUnion));\n+\n+ static_assert (!std::meta::is_public (^^ProtectedEnum));\n+ static_assert (!std::meta::is_public (^^ProtectedEnumClass)); \n+\n+ static_assert (!std::meta::is_public (^^G));\n+ static_assert (!std::meta::is_public (^^H));\n+\n+ // private class members\n+ static_assert (!std::meta::is_public (^^private_field));\n+ static_assert (!std::meta::is_public (^^private_static_field));\n+\n+ static_assert (!std::meta::is_public (^^private_function));\n+ static_assert (!std::meta::is_public (^^private_static_function));\n+ static_assert (!std::meta::is_public (^^private_virtual_function));\n+\n+ static_assert (!std::meta::is_public (^^private_template_function));\n+ static_assert (!std::meta::is_public (^^private_template_function));\n+\n+ static_assert (!std::meta::is_public (^^private_static_template_function));\n+ static_assert (!std::meta::is_public (^^private_static_template_function));\n+\n+ static_assert (!std::meta::is_public (^^private_type_alias)); \n+ static_assert (!std::meta::is_public (^^PrivateCls)); \n+ static_assert (!std::meta::is_public (^^PrivateUnion));\n+\n+ static_assert (!std::meta::is_public (^^PrivateEnum));\n+ static_assert (!std::meta::is_public (^^PrivateEnumClass)); \n+\n+ static_assert (!std::meta::is_public (^^K));\n+ static_assert (!std::meta::is_public (^^L));\n+ }\n+\n+ void test_is_protected()\n+ {\n+ // positive cases for protected class members\n+ static_assert (std::meta::is_protected (^^~A));\n+\n+ static_assert (std::meta::is_protected (^^protected_field));\n+ static_assert (std::meta::is_protected (^^protected_static_field));\n+\n+ static_assert (std::meta::is_protected (^^protected_function));\n+ static_assert (std::meta::is_protected (^^protected_static_function));\n+ static_assert (std::meta::is_protected (^^protected_virtual_function));\n+\n+ static_assert (std::meta::is_protected (^^protected_template_function));\n+ static_assert (std::meta::is_protected (^^protected_template_function));\n+\n+ static_assert (std::meta::is_protected (^^protected_static_template_function));\n+ static_assert (std::meta::is_protected (^^protected_static_template_function));\n+\n+ static_assert (std::meta::is_protected (^^protected_type_alias)); \n+ static_assert (std::meta::is_protected (^^ProtectedCls)); \n+ static_assert (std::meta::is_protected (^^ProtectedUnion));\n+\n+ static_assert (std::meta::is_protected (^^ProtectedEnum));\n+ static_assert (std::meta::is_protected (^^ProtectedEnumClass)); \n+\n+ static_assert (std::meta::is_protected (^^G));\n+ static_assert (std::meta::is_protected (^^H));\n+\n+ // negative cases:\n+ static_assert (!std::meta::is_protected (^^A));\n+ // scoped enum values are not class members\n+ static_assert (!std::meta::is_protected (^^PublicEnumClass::E));\n+ static_assert (!std::meta::is_protected (^^PublicEnumClass::F));\n+\n+ static_assert (!std::meta::is_protected (^^ProtectedEnumClass::I));\n+ static_assert (!std::meta::is_protected (^^ProtectedEnumClass::J));\n+\n+ static_assert (!std::meta::is_protected (^^PrivateEnumClass::M));\n+ static_assert (!std::meta::is_protected (^^PrivateEnumClass::N));\n+\n+ // public class members\n+ static_assert (!std::meta::is_protected (^^public_field));\n+ static_assert (!std::meta::is_protected (^^public_static_field));\n+\n+ static_assert (!std::meta::is_protected (^^public_function));\n+ static_assert (!std::meta::is_protected (^^public_static_function));\n+ static_assert (!std::meta::is_protected (^^public_virtual_function));\n+\n+ static_assert (!std::meta::is_protected (^^public_template_function));\n+ static_assert (!std::meta::is_protected (^^public_template_function));\n+\n+ static_assert (!std::meta::is_protected (^^public_static_template_function));\n+ static_assert (!std::meta::is_protected (^^public_static_template_function));\n+\n+ static_assert (!std::meta::is_protected (^^public_type_alias)); \n+ static_assert (!std::meta::is_protected (^^PublicCls)); \n+ static_assert (!std::meta::is_protected (^^PublicUnion));\n+\n+ static_assert (!std::meta::is_protected (^^PublicEnum));\n+ static_assert (!std::meta::is_protected (^^PublicEnumClass)); \n+\n+ static_assert (!std::meta::is_protected (^^B));\n+ static_assert (!std::meta::is_protected (^^C));\n+ static_assert (!std::meta::is_protected (^^D));\n+\n+\n+ // private class members\n+ static_assert (!std::meta::is_protected (^^private_field));\n+ static_assert (!std::meta::is_protected (^^private_static_field));\n+\n+ static_assert (!std::meta::is_protected (^^private_function));\n+ static_assert (!std::meta::is_protected (^^private_static_function));\n+ static_assert (!std::meta::is_protected (^^private_virtual_function));\n+\n+ static_assert (!std::meta::is_protected (^^private_template_function));\n+ static_assert (!std::meta::is_protected (^^private_template_function));\n+\n+ static_assert (!std::meta::is_protected (^^private_static_template_function));\n+ static_assert (!std::meta::is_protected (^^private_static_template_function));\n+\n+ static_assert (!std::meta::is_protected (^^private_type_alias)); \n+ static_assert (!std::meta::is_protected (^^PrivateCls)); \n+ static_assert (!std::meta::is_protected (^^PrivateUnion));\n+\n+ static_assert (!std::meta::is_protected (^^PrivateEnum));\n+ static_assert (!std::meta::is_protected (^^PrivateEnumClass)); \n+\n+ static_assert (!std::meta::is_protected (^^K));\n+ static_assert (!std::meta::is_protected (^^L));\n+ }\n+\n+ void test_is_private()\n+ {\n+ // positive test cases: private class members\n+ static_assert (std::meta::is_private (^^private_field));\n+ static_assert (std::meta::is_private (^^private_static_field));\n+\n+ static_assert (std::meta::is_private (^^private_function));\n+ static_assert (std::meta::is_private (^^private_static_function));\n+ static_assert (std::meta::is_private (^^private_virtual_function));\n+\n+ static_assert (std::meta::is_private (^^private_template_function));\n+ static_assert (std::meta::is_private (^^private_template_function));\n+\n+ static_assert (std::meta::is_private (^^private_static_template_function));\n+ static_assert (std::meta::is_private (^^private_static_template_function));\n+\n+ static_assert (std::meta::is_private (^^private_type_alias)); \n+ static_assert (std::meta::is_private (^^PrivateCls)); \n+ static_assert (std::meta::is_private (^^PrivateUnion));\n+\n+ static_assert (std::meta::is_private (^^PrivateEnum));\n+ static_assert (std::meta::is_private (^^PrivateEnumClass)); \n+\n+ static_assert (std::meta::is_private (^^K));\n+ static_assert (std::meta::is_private (^^L));\n+\n+ // negative cases:\n+ static_assert (!std::meta::is_private (^^A));\n+\n+ // scoped enum values are not class members\n+ static_assert (!std::meta::is_private (^^PublicEnumClass::E));\n+ static_assert (!std::meta::is_private (^^PublicEnumClass::F));\n+\n+ static_assert (!std::meta::is_private (^^ProtectedEnumClass::I));\n+ static_assert (!std::meta::is_private (^^ProtectedEnumClass::J));\n+\n+ static_assert (!std::meta::is_private (^^PrivateEnumClass::M));\n+ static_assert (!std::meta::is_private (^^PrivateEnumClass::N));\n+\n+ // public class members\n+ static_assert (!std::meta::is_private (^^public_field));\n+ static_assert (!std::meta::is_private (^^public_static_field));\n+\n+ static_assert (!std::meta::is_private (^^public_function));\n+ static_assert (!std::meta::is_private (^^public_static_function));\n+ static_assert (!std::meta::is_private (^^public_virtual_function));\n+\n+ static_assert (!std::meta::is_private (^^public_template_function));\n+ static_assert (!std::meta::is_private (^^public_template_function));\n+\n+ static_assert (!std::meta::is_private (^^public_static_template_function));\n+ static_assert (!std::meta::is_private (^^public_static_template_function));\n+\n+ static_assert (!std::meta::is_private (^^public_type_alias)); \n+ static_assert (!std::meta::is_private (^^PublicCls)); \n+ static_assert (!std::meta::is_private (^^PublicUnion));\n+\n+ static_assert (!std::meta::is_private (^^PublicEnum));\n+ static_assert (!std::meta::is_private (^^PublicEnumClass)); \n+\n+ static_assert (!std::meta::is_private (^^B));\n+ static_assert (!std::meta::is_private (^^C));\n+ static_assert (!std::meta::is_private (^^D));\n+\n+ // protected class members\n+ static_assert (!std::meta::is_private (^^~A));\n+\n+ static_assert (!std::meta::is_private (^^protected_field));\n+ static_assert (!std::meta::is_private (^^protected_static_field));\n+\n+ static_assert (!std::meta::is_private (^^protected_function));\n+ static_assert (!std::meta::is_private (^^protected_static_function));\n+ static_assert (!std::meta::is_private (^^protected_virtual_function));\n+\n+ static_assert (!std::meta::is_private (^^protected_template_function));\n+ static_assert (!std::meta::is_private (^^protected_template_function));\n+\n+ static_assert (!std::meta::is_private (^^protected_static_template_function));\n+ static_assert (!std::meta::is_private (^^protected_static_template_function));\n+\n+ static_assert (!std::meta::is_private (^^protected_type_alias)); \n+ static_assert (!std::meta::is_private (^^ProtectedCls)); \n+ static_assert (!std::meta::is_private (^^ProtectedUnion));\n+\n+ static_assert (!std::meta::is_private (^^ProtectedEnum));\n+ static_assert (!std::meta::is_private (^^ProtectedEnumClass)); \n+\n+ static_assert (!std::meta::is_private (^^G));\n+ static_assert (!std::meta::is_private (^^H));\n+ }\n+};\n+\ndiff --git a/gcc/testsuite/g++.dg/reflect/member-visibility2.C b/gcc/testsuite/g++.dg/reflect/member-visibility2.C\nnew file mode 100644\nindex 00000000000..66dc46666ae\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member-visibility2.C\n@@ -0,0 +1,61 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Tests std::meta::is_public, std::meta::is_private, std::meta::is_protected\n+#include \n+\n+// Test bit-fields\n+struct S {\n+ unsigned char b1 : 3;\n+protected:\n+ unsigned char : 2;\n+private:\n+ unsigned char b2 : 6;\n+};\n+\n+constexpr auto ctx = std::meta::access_context::unchecked();\n+static_assert (std::meta::members_of (^^S, ctx).size() > 3);\n+\n+static_assert (std::meta::is_bit_field (std::meta::members_of (^^S, ctx)[0]));\n+static_assert (std::meta::has_identifier (std::meta::members_of (^^S, ctx)[0]));\n+static_assert (std::meta::is_public (std::meta::members_of (^^S, ctx)[0]));\n+\n+static_assert (std::meta::is_bit_field (std::meta::members_of (^^S, ctx)[1]));\n+static_assert (!std::meta::has_identifier (std::meta::members_of (^^S, ctx)[1]));\n+static_assert (std::meta::is_protected (std::meta::members_of (^^S, ctx)[1]));\n+\n+static_assert (std::meta::is_bit_field (std::meta::members_of (^^S, ctx)[2]));\n+static_assert (std::meta::has_identifier (std::meta::members_of (^^S, ctx)[2]));\n+static_assert (std::meta::is_private (std::meta::members_of (^^S, ctx)[2]));\n+\n+// Test inheritance and change of access modifier\n+class A {\n+protected:\n+ int protected_member;\n+\n+ void protected_function();\n+\n+ virtual void protected_virtual_function();\n+\n+ void test() {\n+ static_assert (std::meta::is_protected (^^protected_member));\n+ static_assert (std::meta::is_protected (^^protected_function));\n+ static_assert (std::meta::is_protected (^^protected_virtual_function));\n+ }\n+};\n+\n+\n+class B : public A {\n+private:\n+ void protected_virtual_function() override;\n+\n+ void test() {\n+ static_assert (std::meta::is_protected (^^B::protected_member));\n+ static_assert (std::meta::is_protected (^^B::protected_function));\n+\n+ static_assert (std::meta::is_protected (^^A::protected_virtual_function));\n+ static_assert (std::meta::is_private (^^B::protected_virtual_function));\n+ }\n+};\n+\n+// TODO: add more tests for inheritance and change of access modification\n+// TODO: add more tests for base access during multilevel inheritance\ndiff --git a/gcc/testsuite/g++.dg/reflect/member1.C b/gcc/testsuite/g++.dg/reflect/member1.C\nnew file mode 100644\nindex 00000000000..e9d9a64d0eb\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member1.C\n@@ -0,0 +1,99 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test various forms of member access.\n+\n+struct A {\n+ int val;\n+};\n+\n+struct B {\n+ A a;\n+};\n+\n+struct S {\n+ int x;\n+ static constexpr int sx = 42;\n+ void fn (int) { }\n+ template\n+ void tfn (T) { }\n+ template\n+ struct N { };\n+ template\n+ static T var;\n+ B b;\n+};\n+\n+template\n+struct C {\n+ int x;\n+ static constexpr int sx = 42;\n+ void fn (int) { }\n+ template\n+ void tfn (U) { }\n+ template\n+ struct N { };\n+ template\n+ static U var;\n+ B b;\n+};\n+\n+void\n+f ()\n+{\n+ S s;\n+ S *sp = &s;\n+ C c;\n+ C *cp = &c;\n+\n+ s.[: ^^S::x :] = 1;\n+ sp->[: ^^S::x :] = 2;\n+ s.[: ^^S::fn :](42);\n+ sp->[: ^^S::fn :](42);\n+ int a = s.[: ^^S::sx :];\n+ a += sp->[: ^^S::sx :];\n+ s.template [: ^^S::tfn :](42);\n+ sp->template [: ^^S::tfn :](42);\n+ s.template [: ^^S::tfn :](42);\n+ sp->template [: ^^S::tfn :](42);\n+ s.[: ^^S::var :] = 1; // { dg-error \"reflection .var. not usable in a splice expression with template arguments\" }\n+ s.template [: ^^S::var :] = 1;\n+ sp->[: ^^S::var :] = 1; // { dg-error \"reflection .var. not usable in a splice expression with template arguments\" }\n+ sp->template [: ^^S::var :] = 1;\n+ s.[: ^^S::b :].[: ^^B::a :].val;\n+ sp->[: ^^S::b :].[: ^^B::a :].val;\n+ [: ^^s :].[: ^^S::b :].[: ^^B::a :].val;\n+ [: ^^sp :]->[: ^^S::b :].[: ^^B::a :].val;\n+\n+ c.[: ^^C::x :] = 1;\n+ cp->[: ^^C::x :] = 1;\n+ c.[: ^^C::fn :](42);\n+ cp->[: ^^C::fn :](42);\n+ a += c.[: ^^C::sx :];\n+ a += cp->[: ^^C::sx :];\n+ c.template [: ^^C::tfn :](42);\n+ cp->template [: ^^C::tfn :](42);\n+ c.template [: ^^C::tfn :](42);\n+ cp->template [: ^^C::tfn :](42);\n+ c.[: ^^C::var :] = 1; // { dg-error \"reflection .var. not usable in a splice expression with template arguments\" }\n+ c.template [: ^^C::var :] = 1;\n+ cp->[: ^^C::var :] = 1; // { dg-error \"reflection .var. not usable in a splice expression with template arguments\" }\n+ cp->template [: ^^C::var :] = 1;\n+ c.[: ^^C::b :].[: ^^B::a :].val;\n+ cp->[: ^^C::b :].[: ^^B::a :].val;\n+ [: ^^c :].[: ^^C::b :].[: ^^B::a :].val;\n+ [: ^^cp :]->[: ^^C::b :].[: ^^B::a :].val;\n+\n+ [: ^^S :]::template N n1;\n+ [: ^^C :]::template N n2;\n+ [: ^^C :]::template N n3; // { dg-error \"missing .template.|expected\" }\n+ typename [: ^^C :]::template N n4;\n+\n+ s->[: ^^S::x :] = 2; // { dg-error \"non-pointer type\" }\n+ sp.[: ^^S::x :] = 2; // { dg-error \"which is of pointer type\" }\n+ c.[: ^^C::x :] = 1; // { dg-error \"is not a base of\" }\n+ cp->[: ^^C::x :] = 1; // { dg-error \"is not a base of\" }\n+ s.template [: ^^S::N :].t; // { dg-error \"reflection .S::N. not usable in a template splice\" }\n+ S::template [: ^^S::N :] e1; // { dg-error \"expected unqualified-id\" }\n+ C::template [: ^^S::N :] e2; // { dg-error \"expected unqualified-id\" }\n+ s.template [: ^^S::var :] = 1; // { dg-error \"reflection .S::var. not usable in a template splice\" }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member10.C b/gcc/testsuite/g++.dg/reflect/member10.C\nnew file mode 100644\nindex 00000000000..649bab57238\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member10.C\n@@ -0,0 +1,42 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^int);\n+\n+/* ??? clang rejects all of these; I'm not entirely sure why.\n+ [expr.prim.id.general]/2 says that the implicit transformation\n+ whereby an id-expression denoting a NSDM becomes a class member\n+ access doesn't apply to a splice-expression. OK, so we reject\n+ [:^^k:], but [:^^S:]::k doesn't seem to be the same case? */\n+\n+// Non-dependent case\n+struct S {\n+ int k;\n+\n+ void fn2() { }\n+\n+ void fn() {\n+ (void) [:^^k:]; // { dg-error \"cannot implicitly reference\" }\n+ (void) [:^^S:]::k;\n+ [:^^fn:](); // { dg-error \"cannot implicitly reference\" }\n+ [:^^S:]::fn2();\n+ }\n+};\n+\n+// Dependent case\n+struct D {\n+ int k;\n+\n+ void fn2() { }\n+\n+ template \n+ void fn() {\n+ (void) [:^^T:]::k;\n+ [:^^T:]::fn2();\n+ }\n+};\n+\n+void runner() {\n+ D f = {4};\n+ f.fn();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member11.C b/gcc/testsuite/g++.dg/reflect/member11.C\nnew file mode 100644\nindex 00000000000..29cfa819d4d\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member11.C\n@@ -0,0 +1,19 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Cf. \n+\n+class Base {\n+private:\n+ int m;\n+public:\n+ static constexpr auto rm = ^^m;\n+};\n+class Derived { static constexpr auto mp = &[:Base::rm:]; };\n+\n+class Base2 {\n+protected:\n+ int m;\n+public:\n+ static constexpr auto rm = ^^m;\n+};\n+class Derived2 { static constexpr auto mp = &[:Base2::rm:]; };\ndiff --git a/gcc/testsuite/g++.dg/reflect/member12.C b/gcc/testsuite/g++.dg/reflect/member12.C\nnew file mode 100644\nindex 00000000000..bfee8a4f6b8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member12.C\n@@ -0,0 +1,37 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct S {\n+ int a;\n+ static int b;\n+ void foo () {}\n+ static void bar () {}\n+};\n+int S::b = 42;\n+\n+void\n+baz ()\n+{\n+ S s {};\n+ s.[:^^S::a:]++;\n+ s.[:^^S::b:]++;\n+ s.[:^^S::foo:] ();\n+ s.[:^^S::bar:] ();\n+}\n+\n+template \n+void\n+qux ()\n+{\n+ S s {};\n+ s.[:(T) ^^S::a:]++;\n+ s.[:(T) ^^S::b:]++;\n+ s.[:(T) ^^S::foo:] ();\n+ s.[:(T) ^^S::bar:] ();\n+}\n+\n+void\n+corge ()\n+{\n+ qux ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member13.C b/gcc/testsuite/g++.dg/reflect/member13.C\nnew file mode 100644\nindex 00000000000..5a1a05bba4b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member13.C\n@@ -0,0 +1,46 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct S {\n+ int a;\n+ static int b;\n+ void foo () {}\n+ static void bar () {}\n+ template \n+ void baz () {}\n+ template \n+ static void qux () {}\n+};\n+int S::b = 42;\n+\n+struct V {\n+ int a;\n+ static int b;\n+ void foo () {}\n+ static void bar () {}\n+ template \n+ void baz () {}\n+ template \n+ static void qux () {}\n+};\n+int V::b = 42;\n+static constexpr auto va = ^^V::a;\n+static constexpr auto vb = ^^V::b;\n+static constexpr auto vfoo = ^^V::foo;\n+static constexpr auto vbar = ^^V::bar;\n+\n+void\n+corge ()\n+{\n+ S s {};\n+ s.[:^^V::a:]++;\t\t\t// { dg-error \".V. is not a base of .S.\" }\n+ s.[:^^V::b:]++;\t\t\t// { dg-error \".V. is not a base of .S.\" }\n+ s.[:^^V::foo:] ();\t\t\t// { dg-error \".V::foo\\\\\\(\\\\\\). is not a member of .S.\" }\n+ s.[:^^V::bar:] ();\t\t\t// { dg-error \".V::bar\\\\\\(\\\\\\). is not a member of .S.\" }\n+ s.[:va:]++;\t\t\t\t// { dg-error \".V. is not a base of .S.\" }\n+ s.[:vb:]++;\t\t\t\t// { dg-error \".V. is not a base of .S.\" }\n+ s.[:vfoo:] ();\t\t\t// { dg-error \".V::foo\\\\\\(\\\\\\). is not a member of .S.\" }\n+ s.[:vbar:] ();\t\t\t// { dg-error \".V::bar\\\\\\(\\\\\\). is not a member of .S.\" }\n+ s.template [:^^V::baz:] <42> ();\t// { dg-error \"is not a member of .S.\" }\n+ s.template [:^^V::qux:] <42> ();\t// { dg-error \"is not a member of .S.\" }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member14.C b/gcc/testsuite/g++.dg/reflect/member14.C\nnew file mode 100644\nindex 00000000000..18f778ef25f\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member14.C\n@@ -0,0 +1,27 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+#include \n+\n+class A {\n+ int a = 0;\n+ consteval int foo () const { return 5; }\n+public:\n+ int b = 0;\n+ consteval A () = default;\n+ consteval A (int x, int y) : a (x), b (y) {}\n+};\n+\n+constexpr auto ctx = std::meta::access_context::unchecked ();\n+static_assert (identifier_of (members_of (^^A, ctx)[0]) == \"a\");\n+static_assert (identifier_of (members_of (^^A, ctx)[1]) == \"foo\");\n+static_assert (identifier_of (members_of(^^A, ctx)[2]) == \"b\");\n+\n+constexpr A c, d = { 42, 6 };\n+// TODO, these don't work yet:\n+//static_assert (c.[: members_of (^^A, ctx)[0] :] == 0);\n+//static_assert (c.[: members_of (^^A, ctx)[1] :] () == 5);\n+static_assert (c.[: members_of (^^A, ctx)[2] :] == 0);\n+//static_assert (d.[: members_of (^^A, ctx)[0] :] == 42);\n+//static_assert (d.[: members_of (^^A, ctx)[1] :] () == 5);\n+static_assert (d.[: members_of (^^A, ctx)[2] :] == 6);\ndiff --git a/gcc/testsuite/g++.dg/reflect/member15.C b/gcc/testsuite/g++.dg/reflect/member15.C\nnew file mode 100644\nindex 00000000000..36f12d8b539\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member15.C\n@@ -0,0 +1,177 @@\n+// { dg-do run { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+#include \n+\n+using namespace std::meta;\n+\n+struct S { int _; long _; short _; };\n+struct T { int _; int _; int _; };\n+struct U { enum E { F, G, H, I } j, k; };\n+struct V : S, T { int _; int _; };\n+\n+constexpr access_context uctx = access_context::unchecked ();\n+\n+void\n+foo ()\n+{\n+ S s = { 1, 2, 3 };\n+ s.[:members_of (^^S, uctx)[1]:] += 10;\n+ s.[:members_of (^^S, uctx)[0]:] += 20;\n+ s.[:members_of (^^S, uctx)[2]:] += 30;\n+ auto [ sa, sb, sc ] = s;\n+ if (sa != 21 || sb != 12 || sc != 33)\n+ __builtin_abort ();\n+ T t = { 4, 5, 6 };\n+ t.[:members_of (^^T, uctx)[1]:] += 40;\n+ t.[:members_of (^^T, uctx)[2]:] += 50;\n+ t.[:members_of (^^T, uctx)[0]:] += 60;\n+ auto [ ta, tb, tc ] = t;\n+ if (ta != 64 || tb != 45 || tc != 56)\n+ __builtin_abort ();\n+ U u = { U::F, U::I };\n+ u.[:nonstatic_data_members_of (^^U, uctx)[0]:] = u.[:^^U::E::G:];\n+ u.[:nonstatic_data_members_of (^^U, uctx)[1]:] = u.[:^^U::H:];\n+ if (u.j != U::G || u.k != U::E::H)\n+ __builtin_abort ();\n+ V v = {};\n+ v.[:members_of (^^S, uctx)[1]:] = 1;\n+ v.[:members_of (^^T, uctx)[2]:] = 2;\n+ v.[:members_of (^^V, uctx)[0]:] = 3;\n+}\n+\n+template \n+void\n+bar ()\n+{\n+ S s = { 1, 2, 3 };\n+ s.[:members_of (^^S, uctx)[1]:] += 10;\n+ s.[:members_of (^^S, uctx)[0]:] += 20;\n+ s.[:members_of (^^S, uctx)[2]:] += 30;\n+ auto [ sa, sb, sc ] = s;\n+ if (sa != 21 || sb != 12 || sc != 33)\n+ __builtin_abort ();\n+ T t = { 4, 5, 6 };\n+ t.[:members_of (^^T, uctx)[1]:] += 40;\n+ t.[:members_of (^^T, uctx)[2]:] += 50;\n+ t.[:members_of (^^T, uctx)[0]:] += 60;\n+ auto [ ta, tb, tc ] = t;\n+ if (ta != 64 || tb != 45 || tc != 56)\n+ __builtin_abort ();\n+ U u = { U::F, U::I };\n+ u.[:nonstatic_data_members_of (^^U, uctx)[0]:] = u.[:^^U::E::G:];\n+ u.[:nonstatic_data_members_of (^^U, uctx)[1]:] = u.[:^^U::H:];\n+ if (u.j != U::G || u.k != U::E::H)\n+ __builtin_abort ();\n+ V v = {};\n+ v.[:members_of (^^S, uctx)[1]:] = 1;\n+ v.[:members_of (^^T, uctx)[2]:] = 2;\n+ v.[:members_of (^^V, uctx)[0]:] = 3;\n+}\n+\n+template \n+void\n+baz ()\n+{\n+ A s = { 1, 2, 3 };\n+ s.[:members_of (^^S, uctx)[1]:] += 10;\n+ s.[:members_of (^^S, uctx)[0]:] += 20;\n+ s.[:members_of (^^S, uctx)[2]:] += 30;\n+ auto [ sa, sb, sc ] = s;\n+ if (sa != 21 || sb != 12 || sc != 33)\n+ __builtin_abort ();\n+ B t = { 4, 5, 6 };\n+ t.[:members_of (^^T, uctx)[1]:] += 40;\n+ t.[:members_of (^^T, uctx)[2]:] += 50;\n+ t.[:members_of (^^T, uctx)[0]:] += 60;\n+ auto [ ta, tb, tc ] = t;\n+ if (ta != 64 || tb != 45 || tc != 56)\n+ __builtin_abort ();\n+ C u = { U::F, U::I };\n+ u.[:nonstatic_data_members_of (^^U, uctx)[0]:] = u.[:^^U::E::G:];\n+ u.[:nonstatic_data_members_of (^^U, uctx)[1]:] = u.[:^^U::H:];\n+ if (u.j != U::G || u.k != U::E::H)\n+ __builtin_abort ();\n+ D v = {};\n+ v.[:members_of (^^S, uctx)[1]:] = 1;\n+ v.[:members_of (^^T, uctx)[2]:] = 2;\n+ v.[:members_of (^^V, uctx)[0]:] = 3;\n+}\n+\n+template \n+void\n+qux ()\n+{\n+ S s = { 1, 2, 3 };\n+ s.[:members_of (^^A, uctx)[1]:] += 10;\n+ s.[:members_of (^^A, uctx)[0]:] += 20;\n+ s.[:members_of (^^A, uctx)[2]:] += 30;\n+ auto [ sa, sb, sc ] = s;\n+ if (sa != 21 || sb != 12 || sc != 33)\n+ __builtin_abort ();\n+ T t = { 4, 5, 6 };\n+ t.[:members_of (^^B, uctx)[1]:] += 40;\n+ t.[:members_of (^^B, uctx)[2]:] += 50;\n+ t.[:members_of (^^B, uctx)[0]:] += 60;\n+ auto [ ta, tb, tc ] = t;\n+ if (ta != 64 || tb != 45 || tc != 56)\n+ __builtin_abort ();\n+ U u = { U::F, U::I };\n+#if 0\n+ // TODO: This doesn't work yet:\n+ u.[:nonstatic_data_members_of (^^C, uctx)[0]:] = u.[:^^C::E::G:];\n+#else\n+ u.[:nonstatic_data_members_of (^^C, uctx)[0]:] = u.[:^^C::G:];\n+#endif\n+ u.[:nonstatic_data_members_of (^^C, uctx)[1]:] = u.[:^^C::H:];\n+ if (u.j != U::G || u.k != U::E::H)\n+ __builtin_abort ();\n+ V v = {};\n+ v.[:members_of (^^A, uctx)[1]:] = 1;\n+ v.[:members_of (^^B, uctx)[2]:] = 2;\n+ v.[:members_of (^^D, uctx)[0]:] = 3;\n+}\n+\n+template \n+void\n+fred ()\n+{\n+ A s = { 1, 2, 3 };\n+ s.[:members_of (^^A, uctx)[1]:] += 10;\n+ s.[:members_of (^^A, uctx)[0]:] += 20;\n+ s.[:members_of (^^A, uctx)[2]:] += 30;\n+ auto [ sa, sb, sc ] = s;\n+ if (sa != 21 || sb != 12 || sc != 33)\n+ __builtin_abort ();\n+ B t = { 4, 5, 6 };\n+ t.[:members_of (^^B, uctx)[1]:] += 40;\n+ t.[:members_of (^^B, uctx)[2]:] += 50;\n+ t.[:members_of (^^B, uctx)[0]:] += 60;\n+ auto [ ta, tb, tc ] = t;\n+ if (ta != 64 || tb != 45 || tc != 56)\n+ __builtin_abort ();\n+ C u = { U::F, U::I };\n+#if 0\n+ // TODO: This doesn't work yet:\n+ u.[:nonstatic_data_members_of (^^C, uctx)[0]:] = u.[:^^C::E::G:];\n+#else\n+ u.[:nonstatic_data_members_of (^^C, uctx)[0]:] = u.[:^^C::G:];\n+#endif\n+ u.[:nonstatic_data_members_of (^^C, uctx)[1]:] = u.[:^^C::H:];\n+ if (u.j != U::G || u.k != U::E::H)\n+ __builtin_abort ();\n+ D v = {};\n+ v.[:members_of (^^A, uctx)[1]:] = 1;\n+ v.[:members_of (^^B, uctx)[2]:] = 2;\n+ v.[:members_of (^^D, uctx)[0]:] = 3;\n+}\n+\n+int\n+main ()\n+{\n+ foo ();\n+ bar <42> ();\n+ baz ();\n+ qux ();\n+ fred ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member16.C b/gcc/testsuite/g++.dg/reflect/member16.C\nnew file mode 100644\nindex 00000000000..2679cdc6714\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member16.C\n@@ -0,0 +1,86 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct A { int a; };\n+struct B : public A { int b; };\n+struct C : public B { int c; };\n+struct D : public A, B, C { int d; };\t// { dg-warning \"direct base 'A' inaccessible in 'D' due to ambiguity\" }\n+\t\t\t\t\t// { dg-warning \"direct base 'B' inaccessible in 'D' due to ambiguity\" \"\" { target *-*-* } .-1 }\n+struct E { int _; };\n+struct F : public E { int _; };\n+struct G : public F { int _; };\n+struct H : public E, F, G { int _; };\t// { dg-warning \"direct base 'E' inaccessible in 'H' due to ambiguity\" }\n+\t\t\t\t\t// { dg-warning \"direct base 'F' inaccessible in 'H' due to ambiguity\" \"\" { target *-*-* } .-1 }\n+struct I { int i; };\n+struct J { int _; };\n+\n+void\n+foo (C &c, D &d, G &g, H &h)\n+{\n+ c.[: ^^A::a :] = 1;\n+ c.[: ^^B::b :] = 2;\n+ c.[: ^^C::c :] = 3;\n+ d.[: ^^A::a :] = 4;\t\t\t// { dg-error \"'A' is an ambiguous base of 'D'\" }\n+ d.[: ^^B::b :] = 5;\t\t\t// { dg-error \"'B' is an ambiguous base of 'D'\" }\n+ d.[: ^^C::c :] = 6;\n+ d.[: ^^D::d :] = 7;\n+ d.[: ^^I::i :] = 8;\t\t\t// { dg-error \"'I' is not a base of 'D'\" }\n+ g.[: ^^E::_ :] = 1;\n+ g.[: ^^F::_ :] = 2;\n+ g.[: ^^G::_ :] = 3;\n+ h.[: ^^E::_ :] = 4;\t\t\t// { dg-error \"'E' is an ambiguous base of 'H'\" }\n+ h.[: ^^F::_ :] = 5;\t\t\t// { dg-error \"'F' is an ambiguous base of 'H'\" }\n+ h.[: ^^G::_ :] = 6;\n+ h.[: ^^H::_ :] = 7;\n+ h.[: ^^J::_ :] = 8;\t\t\t// { dg-error \"'J' is not a base of 'H'\" }\n+}\n+\n+template \n+void\n+bar (S &c, T &d, U &g, V &h)\n+{\n+ c.[: ^^A::a :] = 1;\n+ c.[: ^^B::b :] = 2;\n+ c.[: ^^C::c :] = 3;\n+ d.[: ^^A::a :] = 4;\t\t\t// { dg-error \"'A' is an ambiguous base of 'D'\" }\n+ d.[: ^^B::b :] = 5;\t\t\t// { dg-error \"'B' is an ambiguous base of 'D'\" }\n+ d.[: ^^C::c :] = 6;\n+ d.[: ^^D::d :] = 7;\n+ d.[: ^^I::i :] = 8;\t\t\t// { dg-error \"invalid use of non-static data member 'I::i'\" }\n+ g.[: ^^E::_ :] = 1;\n+ g.[: ^^F::_ :] = 2;\n+ g.[: ^^G::_ :] = 3;\n+ h.[: ^^E::_ :] = 4;\t\t\t// { dg-error \"'E' is an ambiguous base of 'H'\" }\n+ h.[: ^^F::_ :] = 5;\t\t\t// { dg-error \"'F' is an ambiguous base of 'H'\" }\n+ h.[: ^^G::_ :] = 6;\n+ h.[: ^^H::_ :] = 7;\n+ h.[: ^^J::_ :] = 8;\t\t\t// { dg-error \"invalid use of non-static data member 'J::_'\" }\n+}\n+\n+void\n+baz (C &c, D &d, G &g, H &h)\n+{\n+ bar (c, d, g, h);\n+}\n+\n+template \n+void\n+qux (C &c, D &d, G &g, H &h)\n+{\n+ c.[: ^^A::a :] = 1;\n+ c.[: ^^B::b :] = 2;\n+ c.[: ^^C::c :] = 3;\n+ d.[: ^^A::a :] = 4;\t\t\t// { dg-error \"'A' is an ambiguous base of 'D'\" }\n+ d.[: ^^B::b :] = 5;\t\t\t// { dg-error \"'B' is an ambiguous base of 'D'\" }\n+ d.[: ^^C::c :] = 6;\n+ d.[: ^^D::d :] = 7;\n+ d.[: ^^I::i :] = 8;\t\t\t// { dg-error \"'I' is not a base of 'D'\" }\n+ g.[: ^^E::_ :] = 1;\n+ g.[: ^^F::_ :] = 2;\n+ g.[: ^^G::_ :] = 3;\n+ h.[: ^^E::_ :] = 4;\t\t\t// { dg-error \"'E' is an ambiguous base of 'H'\" }\n+ h.[: ^^F::_ :] = 5;\t\t\t// { dg-error \"'F' is an ambiguous base of 'H'\" }\n+ h.[: ^^G::_ :] = 6;\n+ h.[: ^^H::_ :] = 7;\n+ h.[: ^^J::_ :] = 8;\t\t\t// { dg-error \"'J' is not a base of 'H'\" }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member17.C b/gcc/testsuite/g++.dg/reflect/member17.C\nnew file mode 100644\nindex 00000000000..f5850c9e27d\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member17.C\n@@ -0,0 +1,402 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+#include \n+\n+using namespace std::meta;\n+\n+struct S {\n+ constexpr int foo (int x) const { return 41 + x + s; }\n+ constexpr int foo (long x) const { return 42 + x + s; }\n+ constexpr int foo (long long x) const { return 43 + x + s; }\n+ static constexpr int bar (int x) { return 72 + x; } \n+ static constexpr int bar (long x) { return 73 + x; } \n+ static constexpr int bar (long long x) { return 74 + x; } \n+ constexpr S (int x) : s (x) {}\n+ int s;\n+};\n+struct T : public S {\n+ constexpr int foo (int x) const { return 51 + x + s; }\n+ constexpr int foo (long x) const { return 52 + x + s; }\n+ constexpr int foo (long long x) const { return 53 + x + s; }\n+ static constexpr int bar (int x) { return 82 + x; } \n+ static constexpr int bar (long x) { return 83 + x; } \n+ static constexpr int bar (long long x) { return 84 + x; } \n+ constexpr T (int x) : S (x) {}\n+};\n+\n+constexpr access_context uctx = access_context::unchecked ();\n+\n+constexpr S s = 1;\n+static_assert (s.foo (0) == 42);\n+static_assert (s.foo (0L) == 43);\n+static_assert (s.foo (0LL) == 44);\n+static_assert (s.[:members_of (^^S, uctx)[0]:] (10) == 52);\n+static_assert (s.[:members_of (^^S, uctx)[0]:] (20L) == 62);\n+static_assert (s.[:members_of (^^S, uctx)[0]:] (30LL) == 72);\n+static_assert (s.[:members_of (^^S, uctx)[1]:] (10) == 53);\n+static_assert (s.[:members_of (^^S, uctx)[1]:] (20L) == 63);\n+static_assert (s.[:members_of (^^S, uctx)[1]:] (30LL) == 73);\n+static_assert (s.[:members_of (^^S, uctx)[2]:] (10) == 54);\n+static_assert (s.[:members_of (^^S, uctx)[2]:] (20L) == 64);\n+static_assert (s.[:members_of (^^S, uctx)[2]:] (30LL) == 74);\n+static_assert (s.bar (0) == 72);\n+static_assert (s.bar (0L) == 73);\n+static_assert (s.bar (0LL) == 74);\n+static_assert (s.[:members_of (^^S, uctx)[3]:] (10) == 82);\n+static_assert (s.[:members_of (^^S, uctx)[3]:] (20L) == 92);\n+static_assert (s.[:members_of (^^S, uctx)[3]:] (30LL) == 102);\n+static_assert (s.[:members_of (^^S, uctx)[4]:] (10) == 83);\n+static_assert (s.[:members_of (^^S, uctx)[4]:] (20L) == 93);\n+static_assert (s.[:members_of (^^S, uctx)[4]:] (30LL) == 103);\n+static_assert (s.[:members_of (^^S, uctx)[5]:] (10) == 84);\n+static_assert (s.[:members_of (^^S, uctx)[5]:] (20L) == 94);\n+static_assert (s.[:members_of (^^S, uctx)[5]:] (30LL) == 104);\n+constexpr T t = 2;\n+static_assert (t.foo (0) == 53);\n+static_assert (t.foo (0L) == 54);\n+static_assert (t.foo (0LL) == 55);\n+static_assert (t.[:members_of (^^S, uctx)[0]:] (10) == 53);\n+static_assert (t.[:members_of (^^S, uctx)[0]:] (20L) == 63);\n+static_assert (t.[:members_of (^^S, uctx)[0]:] (30LL) == 73);\n+static_assert (t.[:members_of (^^S, uctx)[1]:] (10) == 54);\n+static_assert (t.[:members_of (^^S, uctx)[1]:] (20L) == 64);\n+static_assert (t.[:members_of (^^S, uctx)[1]:] (30LL) == 74);\n+static_assert (t.[:members_of (^^S, uctx)[2]:] (10) == 55);\n+static_assert (t.[:members_of (^^S, uctx)[2]:] (20L) == 65);\n+static_assert (t.[:members_of (^^S, uctx)[2]:] (30LL) == 75);\n+static_assert (t.[:members_of (^^T, uctx)[0]:] (10) == 63);\n+static_assert (t.[:members_of (^^T, uctx)[0]:] (20L) == 73);\n+static_assert (t.[:members_of (^^T, uctx)[0]:] (30LL) == 83);\n+static_assert (t.[:members_of (^^T, uctx)[1]:] (10) == 64);\n+static_assert (t.[:members_of (^^T, uctx)[1]:] (20L) == 74);\n+static_assert (t.[:members_of (^^T, uctx)[1]:] (30LL) == 84);\n+static_assert (t.[:members_of (^^T, uctx)[2]:] (10) == 65);\n+static_assert (t.[:members_of (^^T, uctx)[2]:] (20L) == 75);\n+static_assert (t.[:members_of (^^T, uctx)[2]:] (30LL) == 85);\n+static_assert (t.bar (0) == 82);\n+static_assert (t.bar (0L) == 83);\n+static_assert (t.bar (0LL) == 84);\n+static_assert (t.[:members_of (^^S, uctx)[3]:] (10) == 82);\n+static_assert (t.[:members_of (^^S, uctx)[3]:] (20L) == 92);\n+static_assert (t.[:members_of (^^S, uctx)[3]:] (30LL) == 102);\n+static_assert (t.[:members_of (^^S, uctx)[4]:] (10) == 83);\n+static_assert (t.[:members_of (^^S, uctx)[4]:] (20L) == 93);\n+static_assert (t.[:members_of (^^S, uctx)[4]:] (30LL) == 103);\n+static_assert (t.[:members_of (^^S, uctx)[5]:] (10) == 84);\n+static_assert (t.[:members_of (^^S, uctx)[5]:] (20L) == 94);\n+static_assert (t.[:members_of (^^S, uctx)[5]:] (30LL) == 104);\n+static_assert (t.[:members_of (^^T, uctx)[3]:] (10) == 92);\n+static_assert (t.[:members_of (^^T, uctx)[3]:] (20L) == 102);\n+static_assert (t.[:members_of (^^T, uctx)[3]:] (30LL) == 112);\n+static_assert (t.[:members_of (^^T, uctx)[4]:] (10) == 93);\n+static_assert (t.[:members_of (^^T, uctx)[4]:] (20L) == 103);\n+static_assert (t.[:members_of (^^T, uctx)[4]:] (30LL) == 113);\n+static_assert (t.[:members_of (^^T, uctx)[5]:] (10) == 94);\n+static_assert (t.[:members_of (^^T, uctx)[5]:] (20L) == 104);\n+static_assert (t.[:members_of (^^T, uctx)[5]:] (30LL) == 114);\n+\n+template \n+void\n+foo ()\n+{\n+ constexpr S s = 1;\n+ static_assert (s.foo (0) == 42);\n+ static_assert (s.foo (0L) == 43);\n+ static_assert (s.foo (0LL) == 44);\n+ static_assert (s.[:members_of (^^S, uctx)[0]:] (10) == 52);\n+ static_assert (s.[:members_of (^^S, uctx)[0]:] (20L) == 62);\n+ static_assert (s.[:members_of (^^S, uctx)[0]:] (30LL) == 72);\n+ static_assert (s.[:members_of (^^S, uctx)[1]:] (10) == 53);\n+ static_assert (s.[:members_of (^^S, uctx)[1]:] (20L) == 63);\n+ static_assert (s.[:members_of (^^S, uctx)[1]:] (30LL) == 73);\n+ static_assert (s.[:members_of (^^S, uctx)[2]:] (10) == 54);\n+ static_assert (s.[:members_of (^^S, uctx)[2]:] (20L) == 64);\n+ static_assert (s.[:members_of (^^S, uctx)[2]:] (30LL) == 74);\n+ static_assert (s.bar (0) == 72);\n+ static_assert (s.bar (0L) == 73);\n+ static_assert (s.bar (0LL) == 74);\n+ static_assert (s.[:members_of (^^S, uctx)[3]:] (10) == 82);\n+ static_assert (s.[:members_of (^^S, uctx)[3]:] (20L) == 92);\n+ static_assert (s.[:members_of (^^S, uctx)[3]:] (30LL) == 102);\n+ static_assert (s.[:members_of (^^S, uctx)[4]:] (10) == 83);\n+ static_assert (s.[:members_of (^^S, uctx)[4]:] (20L) == 93);\n+ static_assert (s.[:members_of (^^S, uctx)[4]:] (30LL) == 103);\n+ static_assert (s.[:members_of (^^S, uctx)[5]:] (10) == 84);\n+ static_assert (s.[:members_of (^^S, uctx)[5]:] (20L) == 94);\n+ static_assert (s.[:members_of (^^S, uctx)[5]:] (30LL) == 104);\n+ constexpr T t = 2;\n+ static_assert (t.foo (0) == 53);\n+ static_assert (t.foo (0L) == 54);\n+ static_assert (t.foo (0LL) == 55);\n+ static_assert (t.[:members_of (^^S, uctx)[0]:] (10) == 53);\n+ static_assert (t.[:members_of (^^S, uctx)[0]:] (20L) == 63);\n+ static_assert (t.[:members_of (^^S, uctx)[0]:] (30LL) == 73);\n+ static_assert (t.[:members_of (^^S, uctx)[1]:] (10) == 54);\n+ static_assert (t.[:members_of (^^S, uctx)[1]:] (20L) == 64);\n+ static_assert (t.[:members_of (^^S, uctx)[1]:] (30LL) == 74);\n+ static_assert (t.[:members_of (^^S, uctx)[2]:] (10) == 55);\n+ static_assert (t.[:members_of (^^S, uctx)[2]:] (20L) == 65);\n+ static_assert (t.[:members_of (^^S, uctx)[2]:] (30LL) == 75);\n+ static_assert (t.[:members_of (^^T, uctx)[0]:] (10) == 63);\n+ static_assert (t.[:members_of (^^T, uctx)[0]:] (20L) == 73);\n+ static_assert (t.[:members_of (^^T, uctx)[0]:] (30LL) == 83);\n+ static_assert (t.[:members_of (^^T, uctx)[1]:] (10) == 64);\n+ static_assert (t.[:members_of (^^T, uctx)[1]:] (20L) == 74);\n+ static_assert (t.[:members_of (^^T, uctx)[1]:] (30LL) == 84);\n+ static_assert (t.[:members_of (^^T, uctx)[2]:] (10) == 65);\n+ static_assert (t.[:members_of (^^T, uctx)[2]:] (20L) == 75);\n+ static_assert (t.[:members_of (^^T, uctx)[2]:] (30LL) == 85);\n+ static_assert (t.bar (0) == 82);\n+ static_assert (t.bar (0L) == 83);\n+ static_assert (t.bar (0LL) == 84);\n+ static_assert (t.[:members_of (^^S, uctx)[3]:] (10) == 82);\n+ static_assert (t.[:members_of (^^S, uctx)[3]:] (20L) == 92);\n+ static_assert (t.[:members_of (^^S, uctx)[3]:] (30LL) == 102);\n+ static_assert (t.[:members_of (^^S, uctx)[4]:] (10) == 83);\n+ static_assert (t.[:members_of (^^S, uctx)[4]:] (20L) == 93);\n+ static_assert (t.[:members_of (^^S, uctx)[4]:] (30LL) == 103);\n+ static_assert (t.[:members_of (^^S, uctx)[5]:] (10) == 84);\n+ static_assert (t.[:members_of (^^S, uctx)[5]:] (20L) == 94);\n+ static_assert (t.[:members_of (^^S, uctx)[5]:] (30LL) == 104);\n+ static_assert (t.[:members_of (^^T, uctx)[3]:] (10) == 92);\n+ static_assert (t.[:members_of (^^T, uctx)[3]:] (20L) == 102);\n+ static_assert (t.[:members_of (^^T, uctx)[3]:] (30LL) == 112);\n+ static_assert (t.[:members_of (^^T, uctx)[4]:] (10) == 93);\n+ static_assert (t.[:members_of (^^T, uctx)[4]:] (20L) == 103);\n+ static_assert (t.[:members_of (^^T, uctx)[4]:] (30LL) == 113);\n+ static_assert (t.[:members_of (^^T, uctx)[5]:] (10) == 94);\n+ static_assert (t.[:members_of (^^T, uctx)[5]:] (20L) == 104);\n+ static_assert (t.[:members_of (^^T, uctx)[5]:] (30LL) == 114);\n+}\n+\n+template \n+void\n+bar ()\n+{\n+ constexpr A s = 1;\n+ static_assert (s.foo (0) == 42);\n+ static_assert (s.foo (0L) == 43);\n+ static_assert (s.foo (0LL) == 44);\n+ static_assert (s.[:members_of (^^S, uctx)[0]:] (10) == 52);\n+ static_assert (s.[:members_of (^^S, uctx)[0]:] (20L) == 62);\n+ static_assert (s.[:members_of (^^S, uctx)[0]:] (30LL) == 72);\n+ static_assert (s.[:members_of (^^S, uctx)[1]:] (10) == 53);\n+ static_assert (s.[:members_of (^^S, uctx)[1]:] (20L) == 63);\n+ static_assert (s.[:members_of (^^S, uctx)[1]:] (30LL) == 73);\n+ static_assert (s.[:members_of (^^S, uctx)[2]:] (10) == 54);\n+ static_assert (s.[:members_of (^^S, uctx)[2]:] (20L) == 64);\n+ static_assert (s.[:members_of (^^S, uctx)[2]:] (30LL) == 74);\n+ static_assert (s.bar (0) == 72);\n+ static_assert (s.bar (0L) == 73);\n+ static_assert (s.bar (0LL) == 74);\n+ static_assert (s.[:members_of (^^S, uctx)[3]:] (10) == 82);\n+ static_assert (s.[:members_of (^^S, uctx)[3]:] (20L) == 92);\n+ static_assert (s.[:members_of (^^S, uctx)[3]:] (30LL) == 102);\n+ static_assert (s.[:members_of (^^S, uctx)[4]:] (10) == 83);\n+ static_assert (s.[:members_of (^^S, uctx)[4]:] (20L) == 93);\n+ static_assert (s.[:members_of (^^S, uctx)[4]:] (30LL) == 103);\n+ static_assert (s.[:members_of (^^S, uctx)[5]:] (10) == 84);\n+ static_assert (s.[:members_of (^^S, uctx)[5]:] (20L) == 94);\n+ static_assert (s.[:members_of (^^S, uctx)[5]:] (30LL) == 104);\n+ constexpr B t = 2;\n+ static_assert (t.foo (0) == 53);\n+ static_assert (t.foo (0L) == 54);\n+ static_assert (t.foo (0LL) == 55);\n+ static_assert (t.[:members_of (^^S, uctx)[0]:] (10) == 53);\n+ static_assert (t.[:members_of (^^S, uctx)[0]:] (20L) == 63);\n+ static_assert (t.[:members_of (^^S, uctx)[0]:] (30LL) == 73);\n+ static_assert (t.[:members_of (^^S, uctx)[1]:] (10) == 54);\n+ static_assert (t.[:members_of (^^S, uctx)[1]:] (20L) == 64);\n+ static_assert (t.[:members_of (^^S, uctx)[1]:] (30LL) == 74);\n+ static_assert (t.[:members_of (^^S, uctx)[2]:] (10) == 55);\n+ static_assert (t.[:members_of (^^S, uctx)[2]:] (20L) == 65);\n+ static_assert (t.[:members_of (^^S, uctx)[2]:] (30LL) == 75);\n+ static_assert (t.[:members_of (^^T, uctx)[0]:] (10) == 63);\n+ static_assert (t.[:members_of (^^T, uctx)[0]:] (20L) == 73);\n+ static_assert (t.[:members_of (^^T, uctx)[0]:] (30LL) == 83);\n+ static_assert (t.[:members_of (^^T, uctx)[1]:] (10) == 64);\n+ static_assert (t.[:members_of (^^T, uctx)[1]:] (20L) == 74);\n+ static_assert (t.[:members_of (^^T, uctx)[1]:] (30LL) == 84);\n+ static_assert (t.[:members_of (^^T, uctx)[2]:] (10) == 65);\n+ static_assert (t.[:members_of (^^T, uctx)[2]:] (20L) == 75);\n+ static_assert (t.[:members_of (^^T, uctx)[2]:] (30LL) == 85);\n+ static_assert (t.bar (0) == 82);\n+ static_assert (t.bar (0L) == 83);\n+ static_assert (t.bar (0LL) == 84);\n+ static_assert (t.[:members_of (^^S, uctx)[3]:] (10) == 82);\n+ static_assert (t.[:members_of (^^S, uctx)[3]:] (20L) == 92);\n+ static_assert (t.[:members_of (^^S, uctx)[3]:] (30LL) == 102);\n+ static_assert (t.[:members_of (^^S, uctx)[4]:] (10) == 83);\n+ static_assert (t.[:members_of (^^S, uctx)[4]:] (20L) == 93);\n+ static_assert (t.[:members_of (^^S, uctx)[4]:] (30LL) == 103);\n+ static_assert (t.[:members_of (^^S, uctx)[5]:] (10) == 84);\n+ static_assert (t.[:members_of (^^S, uctx)[5]:] (20L) == 94);\n+ static_assert (t.[:members_of (^^S, uctx)[5]:] (30LL) == 104);\n+ static_assert (t.[:members_of (^^T, uctx)[3]:] (10) == 92);\n+ static_assert (t.[:members_of (^^T, uctx)[3]:] (20L) == 102);\n+ static_assert (t.[:members_of (^^T, uctx)[3]:] (30LL) == 112);\n+ static_assert (t.[:members_of (^^T, uctx)[4]:] (10) == 93);\n+ static_assert (t.[:members_of (^^T, uctx)[4]:] (20L) == 103);\n+ static_assert (t.[:members_of (^^T, uctx)[4]:] (30LL) == 113);\n+ static_assert (t.[:members_of (^^T, uctx)[5]:] (10) == 94);\n+ static_assert (t.[:members_of (^^T, uctx)[5]:] (20L) == 104);\n+ static_assert (t.[:members_of (^^T, uctx)[5]:] (30LL) == 114);\n+}\n+\n+template \n+void\n+baz ()\n+{\n+ constexpr S s = 1;\n+ static_assert (s.foo (0) == 42);\n+ static_assert (s.foo (0L) == 43);\n+ static_assert (s.foo (0LL) == 44);\n+ static_assert (s.[:members_of (^^A, uctx)[0]:] (10) == 52);\n+ static_assert (s.[:members_of (^^A, uctx)[0]:] (20L) == 62);\n+ static_assert (s.[:members_of (^^A, uctx)[0]:] (30LL) == 72);\n+ static_assert (s.[:members_of (^^A, uctx)[1]:] (10) == 53);\n+ static_assert (s.[:members_of (^^A, uctx)[1]:] (20L) == 63);\n+ static_assert (s.[:members_of (^^A, uctx)[1]:] (30LL) == 73);\n+ static_assert (s.[:members_of (^^A, uctx)[2]:] (10) == 54);\n+ static_assert (s.[:members_of (^^A, uctx)[2]:] (20L) == 64);\n+ static_assert (s.[:members_of (^^A, uctx)[2]:] (30LL) == 74);\n+ static_assert (s.bar (0) == 72);\n+ static_assert (s.bar (0L) == 73);\n+ static_assert (s.bar (0LL) == 74);\n+ static_assert (s.[:members_of (^^A, uctx)[3]:] (10) == 82);\n+ static_assert (s.[:members_of (^^A, uctx)[3]:] (20L) == 92);\n+ static_assert (s.[:members_of (^^A, uctx)[3]:] (30LL) == 102);\n+ static_assert (s.[:members_of (^^A, uctx)[4]:] (10) == 83);\n+ static_assert (s.[:members_of (^^A, uctx)[4]:] (20L) == 93);\n+ static_assert (s.[:members_of (^^A, uctx)[4]:] (30LL) == 103);\n+ static_assert (s.[:members_of (^^A, uctx)[5]:] (10) == 84);\n+ static_assert (s.[:members_of (^^A, uctx)[5]:] (20L) == 94);\n+ static_assert (s.[:members_of (^^A, uctx)[5]:] (30LL) == 104);\n+ constexpr T t = 2;\n+ static_assert (t.foo (0) == 53);\n+ static_assert (t.foo (0L) == 54);\n+ static_assert (t.foo (0LL) == 55);\n+ static_assert (t.[:members_of (^^A, uctx)[0]:] (10) == 53);\n+ static_assert (t.[:members_of (^^A, uctx)[0]:] (20L) == 63);\n+ static_assert (t.[:members_of (^^A, uctx)[0]:] (30LL) == 73);\n+ static_assert (t.[:members_of (^^A, uctx)[1]:] (10) == 54);\n+ static_assert (t.[:members_of (^^A, uctx)[1]:] (20L) == 64);\n+ static_assert (t.[:members_of (^^A, uctx)[1]:] (30LL) == 74);\n+ static_assert (t.[:members_of (^^A, uctx)[2]:] (10) == 55);\n+ static_assert (t.[:members_of (^^A, uctx)[2]:] (20L) == 65);\n+ static_assert (t.[:members_of (^^A, uctx)[2]:] (30LL) == 75);\n+ static_assert (t.[:members_of (^^B, uctx)[0]:] (10) == 63);\n+ static_assert (t.[:members_of (^^B, uctx)[0]:] (20L) == 73);\n+ static_assert (t.[:members_of (^^B, uctx)[0]:] (30LL) == 83);\n+ static_assert (t.[:members_of (^^B, uctx)[1]:] (10) == 64);\n+ static_assert (t.[:members_of (^^B, uctx)[1]:] (20L) == 74);\n+ static_assert (t.[:members_of (^^B, uctx)[1]:] (30LL) == 84);\n+ static_assert (t.[:members_of (^^B, uctx)[2]:] (10) == 65);\n+ static_assert (t.[:members_of (^^B, uctx)[2]:] (20L) == 75);\n+ static_assert (t.[:members_of (^^B, uctx)[2]:] (30LL) == 85);\n+ static_assert (t.bar (0) == 82);\n+ static_assert (t.bar (0L) == 83);\n+ static_assert (t.bar (0LL) == 84);\n+ static_assert (t.[:members_of (^^A, uctx)[3]:] (10) == 82);\n+ static_assert (t.[:members_of (^^A, uctx)[3]:] (20L) == 92);\n+ static_assert (t.[:members_of (^^A, uctx)[3]:] (30LL) == 102);\n+ static_assert (t.[:members_of (^^A, uctx)[4]:] (10) == 83);\n+ static_assert (t.[:members_of (^^A, uctx)[4]:] (20L) == 93);\n+ static_assert (t.[:members_of (^^A, uctx)[4]:] (30LL) == 103);\n+ static_assert (t.[:members_of (^^A, uctx)[5]:] (10) == 84);\n+ static_assert (t.[:members_of (^^A, uctx)[5]:] (20L) == 94);\n+ static_assert (t.[:members_of (^^A, uctx)[5]:] (30LL) == 104);\n+ static_assert (t.[:members_of (^^B, uctx)[3]:] (10) == 92);\n+ static_assert (t.[:members_of (^^B, uctx)[3]:] (20L) == 102);\n+ static_assert (t.[:members_of (^^B, uctx)[3]:] (30LL) == 112);\n+ static_assert (t.[:members_of (^^B, uctx)[4]:] (10) == 93);\n+ static_assert (t.[:members_of (^^B, uctx)[4]:] (20L) == 103);\n+ static_assert (t.[:members_of (^^B, uctx)[4]:] (30LL) == 113);\n+ static_assert (t.[:members_of (^^B, uctx)[5]:] (10) == 94);\n+ static_assert (t.[:members_of (^^B, uctx)[5]:] (20L) == 104);\n+ static_assert (t.[:members_of (^^B, uctx)[5]:] (30LL) == 114);\n+}\n+\n+template \n+void\n+qux ()\n+{\n+ constexpr A s = 1;\n+ static_assert (s.foo (0) == 42);\n+ static_assert (s.foo (0L) == 43);\n+ static_assert (s.foo (0LL) == 44);\n+ static_assert (s.[:members_of (^^A, uctx)[0]:] (10) == 52);\n+ static_assert (s.[:members_of (^^A, uctx)[0]:] (20L) == 62);\n+ static_assert (s.[:members_of (^^A, uctx)[0]:] (30LL) == 72);\n+ static_assert (s.[:members_of (^^A, uctx)[1]:] (10) == 53);\n+ static_assert (s.[:members_of (^^A, uctx)[1]:] (20L) == 63);\n+ static_assert (s.[:members_of (^^A, uctx)[1]:] (30LL) == 73);\n+ static_assert (s.[:members_of (^^A, uctx)[2]:] (10) == 54);\n+ static_assert (s.[:members_of (^^A, uctx)[2]:] (20L) == 64);\n+ static_assert (s.[:members_of (^^A, uctx)[2]:] (30LL) == 74);\n+ static_assert (s.bar (0) == 72);\n+ static_assert (s.bar (0L) == 73);\n+ static_assert (s.bar (0LL) == 74);\n+ static_assert (s.[:members_of (^^A, uctx)[3]:] (10) == 82);\n+ static_assert (s.[:members_of (^^A, uctx)[3]:] (20L) == 92);\n+ static_assert (s.[:members_of (^^A, uctx)[3]:] (30LL) == 102);\n+ static_assert (s.[:members_of (^^A, uctx)[4]:] (10) == 83);\n+ static_assert (s.[:members_of (^^A, uctx)[4]:] (20L) == 93);\n+ static_assert (s.[:members_of (^^A, uctx)[4]:] (30LL) == 103);\n+ static_assert (s.[:members_of (^^A, uctx)[5]:] (10) == 84);\n+ static_assert (s.[:members_of (^^A, uctx)[5]:] (20L) == 94);\n+ static_assert (s.[:members_of (^^A, uctx)[5]:] (30LL) == 104);\n+ constexpr B t = 2;\n+ static_assert (t.foo (0) == 53);\n+ static_assert (t.foo (0L) == 54);\n+ static_assert (t.foo (0LL) == 55);\n+ static_assert (t.[:members_of (^^A, uctx)[0]:] (10) == 53);\n+ static_assert (t.[:members_of (^^A, uctx)[0]:] (20L) == 63);\n+ static_assert (t.[:members_of (^^A, uctx)[0]:] (30LL) == 73);\n+ static_assert (t.[:members_of (^^A, uctx)[1]:] (10) == 54);\n+ static_assert (t.[:members_of (^^A, uctx)[1]:] (20L) == 64);\n+ static_assert (t.[:members_of (^^A, uctx)[1]:] (30LL) == 74);\n+ static_assert (t.[:members_of (^^A, uctx)[2]:] (10) == 55);\n+ static_assert (t.[:members_of (^^A, uctx)[2]:] (20L) == 65);\n+ static_assert (t.[:members_of (^^A, uctx)[2]:] (30LL) == 75);\n+ static_assert (t.[:members_of (^^B, uctx)[0]:] (10) == 63);\n+ static_assert (t.[:members_of (^^B, uctx)[0]:] (20L) == 73);\n+ static_assert (t.[:members_of (^^B, uctx)[0]:] (30LL) == 83);\n+ static_assert (t.[:members_of (^^B, uctx)[1]:] (10) == 64);\n+ static_assert (t.[:members_of (^^B, uctx)[1]:] (20L) == 74);\n+ static_assert (t.[:members_of (^^B, uctx)[1]:] (30LL) == 84);\n+ static_assert (t.[:members_of (^^B, uctx)[2]:] (10) == 65);\n+ static_assert (t.[:members_of (^^B, uctx)[2]:] (20L) == 75);\n+ static_assert (t.[:members_of (^^B, uctx)[2]:] (30LL) == 85);\n+ static_assert (t.bar (0) == 82);\n+ static_assert (t.bar (0L) == 83);\n+ static_assert (t.bar (0LL) == 84);\n+ static_assert (t.[:members_of (^^A, uctx)[3]:] (10) == 82);\n+ static_assert (t.[:members_of (^^A, uctx)[3]:] (20L) == 92);\n+ static_assert (t.[:members_of (^^A, uctx)[3]:] (30LL) == 102);\n+ static_assert (t.[:members_of (^^A, uctx)[4]:] (10) == 83);\n+ static_assert (t.[:members_of (^^A, uctx)[4]:] (20L) == 93);\n+ static_assert (t.[:members_of (^^A, uctx)[4]:] (30LL) == 103);\n+ static_assert (t.[:members_of (^^A, uctx)[5]:] (10) == 84);\n+ static_assert (t.[:members_of (^^A, uctx)[5]:] (20L) == 94);\n+ static_assert (t.[:members_of (^^A, uctx)[5]:] (30LL) == 104);\n+ static_assert (t.[:members_of (^^B, uctx)[3]:] (10) == 92);\n+ static_assert (t.[:members_of (^^B, uctx)[3]:] (20L) == 102);\n+ static_assert (t.[:members_of (^^B, uctx)[3]:] (30LL) == 112);\n+ static_assert (t.[:members_of (^^B, uctx)[4]:] (10) == 93);\n+ static_assert (t.[:members_of (^^B, uctx)[4]:] (20L) == 103);\n+ static_assert (t.[:members_of (^^B, uctx)[4]:] (30LL) == 113);\n+ static_assert (t.[:members_of (^^B, uctx)[5]:] (10) == 94);\n+ static_assert (t.[:members_of (^^B, uctx)[5]:] (20L) == 104);\n+ static_assert (t.[:members_of (^^B, uctx)[5]:] (30LL) == 114);\n+}\n+\n+void\n+fred ()\n+{\n+ foo <42> ();\n+ bar ();\n+ baz ();\n+ qux ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member18.C b/gcc/testsuite/g++.dg/reflect/member18.C\nnew file mode 100644\nindex 00000000000..50aa954c226\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member18.C\n@@ -0,0 +1,744 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+#include \n+\n+using namespace std::meta;\n+\n+struct S {\n+ template \n+ constexpr int foo (int x, const U &) const { return 41 + x + s; }\n+ template \n+ constexpr int foo (long x, const U &) const { return 42 + x + s; }\n+ template \n+ constexpr int foo (long long x, const U &) const { return 43 + x + s; }\n+ template \n+ static constexpr int bar (int x, const U &) { return 72 + x; } \n+ template \n+ static constexpr int bar (long x, const U &) { return 73 + x; } \n+ template \n+ static constexpr int bar (long long x, const U &) { return 74 + x; } \n+ constexpr S (int x) : s (x) {}\n+ int s;\n+};\n+struct T : public S {\n+ template \n+ constexpr int foo (int x, const U &) const { return 51 + x + s; }\n+ template \n+ constexpr int foo (long x, const U &) const { return 52 + x + s; }\n+ template \n+ constexpr int foo (long long x, const U &) const { return 53 + x + s; }\n+ template \n+ static constexpr int bar (int x, const U &) { return 82 + x; } \n+ template \n+ static constexpr int bar (long x, const U &) { return 83 + x; } \n+ template \n+ static constexpr int bar (long long x, const U &) { return 84 + x; } \n+ constexpr T (int x) : S (x) {}\n+};\n+\n+constexpr access_context uctx = access_context::unchecked ();\n+\n+constexpr S s = 1;\n+static_assert (s.foo (0, 1.0f) == 42);\n+static_assert (s.foo (0L, 1.0) == 43);\n+static_assert (s.foo (0LL, 1.0L) == 44);\n+static_assert (s.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 52);\n+static_assert (s.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 62);\n+static_assert (s.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 72);\n+static_assert (s.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 53);\n+static_assert (s.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 63);\n+static_assert (s.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 73);\n+static_assert (s.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 54);\n+static_assert (s.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 64);\n+static_assert (s.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 74);\n+static_assert (s.foo (0, 1.0f) == 42);\n+static_assert (s.foo (0L, 1.0) == 43);\n+static_assert (s.foo (0LL, 1.0L) == 44);\n+static_assert (s.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 52);\n+static_assert (s.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 62);\n+static_assert (s.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 72);\n+static_assert (s.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 53);\n+static_assert (s.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 63);\n+static_assert (s.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 73);\n+static_assert (s.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 54);\n+static_assert (s.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 64);\n+static_assert (s.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 74);\n+static_assert (s.bar (0, 1.0f) == 72);\n+static_assert (s.bar (0L, 1.0) == 73);\n+static_assert (s.bar (0LL, 1.0L) == 74);\n+static_assert (s.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+static_assert (s.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+static_assert (s.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+static_assert (s.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+static_assert (s.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+static_assert (s.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+static_assert (s.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+static_assert (s.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+static_assert (s.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+static_assert (s.bar (0, 1.0f) == 72);\n+static_assert (s.bar (0L, 1.0) == 73);\n+static_assert (s.bar (0LL, 1.0L) == 74);\n+static_assert (s.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+static_assert (s.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+static_assert (s.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+static_assert (s.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+static_assert (s.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+static_assert (s.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+static_assert (s.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+static_assert (s.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+static_assert (s.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+constexpr T t = 2;\n+static_assert (t.foo (0, 1.0f) == 53);\n+static_assert (t.foo (0L, 1.0) == 54);\n+static_assert (t.foo (0LL, 1.0L) == 55);\n+static_assert (t.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 53);\n+static_assert (t.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 63);\n+static_assert (t.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 73);\n+static_assert (t.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 54);\n+static_assert (t.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 64);\n+static_assert (t.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 74);\n+static_assert (t.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 55);\n+static_assert (t.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 65);\n+static_assert (t.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 75);\n+static_assert (t.template [:members_of (^^T, uctx)[0]:] (10, 1.0f) == 63);\n+static_assert (t.template [:members_of (^^T, uctx)[0]:] (20L, 1.0) == 73);\n+static_assert (t.template [:members_of (^^T, uctx)[0]:] (30LL, 1.0L) == 83);\n+static_assert (t.template [:members_of (^^T, uctx)[1]:] (10, 1.0f) == 64);\n+static_assert (t.template [:members_of (^^T, uctx)[1]:] (20L, 1.0) == 74);\n+static_assert (t.template [:members_of (^^T, uctx)[1]:] (30LL, 1.0L) == 84);\n+static_assert (t.template [:members_of (^^T, uctx)[2]:] (10, 1.0f) == 65);\n+static_assert (t.template [:members_of (^^T, uctx)[2]:] (20L, 1.0) == 75);\n+static_assert (t.template [:members_of (^^T, uctx)[2]:] (30LL, 1.0L) == 85);\n+static_assert (t.foo (0, 1.0f) == 53);\n+static_assert (t.foo (0L, 1.0) == 54);\n+static_assert (t.foo (0LL, 1.0L) == 55);\n+static_assert (t.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 53);\n+static_assert (t.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 63);\n+static_assert (t.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 73);\n+static_assert (t.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 54);\n+static_assert (t.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 64);\n+static_assert (t.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 74);\n+static_assert (t.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 55);\n+static_assert (t.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 65);\n+static_assert (t.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 75);\n+static_assert (t.template [:members_of (^^T, uctx)[0]:] (10, 1.0f) == 63);\n+static_assert (t.template [:members_of (^^T, uctx)[0]:] (20L, 1.0) == 73);\n+static_assert (t.template [:members_of (^^T, uctx)[0]:] (30LL, 1.0L) == 83);\n+static_assert (t.template [:members_of (^^T, uctx)[1]:] (10, 1.0f) == 64);\n+static_assert (t.template [:members_of (^^T, uctx)[1]:] (20L, 1.0) == 74);\n+static_assert (t.template [:members_of (^^T, uctx)[1]:] (30LL, 1.0L) == 84);\n+static_assert (t.template [:members_of (^^T, uctx)[2]:] (10, 1.0f) == 65);\n+static_assert (t.template [:members_of (^^T, uctx)[2]:] (20L, 1.0) == 75);\n+static_assert (t.template [:members_of (^^T, uctx)[2]:] (30LL, 1.0L) == 85);\n+static_assert (t.bar (0, 1.0f) == 82);\n+static_assert (t.bar (0L, 1.0) == 83);\n+static_assert (t.bar (0LL, 1.0L) == 84);\n+static_assert (t.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+static_assert (t.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+static_assert (t.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+static_assert (t.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+static_assert (t.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+static_assert (t.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+static_assert (t.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+static_assert (t.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+static_assert (t.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+static_assert (t.template [:members_of (^^T, uctx)[3]:] (10, 1.0f) == 92);\n+static_assert (t.template [:members_of (^^T, uctx)[3]:] (20L, 1.0) == 102);\n+static_assert (t.template [:members_of (^^T, uctx)[3]:] (30LL, 1.0L) == 112);\n+static_assert (t.template [:members_of (^^T, uctx)[4]:] (10, 1.0f) == 93);\n+static_assert (t.template [:members_of (^^T, uctx)[4]:] (20L, 1.0) == 103);\n+static_assert (t.template [:members_of (^^T, uctx)[4]:] (30LL, 1.0L) == 113);\n+static_assert (t.template [:members_of (^^T, uctx)[5]:] (10, 1.0f) == 94);\n+static_assert (t.template [:members_of (^^T, uctx)[5]:] (20L, 1.0) == 104);\n+static_assert (t.template [:members_of (^^T, uctx)[5]:] (30LL, 1.0L) == 114);\n+static_assert (t.bar (0, 1.0f) == 82);\n+static_assert (t.bar (0L, 1.0) == 83);\n+static_assert (t.bar (0LL, 1.0L) == 84);\n+static_assert (t.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+static_assert (t.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+static_assert (t.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+static_assert (t.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+static_assert (t.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+static_assert (t.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+static_assert (t.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+static_assert (t.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+static_assert (t.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+static_assert (t.template [:members_of (^^T, uctx)[3]:] (10, 1.0f) == 92);\n+static_assert (t.template [:members_of (^^T, uctx)[3]:] (20L, 1.0) == 102);\n+static_assert (t.template [:members_of (^^T, uctx)[3]:] (30LL, 1.0L) == 112);\n+static_assert (t.template [:members_of (^^T, uctx)[4]:] (10, 1.0f) == 93);\n+static_assert (t.template [:members_of (^^T, uctx)[4]:] (20L, 1.0) == 103);\n+static_assert (t.template [:members_of (^^T, uctx)[4]:] (30LL, 1.0L) == 113);\n+static_assert (t.template [:members_of (^^T, uctx)[5]:] (10, 1.0f) == 94);\n+static_assert (t.template [:members_of (^^T, uctx)[5]:] (20L, 1.0) == 104);\n+static_assert (t.template [:members_of (^^T, uctx)[5]:] (30LL, 1.0L) == 114);\n+\n+template \n+void\n+foo ()\n+{\n+ constexpr S s = 1;\n+ static_assert (s.foo (0, 1.0f) == 42);\n+ static_assert (s.foo (0L, 1.0) == 43);\n+ static_assert (s.foo (0LL, 1.0L) == 44);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 52);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 62);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 72);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 53);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 63);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 73);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 54);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 64);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 74);\n+ static_assert (s.foo (0, 1.0f) == 42);\n+ static_assert (s.foo (0L, 1.0) == 43);\n+ static_assert (s.foo (0LL, 1.0L) == 44);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 52);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 62);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 72);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 53);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 63);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 73);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 54);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 64);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 74);\n+ static_assert (s.bar (0, 1.0f) == 72);\n+ static_assert (s.bar (0L, 1.0) == 73);\n+ static_assert (s.bar (0LL, 1.0L) == 74);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (s.bar (0, 1.0f) == 72);\n+ static_assert (s.bar (0L, 1.0) == 73);\n+ static_assert (s.bar (0LL, 1.0L) == 74);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+ constexpr T t = 2;\n+ static_assert (t.foo (0, 1.0f) == 53);\n+ static_assert (t.foo (0L, 1.0) == 54);\n+ static_assert (t.foo (0LL, 1.0L) == 55);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 53);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 63);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 73);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 54);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 64);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 74);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 55);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 65);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 75);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (10, 1.0f) == 63);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (20L, 1.0) == 73);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (30LL, 1.0L) == 83);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (10, 1.0f) == 64);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (20L, 1.0) == 74);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (30LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (10, 1.0f) == 65);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (20L, 1.0) == 75);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (30LL, 1.0L) == 85);\n+ static_assert (t.foo (0, 1.0f) == 53);\n+ static_assert (t.foo (0L, 1.0) == 54);\n+ static_assert (t.foo (0LL, 1.0L) == 55);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 53);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 63);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 73);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 54);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 64);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 74);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 55);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 65);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 75);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (10, 1.0f) == 63);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (20L, 1.0) == 73);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (30LL, 1.0L) == 83);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (10, 1.0f) == 64);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (20L, 1.0) == 74);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (30LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (10, 1.0f) == 65);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (20L, 1.0) == 75);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (30LL, 1.0L) == 85);\n+ static_assert (t.bar (0, 1.0f) == 82);\n+ static_assert (t.bar (0L, 1.0) == 83);\n+ static_assert (t.bar (0LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (10, 1.0f) == 92);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (20L, 1.0) == 102);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (30LL, 1.0L) == 112);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (10, 1.0f) == 93);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (20L, 1.0) == 103);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (30LL, 1.0L) == 113);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (10, 1.0f) == 94);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (20L, 1.0) == 104);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (30LL, 1.0L) == 114);\n+ static_assert (t.bar (0, 1.0f) == 82);\n+ static_assert (t.bar (0L, 1.0) == 83);\n+ static_assert (t.bar (0LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (10, 1.0f) == 92);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (20L, 1.0) == 102);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (30LL, 1.0L) == 112);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (10, 1.0f) == 93);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (20L, 1.0) == 103);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (30LL, 1.0L) == 113);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (10, 1.0f) == 94);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (20L, 1.0) == 104);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (30LL, 1.0L) == 114);\n+}\n+\n+template \n+void\n+bar ()\n+{\n+ constexpr A s = 1;\n+ static_assert (s.foo (0, 1.0f) == 42);\n+ static_assert (s.foo (0L, 1.0) == 43);\n+ static_assert (s.foo (0LL, 1.0L) == 44);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 52);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 62);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 72);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 53);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 63);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 73);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 54);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 64);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 74);\n+ static_assert (s.template foo (0, 1.0f) == 42);\n+ static_assert (s.template foo (0L, 1.0) == 43);\n+ static_assert (s.template foo (0LL, 1.0L) == 44);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 52);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 62);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 72);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 53);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 63);\n+ static_assert (s.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 73);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 54);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 64);\n+ static_assert (s.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 74);\n+ static_assert (s.bar (0, 1.0f) == 72);\n+ static_assert (s.bar (0L, 1.0) == 73);\n+ static_assert (s.bar (0LL, 1.0L) == 74);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (s.template bar (0, 1.0f) == 72);\n+ static_assert (s.template bar (0L, 1.0) == 73);\n+ static_assert (s.template bar (0LL, 1.0L) == 74);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (s.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (s.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (s.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+ constexpr B t = 2;\n+ static_assert (t.foo (0, 1.0f) == 53);\n+ static_assert (t.foo (0L, 1.0) == 54);\n+ static_assert (t.foo (0LL, 1.0L) == 55);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 53);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 63);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 73);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 54);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 64);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 74);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 55);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 65);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 75);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (10, 1.0f) == 63);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (20L, 1.0) == 73);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (30LL, 1.0L) == 83);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (10, 1.0f) == 64);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (20L, 1.0) == 74);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (30LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (10, 1.0f) == 65);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (20L, 1.0) == 75);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (30LL, 1.0L) == 85);\n+ static_assert (t.template foo (0, 1.0f) == 53);\n+ static_assert (t.template foo (0L, 1.0) == 54);\n+ static_assert (t.template foo (0LL, 1.0L) == 55);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (10, 1.0f) == 53);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (20L, 1.0) == 63);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] (30LL, 1.0L) == 73);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (10, 1.0f) == 54);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (20L, 1.0) == 64);\n+ static_assert (t.template [:members_of (^^S, uctx)[1]:] (30LL, 1.0L) == 74);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (10, 1.0f) == 55);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (20L, 1.0) == 65);\n+ static_assert (t.template [:members_of (^^S, uctx)[2]:] (30LL, 1.0L) == 75);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (10, 1.0f) == 63);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (20L, 1.0) == 73);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] (30LL, 1.0L) == 83);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (10, 1.0f) == 64);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (20L, 1.0) == 74);\n+ static_assert (t.template [:members_of (^^T, uctx)[1]:] (30LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (10, 1.0f) == 65);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (20L, 1.0) == 75);\n+ static_assert (t.template [:members_of (^^T, uctx)[2]:] (30LL, 1.0L) == 85);\n+ static_assert (t.bar (0, 1.0f) == 82);\n+ static_assert (t.bar (0L, 1.0) == 83);\n+ static_assert (t.bar (0LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (10, 1.0f) == 92);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (20L, 1.0) == 102);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (30LL, 1.0L) == 112);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (10, 1.0f) == 93);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (20L, 1.0) == 103);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (30LL, 1.0L) == 113);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (10, 1.0f) == 94);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (20L, 1.0) == 104);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (30LL, 1.0L) == 114);\n+ static_assert (t.template bar (0, 1.0f) == 82);\n+ static_assert (t.template bar (0L, 1.0) == 83);\n+ static_assert (t.template bar (0LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (t.template [:members_of (^^S, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (t.template [:members_of (^^S, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (t.template [:members_of (^^S, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (10, 1.0f) == 92);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (20L, 1.0) == 102);\n+ static_assert (t.template [:members_of (^^T, uctx)[3]:] (30LL, 1.0L) == 112);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (10, 1.0f) == 93);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (20L, 1.0) == 103);\n+ static_assert (t.template [:members_of (^^T, uctx)[4]:] (30LL, 1.0L) == 113);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (10, 1.0f) == 94);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (20L, 1.0) == 104);\n+ static_assert (t.template [:members_of (^^T, uctx)[5]:] (30LL, 1.0L) == 114);\n+}\n+\n+template \n+void\n+baz ()\n+{\n+ constexpr S s = 1;\n+ static_assert (s.foo (0, 1.0f) == 42);\n+ static_assert (s.foo (0L, 1.0) == 43);\n+ static_assert (s.foo (0LL, 1.0L) == 44);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (10, 1.0f) == 52);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (20L, 1.0) == 62);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (30LL, 1.0L) == 72);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (10, 1.0f) == 53);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (20L, 1.0) == 63);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (30LL, 1.0L) == 73);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (10, 1.0f) == 54);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (20L, 1.0) == 64);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (30LL, 1.0L) == 74);\n+ static_assert (s.foo (0, 1.0f) == 42);\n+ static_assert (s.foo (0L, 1.0) == 43);\n+ static_assert (s.foo (0LL, 1.0L) == 44);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (10, 1.0f) == 52);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (20L, 1.0) == 62);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (30LL, 1.0L) == 72);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (10, 1.0f) == 53);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (20L, 1.0) == 63);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (30LL, 1.0L) == 73);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (10, 1.0f) == 54);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (20L, 1.0) == 64);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (30LL, 1.0L) == 74);\n+ static_assert (s.bar (0, 1.0f) == 72);\n+ static_assert (s.bar (0L, 1.0) == 73);\n+ static_assert (s.bar (0LL, 1.0L) == 74);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (s.bar (0, 1.0f) == 72);\n+ static_assert (s.bar (0L, 1.0) == 73);\n+ static_assert (s.bar (0LL, 1.0L) == 74);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (30LL, 1.0L) == 104);\n+ constexpr T t = 2;\n+ static_assert (t.foo (0, 1.0f) == 53);\n+ static_assert (t.foo (0L, 1.0) == 54);\n+ static_assert (t.foo (0LL, 1.0L) == 55);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (10, 1.0f) == 53);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (20L, 1.0) == 63);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (30LL, 1.0L) == 73);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (10, 1.0f) == 54);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (20L, 1.0) == 64);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (30LL, 1.0L) == 74);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (10, 1.0f) == 55);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (20L, 1.0) == 65);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (30LL, 1.0L) == 75);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (10, 1.0f) == 63);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (20L, 1.0) == 73);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (30LL, 1.0L) == 83);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (10, 1.0f) == 64);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (20L, 1.0) == 74);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (30LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (10, 1.0f) == 65);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (20L, 1.0) == 75);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (30LL, 1.0L) == 85);\n+ static_assert (t.foo (0, 1.0f) == 53);\n+ static_assert (t.foo (0L, 1.0) == 54);\n+ static_assert (t.foo (0LL, 1.0L) == 55);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (10, 1.0f) == 53);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (20L, 1.0) == 63);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (30LL, 1.0L) == 73);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (10, 1.0f) == 54);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (20L, 1.0) == 64);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (30LL, 1.0L) == 74);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (10, 1.0f) == 55);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (20L, 1.0) == 65);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (30LL, 1.0L) == 75);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (10, 1.0f) == 63);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (20L, 1.0) == 73);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (30LL, 1.0L) == 83);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (10, 1.0f) == 64);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (20L, 1.0) == 74);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (30LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (10, 1.0f) == 65);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (20L, 1.0) == 75);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (30LL, 1.0L) == 85);\n+ static_assert (t.bar (0, 1.0f) == 82);\n+ static_assert (t.bar (0L, 1.0) == 83);\n+ static_assert (t.bar (0LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (10, 1.0f) == 92);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (20L, 1.0) == 102);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (30LL, 1.0L) == 112);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (10, 1.0f) == 93);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (20L, 1.0) == 103);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (30LL, 1.0L) == 113);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (10, 1.0f) == 94);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (20L, 1.0) == 104);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (30LL, 1.0L) == 114);\n+ static_assert (t.bar (0, 1.0f) == 82);\n+ static_assert (t.bar (0L, 1.0) == 83);\n+ static_assert (t.bar (0LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (10, 1.0f) == 92);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (20L, 1.0) == 102);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (30LL, 1.0L) == 112);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (10, 1.0f) == 93);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (20L, 1.0) == 103);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (30LL, 1.0L) == 113);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (10, 1.0f) == 94);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (20L, 1.0) == 104);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (30LL, 1.0L) == 114);\n+}\n+\n+template \n+void\n+qux ()\n+{\n+ constexpr A s = 1;\n+ static_assert (s.foo (0, 1.0f) == 42);\n+ static_assert (s.foo (0L, 1.0) == 43);\n+ static_assert (s.foo (0LL, 1.0L) == 44);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (10, 1.0f) == 52);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (20L, 1.0) == 62);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (30LL, 1.0L) == 72);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (10, 1.0f) == 53);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (20L, 1.0) == 63);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (30LL, 1.0L) == 73);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (10, 1.0f) == 54);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (20L, 1.0) == 64);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (30LL, 1.0L) == 74);\n+ static_assert (s.template foo (0, 1.0f) == 42);\n+ static_assert (s.template foo (0L, 1.0) == 43);\n+ static_assert (s.template foo (0LL, 1.0L) == 44);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (10, 1.0f) == 52);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (20L, 1.0) == 62);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] (30LL, 1.0L) == 72);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (10, 1.0f) == 53);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (20L, 1.0) == 63);\n+ static_assert (s.template [:members_of (^^A, uctx)[1]:] (30LL, 1.0L) == 73);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (10, 1.0f) == 54);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (20L, 1.0) == 64);\n+ static_assert (s.template [:members_of (^^A, uctx)[2]:] (30LL, 1.0L) == 74);\n+ static_assert (s.bar (0, 1.0f) == 72);\n+ static_assert (s.bar (0L, 1.0) == 73);\n+ static_assert (s.bar (0LL, 1.0L) == 74);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (s.template bar (0, 1.0f) == 72);\n+ static_assert (s.template bar (0L, 1.0) == 73);\n+ static_assert (s.template bar (0LL, 1.0L) == 74);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (s.template [:members_of (^^A, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (s.template [:members_of (^^A, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (s.template [:members_of (^^A, uctx)[5]:] (30LL, 1.0L) == 104);\n+ constexpr B t = 2;\n+ static_assert (t.foo (0, 1.0f) == 53);\n+ static_assert (t.foo (0L, 1.0) == 54);\n+ static_assert (t.foo (0LL, 1.0L) == 55);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (10, 1.0f) == 53);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (20L, 1.0) == 63);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (30LL, 1.0L) == 73);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (10, 1.0f) == 54);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (20L, 1.0) == 64);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (30LL, 1.0L) == 74);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (10, 1.0f) == 55);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (20L, 1.0) == 65);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (30LL, 1.0L) == 75);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (10, 1.0f) == 63);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (20L, 1.0) == 73);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (30LL, 1.0L) == 83);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (10, 1.0f) == 64);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (20L, 1.0) == 74);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (30LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (10, 1.0f) == 65);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (20L, 1.0) == 75);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (30LL, 1.0L) == 85);\n+ static_assert (t.template foo (0, 1.0f) == 53);\n+ static_assert (t.template foo (0L, 1.0) == 54);\n+ static_assert (t.template foo (0LL, 1.0L) == 55);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (10, 1.0f) == 53);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (20L, 1.0) == 63);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] (30LL, 1.0L) == 73);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (10, 1.0f) == 54);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (20L, 1.0) == 64);\n+ static_assert (t.template [:members_of (^^A, uctx)[1]:] (30LL, 1.0L) == 74);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (10, 1.0f) == 55);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (20L, 1.0) == 65);\n+ static_assert (t.template [:members_of (^^A, uctx)[2]:] (30LL, 1.0L) == 75);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (10, 1.0f) == 63);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (20L, 1.0) == 73);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] (30LL, 1.0L) == 83);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (10, 1.0f) == 64);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (20L, 1.0) == 74);\n+ static_assert (t.template [:members_of (^^B, uctx)[1]:] (30LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (10, 1.0f) == 65);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (20L, 1.0) == 75);\n+ static_assert (t.template [:members_of (^^B, uctx)[2]:] (30LL, 1.0L) == 85);\n+ static_assert (t.bar (0, 1.0f) == 82);\n+ static_assert (t.bar (0L, 1.0) == 83);\n+ static_assert (t.bar (0LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (10, 1.0f) == 92);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (20L, 1.0) == 102);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (30LL, 1.0L) == 112);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (10, 1.0f) == 93);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (20L, 1.0) == 103);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (30LL, 1.0L) == 113);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (10, 1.0f) == 94);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (20L, 1.0) == 104);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (30LL, 1.0L) == 114);\n+ static_assert (t.template bar (0, 1.0f) == 82);\n+ static_assert (t.template bar (0L, 1.0) == 83);\n+ static_assert (t.template bar (0LL, 1.0L) == 84);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (10, 1.0f) == 82);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (20L, 1.0) == 92);\n+ static_assert (t.template [:members_of (^^A, uctx)[3]:] (30LL, 1.0L) == 102);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (10, 1.0f) == 83);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (20L, 1.0) == 93);\n+ static_assert (t.template [:members_of (^^A, uctx)[4]:] (30LL, 1.0L) == 103);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (10, 1.0f) == 84);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (20L, 1.0) == 94);\n+ static_assert (t.template [:members_of (^^A, uctx)[5]:] (30LL, 1.0L) == 104);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (10, 1.0f) == 92);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (20L, 1.0) == 102);\n+ static_assert (t.template [:members_of (^^B, uctx)[3]:] (30LL, 1.0L) == 112);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (10, 1.0f) == 93);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (20L, 1.0) == 103);\n+ static_assert (t.template [:members_of (^^B, uctx)[4]:] (30LL, 1.0L) == 113);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (10, 1.0f) == 94);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (20L, 1.0) == 104);\n+ static_assert (t.template [:members_of (^^B, uctx)[5]:] (30LL, 1.0L) == 114);\n+}\n+\n+void\n+fred ()\n+{\n+ foo <42> ();\n+ bar ();\n+ baz ();\n+ qux ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member19.C b/gcc/testsuite/g++.dg/reflect/member19.C\nnew file mode 100644\nindex 00000000000..8523ee55215\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member19.C\n@@ -0,0 +1,159 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+#include \n+\n+using namespace std::meta;\n+\n+struct S {\n+ template \n+ static constexpr int a = N;\n+};\n+struct T : public S {\n+ template \n+ static constexpr int a = N + 100;\n+};\n+\n+constexpr access_context uctx = access_context::unchecked ();\n+\n+constexpr S s;\n+static_assert (s.a <42> == 42);\n+static_assert (s.a <43> == 43);\n+static_assert (s.template [:members_of (^^S, uctx)[0]:] <44> == 44);\n+static_assert (s.template [:members_of (^^S, uctx)[0]:] <45> == 45);\n+static_assert (s.template [:^^S::a:] <44> == 44);\n+static_assert (s.template [:^^S::a:] <45> == 45);\n+constexpr T t;\n+static_assert (t.a <42> == 142);\n+static_assert (t.a <43> == 143);\n+static_assert (t.template [:members_of (^^S, uctx)[0]:] <44> == 44);\n+static_assert (t.template [:members_of (^^S, uctx)[0]:] <45> == 45);\n+static_assert (t.template [:members_of (^^T, uctx)[0]:] <44> == 144);\n+static_assert (t.template [:members_of (^^T, uctx)[0]:] <45> == 145);\n+static_assert (t.template [:^^S::a:] <44> == 44);\n+static_assert (t.template [:^^S::a:] <45> == 45);\n+static_assert (t.template [:^^T::a:] <44> == 144);\n+static_assert (t.template [:^^T::a:] <45> == 145);\n+\n+template \n+void\n+foo ()\n+{\n+ constexpr S s;\n+ static_assert (s.a <42> == 42);\n+ static_assert (s.a <43> == 43);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] <44> == 44);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] <45> == 45);\n+ static_assert (s.template [:^^S::a:] <44> == 44);\n+ static_assert (s.template [:^^S::a:] <45> == 45);\n+ constexpr T t;\n+ static_assert (t.a <42> == 142);\n+ static_assert (t.a <43> == 143);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] <44> == 44);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] <45> == 45);\n+ static_assert (t.template [:^^S::a:] <44> == 44);\n+ static_assert (t.template [:^^S::a:] <45> == 45);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] <44> == 144);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] <45> == 145);\n+ static_assert (t.template [:^^T::a:] <44> == 144);\n+ static_assert (t.template [:^^T::a:] <45> == 145);\n+}\n+\n+template \n+void\n+bar ()\n+{\n+ constexpr A s;\n+ static_assert (s.template a <42> == 42);\n+ static_assert (s.template a <43> == 43);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] <44> == 44);\n+ static_assert (s.template [:members_of (^^S, uctx)[0]:] <45> == 45);\n+ static_assert (s.template [:^^S::a:] <44> == 44);\n+ static_assert (s.template [:^^S::a:] <45> == 45);\n+ constexpr B t;\n+ static_assert (t.template a <42> == 142);\n+ static_assert (t.template a <43> == 143);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] <44> == 44);\n+ static_assert (t.template [:members_of (^^S, uctx)[0]:] <45> == 45);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] <44> == 144);\n+ static_assert (t.template [:members_of (^^T, uctx)[0]:] <45> == 145);\n+ static_assert (t.template [:^^S::a:] <44> == 44);\n+ static_assert (t.template [:^^S::a:] <45> == 45);\n+ static_assert (t.template [:^^T::a:] <44> == 144);\n+ static_assert (t.template [:^^T::a:] <45> == 145);\n+}\n+\n+template \n+void\n+baz ()\n+{\n+ constexpr S s;\n+ static_assert (s.a <42> == 42);\n+ static_assert (s.a <43> == 43);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] <44> == 44);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] <45> == 45);\n+#if 0\n+ // TODO: This doesn't work yet.\n+ static_assert (s.template [:^^A::a:] <44> == 44);\n+ static_assert (s.template [:^^A::a:] <45> == 45);\n+#endif\n+ constexpr T t;\n+ static_assert (t.a <42> == 142);\n+ static_assert (t.a <43> == 143);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] <44> == 44);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] <45> == 45);\n+#if 0\n+ // TODO: This doesn't work yet.\n+ static_assert (t.template [:^^A::a:] <44> == 44);\n+ static_assert (t.template [:^^A::a:] <45> == 45);\n+#endif\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] <44> == 144);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] <45> == 145);\n+#if 0\n+ // TODO: This doesn't work yet.\n+ static_assert (t.template [:^^B::a:] <44> == 144);\n+ static_assert (t.template [:^^B::a:] <45> == 145);\n+#endif\n+}\n+\n+template \n+void\n+qux ()\n+{\n+ constexpr A s;\n+ static_assert (s.template a <42> == 42);\n+ static_assert (s.template a <43> == 43);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] <44> == 44);\n+ static_assert (s.template [:members_of (^^A, uctx)[0]:] <45> == 45);\n+#if 0\n+ // TODO: This doesn't work yet.\n+ static_assert (s.template [:^^A::a:] <44> == 44);\n+ static_assert (s.template [:^^A::a:] <45> == 45);\n+#endif\n+ constexpr B t;\n+ static_assert (t.template a <42> == 142);\n+ static_assert (t.template a <43> == 143);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] <44> == 44);\n+ static_assert (t.template [:members_of (^^A, uctx)[0]:] <45> == 45);\n+#if 0\n+ // TODO: This doesn't work yet.\n+ static_assert (t.template [:^^A::a:] <44> == 44);\n+ static_assert (t.template [:^^A::a:] <45> == 45);\n+#endif\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] <44> == 144);\n+ static_assert (t.template [:members_of (^^B, uctx)[0]:] <45> == 145);\n+#if 0\n+ // TODO: This doesn't work yet.\n+ static_assert (t.template [:^^B::a:] <44> == 144);\n+ static_assert (t.template [:^^B::a:] <45> == 145);\n+#endif\n+}\n+\n+void\n+fred ()\n+{\n+ foo <42> ();\n+ bar ();\n+ baz ();\n+ qux ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member2.C b/gcc/testsuite/g++.dg/reflect/member2.C\nnew file mode 100644\nindex 00000000000..adf7928e571\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member2.C\n@@ -0,0 +1,14 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct B { consteval char fn() const { return 'B'; } };\n+struct D : B { consteval char fn() const { return 'D'; } };\n+\n+constexpr auto rBfn = ^^B::fn;\n+constexpr auto rDfn = ^^D::fn;\n+\n+constexpr D d;\n+constexpr auto rd = ^^d;\n+\n+static_assert([:rd:].[:rBfn:]() == 'B');\n+static_assert([:rd:].[:rDfn:]() == 'D');\ndiff --git a/gcc/testsuite/g++.dg/reflect/member20.C b/gcc/testsuite/g++.dg/reflect/member20.C\nnew file mode 100644\nindex 00000000000..1aa4b12bc17\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member20.C\n@@ -0,0 +1,26 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+template\n+void\n+bar ()\n+{\n+ constexpr auto t = [: R :]; // { dg-error \"use of local variable\" }\n+}\n+\n+void\n+g (int p)\n+{\n+ int x = 42;\n+ bar<^^p> ();\n+ constexpr auto r = ^^x;\n+ struct S {\n+ void foo () {\n+ [: ^^x :]; // { dg-error \"use of local variable\" }\n+ [: r :];\t // { dg-error \"use of local variable\" }\n+ decltype ([: ^^x :]) a{};\n+ decltype ([: r :]) b{};\n+ constexpr auto rx = ^^x;\n+ }\n+ };\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/member3.C b/gcc/testsuite/g++.dg/reflect/member3.C\nnew file mode 100644\nindex 00000000000..a9e698dd785\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member3.C\n@@ -0,0 +1,35 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test various forms of member access with this.\n+\n+struct S {\n+ int i;\n+ static constexpr int j = 42;\n+ int foo () { return 42; }\n+\n+ void\n+ f ()\n+ {\n+ static_assert([: ^^ j :] == 42);\n+ static_assert([: ^^S :]::j == 42);\n+ int q = this->[: ^^i :];\n+ q += this->[: ^^S :]::i;\n+ this->[: ^^foo :] ();\n+ this->[: ^^S :]::foo ();\n+ }\n+};\n+\n+struct D {\n+ int i;\n+ static constexpr int j = 42;\n+ int foo () { return 42; }\n+\n+ template\n+ void\n+ f ()\n+ {\n+ static_assert([: ^^T :]::j == 42);\n+ int q = this->[: ^^T :]::j;\n+ this->[: ^^T :]::foo ();\n+ }\n+};\ndiff --git a/gcc/testsuite/g++.dg/reflect/member4.C b/gcc/testsuite/g++.dg/reflect/member4.C\nnew file mode 100644\nindex 00000000000..35c3ff4dd0a\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member4.C\n@@ -0,0 +1,14 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct C {\n+ union {\n+ int i;\n+ };\n+};\n+\n+struct D { int i; };\n+\n+auto c = C{.i=2};\n+auto v = c.[:^^C::i:]; // { dg-error \"not a base\" }\n+auto e = c.[: ^^D::i :]; // { dg-error \"not a base\" }\ndiff --git a/gcc/testsuite/g++.dg/reflect/member5.C b/gcc/testsuite/g++.dg/reflect/member5.C\nnew file mode 100644\nindex 00000000000..96085636902\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member5.C\n@@ -0,0 +1,19 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct A { };\n+\n+struct S {\n+ int m(this S) { return 42; }\n+ int n() const { return 42; }\n+ enum { FOO } e;\n+ A a;\n+};\n+\n+auto p = &[: ^^S::m :];\n+auto q = &[: ^^S::m :];\n+\n+auto rm = [: ^^S::m :];\t // { dg-error \"cannot implicitly reference a class member through a splice\" }\n+auto rn = [: ^^S::n :]; // { dg-error \"cannot implicitly reference a class member through a splice\" }\n+auto re = [: ^^S::e :]; // { dg-error \"cannot implicitly reference a class member through a splice\" }\n+auto ra = [: ^^S::a :]; // { dg-error \"cannot implicitly reference a class member through a splice\" }\ndiff --git a/gcc/testsuite/g++.dg/reflect/member6.C b/gcc/testsuite/g++.dg/reflect/member6.C\nnew file mode 100644\nindex 00000000000..e77e1ca0168\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member6.C\n@@ -0,0 +1,13 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct S {\n+ int i;\n+};\n+\n+constexpr auto r = ^^S::i;\n+/* A pointer to member is only formed when an explicit & is used and\n+ its operand is a qualified-id or splice-expression not enclosed in\n+ parentheses. */\n+auto p = &([: r :]); // { dg-error \"cannot implicitly reference a class member through a splice\" }\n+auto q = &[: r :];\ndiff --git a/gcc/testsuite/g++.dg/reflect/member7.C b/gcc/testsuite/g++.dg/reflect/member7.C\nnew file mode 100644\nindex 00000000000..3fc41bb65fd\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member7.C\n@@ -0,0 +1,78 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// From clang/test/Reflection/splice-exprs.cpp.\n+\n+using info = decltype(^^int);\n+\n+struct S {\n+ int j;\n+ int k;\n+\n+ consteval int getJ() const { return j; }\n+\n+ template \n+ consteval int getJPlusN() const { return j + N; }\n+\n+ static consteval int eleven() { return 11; }\n+\n+ template \n+ static consteval int constant() { return N; }\n+};\n+\n+// Splicing dependent member references.\n+template \n+consteval int fn() {\n+ S s = {11, 13};\n+ return s.[:RMem:] + (&s)->[:RMem:];\n+}\n+static_assert(fn<^^S::j>() == 22);\n+static_assert(fn<^^S::k>() == 26);\n+\n+// Splicing dependent member references with arrow syntax.\n+template \n+consteval int fn2() {\n+ S s = {11, 13};\n+ return s.*(&[:RMem:]) + (&s)->*(&[:RMem:]);\n+}\n+static_assert(fn<^^S::j>() == 22);\n+static_assert(fn<^^S::k>() == 26);\n+\n+// Splicing member functions.\n+constexpr info r_getJ = ^^S::getJ;\n+static_assert(S{2, 4}.[:r_getJ:]() == 2);\n+\n+// Splicing static member functions.\n+constexpr auto rEleven = ^^S::eleven;\n+static_assert([:rEleven:]() == 11);\n+\n+// Splicing static member template function instantiation.\n+constexpr auto rConst14 = ^^S::constant<14>;\n+static_assert([:rConst14:]() == 14);\n+\n+// Splicing member function template instantiations.\n+constexpr auto rgetJPlus5 = ^^S::getJPlusN<5>;\n+static_assert(S{2, 4}.[:rgetJPlus5:]() == 7);\n+\n+// Splicing member function template instantiations with spliced objects.\n+constexpr S instance {1, 4};\n+constexpr info rInstance = ^^instance;\n+static_assert([:rInstance:].[:rgetJPlus5:]() == 6);\n+static_assert((&[:rInstance:])->[:rgetJPlus5:]() == 6);\n+\n+// Splicing dependent object in a member access expression.\n+template \n+consteval int fn3() {\n+ return [:RObj:].k;\n+}\n+static_assert(fn3<^^instance>() == 4);\n+\n+// Passing address of a spliced operand as an argument.\n+consteval int getMem(const S *s, int S::* mem) {\n+ return s->*mem;\n+}\n+constexpr info rJ = ^^S::j;\n+static_assert(getMem(&instance, &[:rJ:]) == 1);\n+\n+// Member access through a splice of a private member.\n+class WithPrivateBase : S {} d;\n+int dK = d.[:^^S::k:];\ndiff --git a/gcc/testsuite/g++.dg/reflect/member8.C b/gcc/testsuite/g++.dg/reflect/member8.C\nnew file mode 100644\nindex 00000000000..4f96b5583ec\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member8.C\n@@ -0,0 +1,15 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct S {\n+ int k;\n+};\n+\n+struct Y {\n+ int k;\n+};\n+struct X : S { };\n+\n+class D : S , X {} d;\t// { dg-warning \"direct base .S. inaccessible in .D. due to ambiguity\" }\n+int dK = d.[:^^S::k:];\t// { dg-error \".S. is an ambiguous base of .D.\" }\n+int dY = d.[:^^Y::k:];\t// { dg-error \".Y. is not a base of .D.\" }\ndiff --git a/gcc/testsuite/g++.dg/reflect/member9.C b/gcc/testsuite/g++.dg/reflect/member9.C\nnew file mode 100644\nindex 00000000000..5a6d9836a58\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/member9.C\n@@ -0,0 +1,18 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct B { consteval virtual int fn() const { return 1; } };\n+struct D : B { consteval int fn() const override { return 2; } };\n+\n+constexpr D d;\n+static_assert(d.[:^^D::fn:]() == 2);\n+static_assert(d.D::fn() == 2);\n+static_assert(d.[:^^B::fn:]() == 2);\n+static_assert(d.[:^^B:]::fn() == 1);\n+static_assert(d.B::fn() == 1);\n+\n+// Splicing member as intermediate component of a member-access expression.\n+struct T { struct Inner { int v; } inner; };\n+constexpr auto r_inner = ^^T::inner;\n+constexpr T t = {{4}};\n+static_assert(t.[:r_inner:].v == 4);\ndiff --git a/gcc/testsuite/g++.dg/reflect/members_of1.C b/gcc/testsuite/g++.dg/reflect/members_of1.C\nnew file mode 100644\nindex 00000000000..2d52da07a41\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/members_of1.C\n@@ -0,0 +1,524 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::{,{,non}static_data_}members_of and\n+// has_inaccessible_nonstatic_data_members.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+using std::views::filter;\n+using std::ranges::to;\n+using std::vector;\n+using std::string_view;\n+\n+consteval bool\n+check_special_members (const vector &vec, int cnt, bool dct, bool cct, bool cas, bool mct, bool mas, bool dt)\n+{\n+ if ((vec | filter (is_special_member_function) | filter (is_defaulted) | to ()).size () != cnt)\n+ throw 1;\n+ if ((vec | filter (is_default_constructor) | to ()).size () != dct)\n+ throw 2;\n+ if ((vec | filter (is_copy_constructor) | to ()).size () != cct)\n+ throw 3;\n+ if ((vec | filter (is_copy_assignment) | to ()).size () != cas)\n+ throw 4;\n+ if ((vec | filter (is_move_constructor) | to ()).size () != mct)\n+ throw 5;\n+ if ((vec | filter (is_move_assignment) | to ()).size () != mas)\n+ throw 6;\n+ if ((vec | filter (is_destructor) | to ()).size () != dt)\n+ throw 7;\n+ return true;\n+}\n+\n+namespace N1 {\n+ struct A {\n+ int a;\n+ static int b;\n+ enum E { E0 };\n+ using c = int;\n+ typedef long d;\n+ consteval {\n+ }\n+ };\n+ int A::b = 24;\n+ consteval {\n+ }\n+}\n+namespace N2 {\n+ struct B {};\n+ struct C { int : 5; };\n+ struct D { D (int = 42); int d; };\n+ struct E { E (int); int e; };\n+ struct F { int f; F (const F &); };\n+ struct G { G &operator = (const G &); int g; };\n+ struct H { int h; H (H &&); };\n+ struct I { I &operator = (I &&); int i; };\n+ struct J { ~J (); };\n+ struct K {\n+ int a;\n+ static int b;\n+ enum E { E0 };\n+ using c = int;\n+ typedef long d;\n+ template \n+ struct A {};\n+ template \n+ static consteval bool foo (const T &) { return true; }\n+ template \n+ static constexpr int e = N;\n+ template \n+ using f = const T &;\n+ void bar () {}\n+ auto baz ();\n+ int g : 3;\n+ long : 2;\n+ int : 0;\n+ consteval {\n+ A z = {};\n+ static_assert (e <42> == 42);\n+ f w = 42;\n+ }\n+ protected:\n+ int Xa;\n+ static int Xb;\n+ enum XE { XE0 };\n+ using Xc = int;\n+ typedef long Xd;\n+ template \n+ struct XA {};\n+ template \n+ static consteval bool Xfoo (const T &) { return true; }\n+ template \n+ static constexpr int Xe = N;\n+ template \n+ using Xf = const T &;\n+ void Xbar () {}\n+ auto Xbaz ();\n+ int Xg : 5;\n+ long : 4;\n+ int : 0;\n+ private:\n+ int Ya;\n+ static int Yb;\n+ enum YE { YE0 };\n+ using Yc = int;\n+ typedef long Yd;\n+ template \n+ struct YA {};\n+ template \n+ static consteval bool Yfoo (const T &) { return true; }\n+ template \n+ static constexpr int Ye = N;\n+ template \n+ using Yf = const T &;\n+ void Ybar () {}\n+ auto Ybaz ();\n+ int Yg : 7;\n+ long : 6;\n+ int : 0;\n+ public:\n+ static constexpr info rXa = ^^Xa;\n+ static constexpr info rXb = ^^Xb;\n+ static constexpr info rXE = ^^XE;\n+ static constexpr info rXg = ^^Xg;\n+ static constexpr info rYa = ^^Ya;\n+ static constexpr info rYb = ^^Yb;\n+ static constexpr info rYE = ^^YE;\n+ static constexpr info rYg = ^^Yg;\n+ };\n+ namespace W {}\n+ namespace X = W;\n+ namespace W {}\n+ namespace W {}\n+ inline namespace Y { int a; }\n+ template \n+ concept Z = requires { true; };\n+}\n+static_assert (N2::K::foo (42) && N2::K::foo (42UL));\n+\n+constexpr access_context gctx = access_context::current ();\n+constexpr access_context uctx = access_context::unchecked ();\n+\n+static_assert (members_of (^^N1::A, gctx).size () == 11);\n+static_assert (members_of (^^N1::A, gctx)[0] == ^^N1::A::a);\n+static_assert (members_of (^^N1::A, gctx)[1] == ^^N1::A::b);\n+static_assert (members_of (^^N1::A, gctx)[2] == ^^N1::A::E);\n+static_assert (members_of (^^N1::A, gctx)[3] == ^^N1::A::c);\n+static_assert (members_of (^^N1::A, gctx)[4] == ^^N1::A::d);\n+static_assert (check_special_members (members_of (^^N1::A, gctx), 6, true, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N1::A, gctx).size () == 1);\n+static_assert (static_data_members_of (^^N1::A, gctx)[0] == ^^N1::A::b);\n+static_assert (nonstatic_data_members_of (^^N1::A, gctx).size () == 1);\n+static_assert (nonstatic_data_members_of (^^N1::A, gctx)[0] == ^^N1::A::a);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N1::A, gctx));\n+\n+static_assert (members_of (^^N1, gctx).size () == 1);\n+static_assert (members_of (^^N1, gctx)[0] == ^^N1::A);\n+\n+static_assert (members_of (^^N2::B, gctx).size () == 6);\n+static_assert (check_special_members (members_of (^^N2::B, gctx), 6, true, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N2::B, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::B, gctx).size () == 0);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::B, gctx));\n+\n+static_assert (members_of (^^N2::C, gctx).size () == 7);\n+static_assert (is_bit_field (members_of (^^N2::C, gctx)[0]));\n+static_assert (!has_identifier (members_of (^^N2::C, gctx)[0]));\n+static_assert (bit_size_of (members_of (^^N2::C, gctx)[0]) == 5);\n+static_assert (type_of (members_of (^^N2::C, gctx)[0]) == ^^int);\n+static_assert (check_special_members (members_of (^^N2::C, gctx), 6, true, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N2::C, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::C, gctx).size () == 0);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::C, gctx));\n+\n+static_assert (members_of (^^N2::D, gctx).size () == 7);\n+static_assert (is_default_constructor (members_of (^^N2::D, gctx)[0]));\n+static_assert (members_of (^^N2::D, gctx)[1] == ^^N2::D::d);\n+static_assert (check_special_members (members_of (^^N2::D, gctx), 5, true, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N2::D, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::D, gctx).size () == 1);\n+static_assert (nonstatic_data_members_of (^^N2::D, gctx)[0] == ^^N2::D::d);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::D, gctx));\n+\n+static_assert (members_of (^^N2::E, gctx).size () == 7);\n+static_assert (is_constructor (members_of (^^N2::E, gctx)[0]));\n+static_assert (members_of (^^N2::E, gctx)[1] == ^^N2::E::e);\n+static_assert (check_special_members (members_of (^^N2::E, gctx), 5, false, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N2::E, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::E, gctx).size () == 1);\n+static_assert (nonstatic_data_members_of (^^N2::E, gctx)[0] == ^^N2::E::e);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::E, gctx));\n+\n+static_assert (members_of (^^N2::F, gctx).size () == 4);\n+static_assert (members_of (^^N2::F, gctx)[0] == ^^N2::F::f);\n+static_assert (is_copy_constructor (members_of (^^N2::F, gctx)[1]));\n+static_assert (check_special_members (members_of (^^N2::F, gctx), 2, false, true, true, false, false, true));\n+static_assert (static_data_members_of (^^N2::F, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::F, gctx).size () == 1);\n+static_assert (nonstatic_data_members_of (^^N2::F, gctx)[0] == ^^N2::F::f);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::F, gctx));\n+\n+static_assert (members_of (^^N2::G, gctx).size () == 5);\n+static_assert (is_copy_assignment (members_of (^^N2::G, gctx)[0]));\n+static_assert (members_of (^^N2::G, gctx)[1] == ^^N2::G::g);\n+static_assert (check_special_members (members_of (^^N2::G, gctx), 3, true, true, true, false, false, true));\n+static_assert (static_data_members_of (^^N2::G, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::G, gctx).size () == 1);\n+static_assert (nonstatic_data_members_of (^^N2::G, gctx)[0] == ^^N2::G::g);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::G, gctx));\n+\n+static_assert (members_of (^^N2::H, gctx).size () == 5);\n+static_assert (members_of (^^N2::H, gctx)[0] == ^^N2::H::h);\n+static_assert (is_move_constructor (members_of (^^N2::H, gctx)[1]));\n+static_assert (check_special_members (members_of (^^N2::H, gctx), 3, false, true, true, true, false, true));\n+static_assert (static_data_members_of (^^N2::H, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::H, gctx).size () == 1);\n+static_assert (nonstatic_data_members_of (^^N2::H, gctx)[0] == ^^N2::H::h);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::H, gctx));\n+\n+static_assert (members_of (^^N2::I, gctx).size () == 6);\n+static_assert (is_move_assignment (members_of (^^N2::I, gctx)[0]));\n+static_assert (members_of (^^N2::I, gctx)[1] == ^^N2::I::i);\n+static_assert (check_special_members (members_of (^^N2::I, gctx), 4, true, true, true, false, true, true));\n+static_assert (static_data_members_of (^^N2::I, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::I, gctx).size () == 1);\n+static_assert (nonstatic_data_members_of (^^N2::I, gctx)[0] == ^^N2::I::i);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::I, gctx));\n+\n+static_assert (members_of (^^N2::J, gctx).size () == 4);\n+static_assert (is_destructor (members_of (^^N2::J, gctx)[0]));\n+static_assert (check_special_members (members_of (^^N2::J, gctx), 3, true, true, true, false, false, true));\n+static_assert (static_data_members_of (^^N2::J, gctx).size () == 0);\n+static_assert (nonstatic_data_members_of (^^N2::J, gctx).size () == 0);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::J, gctx));\n+\n+static_assert (members_of (^^N2::K, gctx).size () == 27);\n+static_assert (members_of (^^N2::K, gctx)[0] == ^^N2::K::a);\n+static_assert (members_of (^^N2::K, gctx)[1] == ^^N2::K::b);\n+static_assert (members_of (^^N2::K, gctx)[2] == ^^N2::K::E);\n+static_assert (members_of (^^N2::K, gctx)[3] == ^^N2::K::c);\n+static_assert (members_of (^^N2::K, gctx)[4] == ^^N2::K::d);\n+static_assert (members_of (^^N2::K, gctx)[5] == ^^N2::K::A);\n+static_assert (members_of (^^N2::K, gctx)[6] == ^^N2::K::foo);\n+static_assert (members_of (^^N2::K, gctx)[7] == ^^N2::K::e);\n+static_assert (members_of (^^N2::K, gctx)[8] == ^^N2::K::f);\n+static_assert (members_of (^^N2::K, gctx)[9] == ^^N2::K::bar);\n+static_assert (members_of (^^N2::K, gctx)[10] == ^^N2::K::g);\n+static_assert (is_bit_field (members_of (^^N2::K, gctx)[11]));\n+static_assert (!has_identifier (members_of (^^N2::K, gctx)[11]));\n+static_assert (bit_size_of (members_of (^^N2::K, gctx)[11]) == 2);\n+static_assert (type_of (members_of (^^N2::K, gctx)[11]) == ^^long);\n+static_assert (is_bit_field (members_of (^^N2::K, gctx)[12]));\n+static_assert (!has_identifier (members_of (^^N2::K, gctx)[12]));\n+static_assert (bit_size_of (members_of (^^N2::K, gctx)[12]) == 0);\n+static_assert (type_of (members_of (^^N2::K, gctx)[12]) == ^^int);\n+static_assert (members_of (^^N2::K, gctx)[13] == ^^N2::K::rXa);\n+static_assert (members_of (^^N2::K, gctx)[14] == ^^N2::K::rXb);\n+static_assert (members_of (^^N2::K, gctx)[15] == ^^N2::K::rXE);\n+static_assert (members_of (^^N2::K, gctx)[16] == ^^N2::K::rXg);\n+static_assert (members_of (^^N2::K, gctx)[17] == ^^N2::K::rYa);\n+static_assert (members_of (^^N2::K, gctx)[18] == ^^N2::K::rYb);\n+static_assert (members_of (^^N2::K, gctx)[19] == ^^N2::K::rYE);\n+static_assert (members_of (^^N2::K, gctx)[20] == ^^N2::K::rYg);\n+static_assert (check_special_members (members_of (^^N2::K, gctx), 6, true, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N2::K, gctx).size () == 9);\n+static_assert (static_data_members_of (^^N2::K, gctx)[0] == ^^N2::K::b);\n+static_assert (static_data_members_of (^^N2::K, gctx)[1] == ^^N2::K::rXa);\n+static_assert (static_data_members_of (^^N2::K, gctx)[2] == ^^N2::K::rXb);\n+static_assert (static_data_members_of (^^N2::K, gctx)[3] == ^^N2::K::rXE);\n+static_assert (static_data_members_of (^^N2::K, gctx)[4] == ^^N2::K::rXg);\n+static_assert (static_data_members_of (^^N2::K, gctx)[5] == ^^N2::K::rYa);\n+static_assert (static_data_members_of (^^N2::K, gctx)[6] == ^^N2::K::rYb);\n+static_assert (static_data_members_of (^^N2::K, gctx)[7] == ^^N2::K::rYE);\n+static_assert (static_data_members_of (^^N2::K, gctx)[8] == ^^N2::K::rYg);\n+static_assert (nonstatic_data_members_of (^^N2::K, gctx).size () == 2);\n+static_assert (nonstatic_data_members_of (^^N2::K, gctx)[0] == ^^N2::K::a);\n+static_assert (nonstatic_data_members_of (^^N2::K, gctx)[1] == ^^N2::K::g);\n+static_assert (has_inaccessible_nonstatic_data_members (^^N2::K, gctx));\n+static_assert (members_of (^^N2::K, uctx).size () == 53);\n+static_assert (members_of (^^N2::K, uctx)[0] == ^^N2::K::a);\n+static_assert (members_of (^^N2::K, uctx)[1] == ^^N2::K::b);\n+static_assert (members_of (^^N2::K, uctx)[2] == ^^N2::K::E);\n+static_assert (members_of (^^N2::K, uctx)[3] == ^^N2::K::c);\n+static_assert (members_of (^^N2::K, uctx)[4] == ^^N2::K::d);\n+static_assert (members_of (^^N2::K, uctx)[5] == ^^N2::K::A);\n+static_assert (members_of (^^N2::K, uctx)[6] == ^^N2::K::foo);\n+static_assert (members_of (^^N2::K, uctx)[7] == ^^N2::K::e);\n+static_assert (members_of (^^N2::K, uctx)[8] == ^^N2::K::f);\n+static_assert (members_of (^^N2::K, uctx)[9] == ^^N2::K::bar);\n+static_assert (members_of (^^N2::K, uctx)[10] == ^^N2::K::g);\n+static_assert (is_bit_field (members_of (^^N2::K, uctx)[11]));\n+static_assert (!has_identifier (members_of (^^N2::K, uctx)[11]));\n+static_assert (bit_size_of (members_of (^^N2::K, uctx)[11]) == 2);\n+static_assert (type_of (members_of (^^N2::K, uctx)[11]) == ^^long);\n+static_assert (is_bit_field (members_of (^^N2::K, uctx)[12]));\n+static_assert (!has_identifier (members_of (^^N2::K, uctx)[12]));\n+static_assert (bit_size_of (members_of (^^N2::K, uctx)[12]) == 0);\n+static_assert (type_of (members_of (^^N2::K, uctx)[12]) == ^^int);\n+static_assert (members_of (^^N2::K, uctx)[13] == N2::K::rXa);\n+static_assert (members_of (^^N2::K, uctx)[14] == N2::K::rXb);\n+static_assert (members_of (^^N2::K, uctx)[15] == N2::K::rXE);\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[16]) == string_view (\"Xc\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[17]) == string_view (\"Xd\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[18]) == string_view (\"XA\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[19]) == string_view (\"Xfoo\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[20]) == string_view (\"Xe\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[21]) == string_view (\"Xf\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[22]) == string_view (\"Xbar\"));\n+static_assert (members_of (^^N2::K, uctx)[23] == N2::K::rXg);\n+static_assert (is_bit_field (members_of (^^N2::K, uctx)[24]));\n+static_assert (!has_identifier (members_of (^^N2::K, uctx)[24]));\n+static_assert (bit_size_of (members_of (^^N2::K, uctx)[24]) == 4);\n+static_assert (type_of (members_of (^^N2::K, uctx)[24]) == ^^long);\n+static_assert (is_bit_field (members_of (^^N2::K, uctx)[25]));\n+static_assert (!has_identifier (members_of (^^N2::K, uctx)[25]));\n+static_assert (bit_size_of (members_of (^^N2::K, uctx)[25]) == 0);\n+static_assert (type_of (members_of (^^N2::K, uctx)[25]) == ^^int);\n+static_assert (members_of (^^N2::K, uctx)[26] == N2::K::rYa);\n+static_assert (members_of (^^N2::K, uctx)[27] == N2::K::rYb);\n+static_assert (members_of (^^N2::K, uctx)[28] == N2::K::rYE);\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[29]) == string_view (\"Yc\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[30]) == string_view (\"Yd\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[31]) == string_view (\"YA\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[32]) == string_view (\"Yfoo\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[33]) == string_view (\"Ye\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[34]) == string_view (\"Yf\"));\n+static_assert (identifier_of (members_of (^^N2::K, uctx)[35]) == string_view (\"Ybar\"));\n+static_assert (members_of (^^N2::K, uctx)[36] == N2::K::rYg);\n+static_assert (is_bit_field (members_of (^^N2::K, uctx)[37]));\n+static_assert (!has_identifier (members_of (^^N2::K, uctx)[37]));\n+static_assert (bit_size_of (members_of (^^N2::K, uctx)[37]) == 6);\n+static_assert (type_of (members_of (^^N2::K, uctx)[37]) == ^^long);\n+static_assert (is_bit_field (members_of (^^N2::K, uctx)[38]));\n+static_assert (!has_identifier (members_of (^^N2::K, uctx)[38]));\n+static_assert (bit_size_of (members_of (^^N2::K, uctx)[38]) == 0);\n+static_assert (type_of (members_of (^^N2::K, uctx)[38]) == ^^int);\n+static_assert (members_of (^^N2::K, uctx)[39] == ^^N2::K::rXa);\n+static_assert (members_of (^^N2::K, uctx)[40] == ^^N2::K::rXb);\n+static_assert (members_of (^^N2::K, uctx)[41] == ^^N2::K::rXE);\n+static_assert (members_of (^^N2::K, uctx)[42] == ^^N2::K::rXg);\n+static_assert (members_of (^^N2::K, uctx)[43] == ^^N2::K::rYa);\n+static_assert (members_of (^^N2::K, uctx)[44] == ^^N2::K::rYb);\n+static_assert (members_of (^^N2::K, uctx)[45] == ^^N2::K::rYE);\n+static_assert (members_of (^^N2::K, uctx)[46] == ^^N2::K::rYg);\n+static_assert (check_special_members (members_of (^^N2::K, uctx), 6, true, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N2::K, uctx).size () == 11);\n+static_assert (static_data_members_of (^^N2::K, uctx)[0] == ^^N2::K::b);\n+static_assert (static_data_members_of (^^N2::K, uctx)[1] == N2::K::rXb);\n+static_assert (static_data_members_of (^^N2::K, uctx)[2] == N2::K::rYb);\n+static_assert (static_data_members_of (^^N2::K, uctx)[3] == ^^N2::K::rXa);\n+static_assert (static_data_members_of (^^N2::K, uctx)[4] == ^^N2::K::rXb);\n+static_assert (static_data_members_of (^^N2::K, uctx)[5] == ^^N2::K::rXE);\n+static_assert (static_data_members_of (^^N2::K, uctx)[6] == ^^N2::K::rXg);\n+static_assert (static_data_members_of (^^N2::K, uctx)[7] == ^^N2::K::rYa);\n+static_assert (static_data_members_of (^^N2::K, uctx)[8] == ^^N2::K::rYb);\n+static_assert (static_data_members_of (^^N2::K, uctx)[9] == ^^N2::K::rYE);\n+static_assert (static_data_members_of (^^N2::K, uctx)[10] == ^^N2::K::rYg);\n+static_assert (nonstatic_data_members_of (^^N2::K, uctx).size () == 6);\n+static_assert (nonstatic_data_members_of (^^N2::K, uctx)[0] == ^^N2::K::a);\n+static_assert (nonstatic_data_members_of (^^N2::K, uctx)[1] == ^^N2::K::g);\n+static_assert (nonstatic_data_members_of (^^N2::K, uctx)[2] == N2::K::rXa);\n+static_assert (nonstatic_data_members_of (^^N2::K, uctx)[3] == N2::K::rXg);\n+static_assert (nonstatic_data_members_of (^^N2::K, uctx)[4] == N2::K::rYa);\n+static_assert (nonstatic_data_members_of (^^N2::K, uctx)[5] == N2::K::rYg);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::K, uctx));\n+\n+static_assert (members_of (^^N2, gctx).size () == 14);\n+static_assert ((members_of (^^N2, gctx) | filter (is_type) | filter (is_class_type) | to ()).size () == 10);\n+static_assert ((members_of (^^N2, gctx) | filter (is_namespace) | to ()).size () == 3);\n+static_assert ((members_of (^^N2, gctx) | filter (is_namespace_alias) | to ()).size () == 1);\n+static_assert ((members_of (^^N2, gctx) | filter (is_concept) | to ()).size () == 1);\n+\n+namespace N2 {\n+ struct L : public K {\n+ static constexpr auto ctx = access_context::current ();\n+ };\n+ static constexpr auto ctx = L::ctx.via (^^L);\n+}\n+\n+static_assert (members_of (^^N2::K, N2::ctx).size () == 40);\n+static_assert (members_of (^^N2::K, N2::ctx)[0] == ^^N2::K::a);\n+static_assert (members_of (^^N2::K, N2::ctx)[1] == ^^N2::K::b);\n+static_assert (members_of (^^N2::K, N2::ctx)[2] == ^^N2::K::E);\n+static_assert (members_of (^^N2::K, N2::ctx)[3] == ^^N2::K::c);\n+static_assert (members_of (^^N2::K, N2::ctx)[4] == ^^N2::K::d);\n+static_assert (members_of (^^N2::K, N2::ctx)[5] == ^^N2::K::A);\n+static_assert (members_of (^^N2::K, N2::ctx)[6] == ^^N2::K::foo);\n+static_assert (members_of (^^N2::K, N2::ctx)[7] == ^^N2::K::e);\n+static_assert (members_of (^^N2::K, N2::ctx)[8] == ^^N2::K::f);\n+static_assert (members_of (^^N2::K, N2::ctx)[9] == ^^N2::K::bar);\n+static_assert (members_of (^^N2::K, N2::ctx)[10] == ^^N2::K::g);\n+static_assert (is_bit_field (members_of (^^N2::K, N2::ctx)[11]));\n+static_assert (!has_identifier (members_of (^^N2::K, N2::ctx)[11]));\n+static_assert (bit_size_of (members_of (^^N2::K, N2::ctx)[11]) == 2);\n+static_assert (type_of (members_of (^^N2::K, N2::ctx)[11]) == ^^long);\n+static_assert (is_bit_field (members_of (^^N2::K, N2::ctx)[12]));\n+static_assert (!has_identifier (members_of (^^N2::K, N2::ctx)[12]));\n+static_assert (bit_size_of (members_of (^^N2::K, N2::ctx)[12]) == 0);\n+static_assert (type_of (members_of (^^N2::K, N2::ctx)[12]) == ^^int);\n+static_assert (members_of (^^N2::K, N2::ctx)[13] == N2::K::rXa);\n+static_assert (members_of (^^N2::K, N2::ctx)[14] == N2::K::rXb);\n+static_assert (members_of (^^N2::K, N2::ctx)[15] == N2::K::rXE);\n+static_assert (identifier_of (members_of (^^N2::K, N2::ctx)[16]) == string_view (\"Xc\"));\n+static_assert (identifier_of (members_of (^^N2::K, N2::ctx)[17]) == string_view (\"Xd\"));\n+static_assert (identifier_of (members_of (^^N2::K, N2::ctx)[18]) == string_view (\"XA\"));\n+static_assert (identifier_of (members_of (^^N2::K, N2::ctx)[19]) == string_view (\"Xfoo\"));\n+static_assert (identifier_of (members_of (^^N2::K, N2::ctx)[20]) == string_view (\"Xe\"));\n+static_assert (identifier_of (members_of (^^N2::K, N2::ctx)[21]) == string_view (\"Xf\"));\n+static_assert (identifier_of (members_of (^^N2::K, N2::ctx)[22]) == string_view (\"Xbar\"));\n+static_assert (members_of (^^N2::K, N2::ctx)[23] == N2::K::rXg);\n+static_assert (is_bit_field (members_of (^^N2::K, N2::ctx)[24]));\n+static_assert (!has_identifier (members_of (^^N2::K, N2::ctx)[24]));\n+static_assert (bit_size_of (members_of (^^N2::K, N2::ctx)[24]) == 4);\n+static_assert (type_of (members_of (^^N2::K, N2::ctx)[24]) == ^^long);\n+static_assert (is_bit_field (members_of (^^N2::K, N2::ctx)[25]));\n+static_assert (!has_identifier (members_of (^^N2::K, N2::ctx)[25]));\n+static_assert (bit_size_of (members_of (^^N2::K, N2::ctx)[25]) == 0);\n+static_assert (type_of (members_of (^^N2::K, N2::ctx)[25]) == ^^int);\n+static_assert (members_of (^^N2::K, N2::ctx)[26] == ^^N2::K::rXa);\n+static_assert (members_of (^^N2::K, N2::ctx)[27] == ^^N2::K::rXb);\n+static_assert (members_of (^^N2::K, N2::ctx)[28] == ^^N2::K::rXE);\n+static_assert (members_of (^^N2::K, N2::ctx)[29] == ^^N2::K::rXg);\n+static_assert (members_of (^^N2::K, N2::ctx)[30] == ^^N2::K::rYa);\n+static_assert (members_of (^^N2::K, N2::ctx)[31] == ^^N2::K::rYb);\n+static_assert (members_of (^^N2::K, N2::ctx)[32] == ^^N2::K::rYE);\n+static_assert (members_of (^^N2::K, N2::ctx)[33] == ^^N2::K::rYg);\n+static_assert (check_special_members (members_of (^^N2::K, N2::ctx), 6, true, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N2::K, N2::ctx).size () == 10);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[0] == ^^N2::K::b);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[1] == N2::K::rXb);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[2] == ^^N2::K::rXa);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[3] == ^^N2::K::rXb);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[4] == ^^N2::K::rXE);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[5] == ^^N2::K::rXg);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[6] == ^^N2::K::rYa);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[7] == ^^N2::K::rYb);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[8] == ^^N2::K::rYE);\n+static_assert (static_data_members_of (^^N2::K, N2::ctx)[9] == ^^N2::K::rYg);\n+static_assert (nonstatic_data_members_of (^^N2::K, N2::ctx).size () == 4);\n+static_assert (nonstatic_data_members_of (^^N2::K, N2::ctx)[0] == ^^N2::K::a);\n+static_assert (nonstatic_data_members_of (^^N2::K, N2::ctx)[1] == ^^N2::K::g);\n+static_assert (nonstatic_data_members_of (^^N2::K, N2::ctx)[2] == N2::K::rXa);\n+static_assert (nonstatic_data_members_of (^^N2::K, N2::ctx)[3] == N2::K::rXg);\n+static_assert (has_inaccessible_nonstatic_data_members (^^N2::K, N2::ctx));\n+static_assert (members_of (^^N2::L, gctx).size () == 7);\n+static_assert (members_of (^^N2::L, gctx)[0] == ^^N2::L::ctx);\n+static_assert (check_special_members (members_of (^^N2::L, gctx), 6, true, true, true, true, true, true));\n+static_assert (static_data_members_of (^^N2::L, gctx).size () == 1);\n+static_assert (static_data_members_of (^^N2::L, gctx)[0] == ^^N2::L::ctx);\n+static_assert (nonstatic_data_members_of (^^N2::L, gctx).size () == 0);\n+static_assert (!has_inaccessible_nonstatic_data_members (^^N2::L, gctx));\n+\n+static_assert (members_of (^^N2, gctx).size () == 16);\n+static_assert ((members_of (^^N2, gctx) | filter (is_type) | filter (is_class_type) | to ()).size () == 11);\n+static_assert ((members_of (^^N2, gctx) | filter (is_namespace) | to ()).size () == 3);\n+static_assert ((members_of (^^N2, gctx) | filter (is_namespace_alias) | to ()).size () == 1);\n+static_assert ((members_of (^^N2, gctx) | filter (is_concept) | to ()).size () == 1);\n+static_assert ((members_of (^^N2, gctx) | filter (is_variable) | to ()).size () == 1);\n+\n+namespace N3 {\n+ struct A {\n+ union { int a; };\n+ };\n+\n+ struct B {\n+ static int foo (int);\n+ static long foo (long);\n+ static short foo (short);\n+ static int foo (int, int);\n+ static double foo (double, float);\n+ };\n+\n+ template \n+ constexpr bool c = false;\n+\n+ template \n+ constexpr bool c = true;\n+\n+ template \n+ struct C {\n+ void foo () requires (c );\n+ void bar () requires (c );\n+ void baz () requires (c );\n+ };\n+}\n+\n+static_assert (members_of (^^N3::A, gctx).size () == 8);\n+static_assert (is_union_type (members_of (^^N3::A, gctx)[0]));\n+static_assert (!has_identifier (members_of (^^N3::A, gctx)[0]));\n+static_assert (is_nonstatic_data_member (members_of (^^N3::A, gctx)[1]));\n+static_assert (!has_identifier (members_of (^^N3::A, gctx)[1]));\n+static_assert (check_special_members (members_of (^^N3::A, gctx), 6, true, true, true, true, true, true));\n+\n+static_assert (members_of (^^N3::B, gctx).size () == 11);\n+static_assert (is_function (members_of (^^N3::B, gctx)[0]));\n+static_assert (identifier_of (members_of (^^N3::B, gctx)[0]) == \"foo\");\n+static_assert (type_of (members_of (^^N3::B, gctx)[0]) == ^^int (int));\n+static_assert (is_function (members_of (^^N3::B, gctx)[1]));\n+static_assert (identifier_of (members_of (^^N3::B, gctx)[1]) == \"foo\");\n+static_assert (type_of (members_of (^^N3::B, gctx)[1]) == ^^long (long));\n+static_assert (is_function (members_of (^^N3::B, gctx)[2]));\n+static_assert (identifier_of (members_of (^^N3::B, gctx)[2]) == \"foo\");\n+static_assert (type_of (members_of (^^N3::B, gctx)[2]) == ^^short (short));\n+static_assert (is_function (members_of (^^N3::B, gctx)[3]));\n+static_assert (identifier_of (members_of (^^N3::B, gctx)[3]) == \"foo\");\n+static_assert (type_of (members_of (^^N3::B, gctx)[3]) == ^^int (int, int));\n+static_assert (is_function (members_of (^^N3::B, gctx)[4]));\n+static_assert (identifier_of (members_of (^^N3::B, gctx)[4]) == \"foo\");\n+static_assert (type_of (members_of (^^N3::B, gctx)[4]) == ^^double (double, float));\n+static_assert (check_special_members (members_of (^^N3::B, gctx), 6, true, true, true, true, true, true));\n+\n+static_assert (members_of (^^N3::C , gctx).size () == 7);\n+static_assert (is_function (members_of (^^N3::C , gctx)[0]));\n+static_assert (identifier_of (members_of (^^N3::C , gctx)[0]) == \"foo\");\n+static_assert (check_special_members (members_of (^^N3::C , gctx), 6, true, true, true, true, true, true));\n+static_assert (members_of (^^N3::C , gctx).size () == 8);\n+static_assert (is_function (members_of (^^N3::C , gctx)[0]));\n+static_assert (identifier_of (members_of (^^N3::C , gctx)[0]) == \"bar\");\n+static_assert (is_function (members_of (^^N3::C , gctx)[1]));\n+static_assert (identifier_of (members_of (^^N3::C , gctx)[1]) == \"baz\");\n+static_assert (check_special_members (members_of (^^N3::C , gctx), 6, true, true, true, true, true, true));\n+static_assert (members_of (^^N3::C , gctx).size () == 6);\n+static_assert (check_special_members (members_of (^^N3::C , gctx), 6, true, true, true, true, true, true));\ndiff --git a/gcc/testsuite/g++.dg/reflect/members_of2.C b/gcc/testsuite/g++.dg/reflect/members_of2.C\nnew file mode 100644\nindex 00000000000..cbf155c6faa\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/members_of2.C\n@@ -0,0 +1,58 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::members_of.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+namespace N1\n+{\n+ void foo (int);\n+ void foo (long);\n+ void foo (double);\n+ void foo (long);\n+ void foo (int);\n+ void foo (float);\n+}\n+\n+namespace N2\n+{\n+ struct A {};\n+ int A;\n+ int B;\n+ struct B {};\n+}\n+\n+namespace N3\n+{\n+ struct A {};\n+ void A (int);\n+ void A (long);\n+ void B (int);\n+ void B (long);\n+ struct B {};\n+}\n+\n+namespace N4\n+{\n+ static union { int a; };\n+}\n+\n+static constexpr auto ctx = access_context::current ();\n+static_assert (members_of (^^N1, ctx).size () == 4);\n+static_assert ((members_of (^^N1, ctx) | std::views::filter (is_function) | std::ranges::to ()).size () == 4);\n+static_assert ((members_of (^^N1, ctx) | std::views::filter (has_identifier) | std::ranges::to ()).size () == 4);\n+static_assert (members_of (^^N2, ctx).size () == 4);\n+static_assert ((members_of (^^N2, ctx) | std::views::filter (is_variable) | std::ranges::to ()).size () == 2);\n+static_assert ((members_of (^^N2, ctx) | std::views::filter (is_type) | std::ranges::to ()).size () == 2);\n+static_assert ((members_of (^^N2, ctx) | std::views::filter (has_identifier) | std::ranges::to ()).size () == 4);\n+static_assert (members_of (^^N3, ctx).size () == 6);\n+static_assert ((members_of (^^N3, ctx) | std::views::filter (is_function) | std::ranges::to ()).size () == 4);\n+static_assert ((members_of (^^N3, ctx) | std::views::filter (is_type) | std::ranges::to ()).size () == 2);\n+static_assert ((members_of (^^N3, ctx) | std::views::filter (has_identifier) | std::ranges::to ()).size () == 6);\n+static_assert (members_of (^^N4, ctx).size () == 2);\n+static_assert ((members_of (^^N4, ctx) | std::views::filter (is_variable) | std::ranges::to ()).size () == 1);\n+static_assert ((members_of (^^N4, ctx) | std::views::filter (is_type) | std::views::filter (is_union_type) | std::ranges::to ()).size () == 1);\n+static_assert ((members_of (^^N4, ctx) | std::views::filter (has_identifier) | std::ranges::to ()).size () == 0);\ndiff --git a/gcc/testsuite/g++.dg/reflect/members_of3.C b/gcc/testsuite/g++.dg/reflect/members_of3.C\nnew file mode 100644\nindex 00000000000..2ee9f468e5c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/members_of3.C\n@@ -0,0 +1,49 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::members_of.\n+\n+#include \n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+struct A {\n+ int i;\n+ template int &get () { return i; }\n+};\n+\n+template <>\n+struct std::tuple_size \n+{\n+ static const int value = 4;\n+};\n+\n+template \n+struct std::tuple_element \n+{\n+ using type = int;\n+};\n+\n+int arr[4];\n+\n+namespace N1\n+{\n+ auto [x, y, z, w] = arr;\n+}\n+\n+namespace N2\n+{\n+ auto [x, y, z, w] = A {};\n+}\n+\n+static constexpr auto ctx = access_context::current ();\n+static_assert (members_of (^^N1, ctx).size () == 1);\n+static_assert (is_variable (members_of (^^N1, ctx)[0]));\n+static_assert (!has_identifier (members_of (^^N1, ctx)[0]));\n+static_assert (type_of (members_of (^^N1, ctx)[0]) == ^^int [4]);\n+static_assert (!is_structured_binding (members_of (^^N1, ctx)[0]));\n+static_assert (members_of (^^N2, ctx).size () == 5);\n+static_assert ((members_of (^^N2, ctx) | std::views::filter (is_variable) | std::ranges::to ()).size () == 5);\n+static_assert ((members_of (^^N2, ctx) | std::views::filter (has_identifier) | std::ranges::to ()).size () == 4);\n+static_assert ((members_of (^^N2, ctx) | std::views::filter (is_structured_binding) | std::ranges::to ()).size () == 0);\ndiff --git a/gcc/testsuite/g++.dg/reflect/members_of4.C b/gcc/testsuite/g++.dg/reflect/members_of4.C\nnew file mode 100644\nindex 00000000000..7c843a81db8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/members_of4.C\n@@ -0,0 +1,21 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::members_of.\n+\n+#include \n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+auto l1 = [] (int x) {};\n+auto l2 = [] (auto x) {};\n+auto l3 = [] (int x) static {};\n+auto l4 = [] (auto x) static {};\n+\n+static constexpr auto ctx = access_context::current ();\n+// FIXME these two should pass, call operator is guaranteed\n+// static_assert (std::ranges::distance (members_of (type_of (^^l1), ctx) | std::views::filter (is_operator_function)) >= 1);\n+static_assert (std::ranges::distance (members_of (type_of (^^l2), ctx) | std::views::filter (is_operator_function_template)) >= 1);\n+// static_assert (std::ranges::distance (members_of (type_of (^^l3), ctx) | std::views::filter (is_operator_function)) >= 1);\n+static_assert (std::ranges::distance (members_of (type_of (^^l4), ctx) | std::views::filter (is_operator_function_template)) >= 1);\ndiff --git a/gcc/testsuite/g++.dg/reflect/members_of5.C b/gcc/testsuite/g++.dg/reflect/members_of5.C\nnew file mode 100644\nindex 00000000000..5653339dbc1\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/members_of5.C\n@@ -0,0 +1,102 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::members_of.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+template\n+consteval bool\n+has_mem(info clazz, F f)\n+{\n+ for (info x : members_of(clazz, access_context::unchecked()))\n+ if (f(x))\n+ return true;\n+ return false;\n+}\n+\n+consteval auto is_operator(operators op)\n+{ return [op](info mem) { return is_operator_function(mem) && operator_of(mem) == op; }; }\n+\n+struct ExplicitDef\n+{\n+ ExplicitDef() = default;\n+ ExplicitDef(const ExplicitDef&) = default;\n+ ExplicitDef(ExplicitDef&&) = default;\n+\n+ ExplicitDef& operator=(const ExplicitDef&) = default;\n+ ExplicitDef& operator=(ExplicitDef&&) = default;\n+ \n+ ~ExplicitDef() = default;\n+};\n+\n+static_assert (has_mem (^^ExplicitDef, is_default_constructor));\n+static_assert (has_mem (^^ExplicitDef, is_copy_constructor));\n+static_assert (has_mem (^^ExplicitDef, is_move_constructor));\n+static_assert (has_mem (^^ExplicitDef, is_copy_assignment));\n+static_assert (has_mem (^^ExplicitDef, is_move_assignment));\n+static_assert (has_mem (^^ExplicitDef, is_destructor));\n+static_assert (!has_mem (^^ExplicitDef, is_operator(op_equals_equals)));\n+static_assert (!has_mem (^^ExplicitDef, is_operator(op_spaceship)));\n+\n+struct NoMoveDecl\n+{\n+ NoMoveDecl() = default;\n+ NoMoveDecl(const NoMoveDecl&) = default;\n+\n+ NoMoveDecl& operator=(const NoMoveDecl&) = default;\n+ \n+ ~NoMoveDecl() = default;\n+};\n+\n+static_assert (has_mem (^^NoMoveDecl, is_default_constructor));\n+static_assert (has_mem (^^NoMoveDecl, is_copy_constructor));\n+static_assert (!has_mem (^^NoMoveDecl, is_move_constructor));\n+static_assert (has_mem (^^NoMoveDecl, is_copy_assignment));\n+static_assert (!has_mem (^^NoMoveDecl, is_move_assignment));\n+static_assert (has_mem (^^NoMoveDecl, is_destructor));\n+static_assert (!has_mem (^^NoMoveDecl, is_operator(op_equals_equals)));\n+static_assert (!has_mem (^^NoMoveDecl, is_operator(op_spaceship)));\n+\n+struct ImplicitDef\n+{\n+};\n+\n+static_assert (has_mem (^^ImplicitDef, is_default_constructor));\n+static_assert (has_mem (^^ImplicitDef, is_copy_constructor));\n+static_assert (has_mem (^^ImplicitDef, is_move_constructor));\n+static_assert (has_mem (^^ImplicitDef, is_copy_assignment));\n+static_assert (has_mem (^^ImplicitDef, is_move_assignment));\n+static_assert (has_mem (^^ImplicitDef, is_destructor));\n+static_assert (!has_mem (^^ImplicitDef, is_operator(op_equals_equals)));\n+static_assert (!has_mem (^^ImplicitDef, is_operator(op_spaceship)));\n+\n+struct ExplicitRelOps\n+{\n+ bool operator==(const ExplicitRelOps&) const = default;\n+ auto operator<=>(const ExplicitRelOps&) const = default;\n+};\n+ExplicitRelOps a,b;\n+static_assert (has_mem (^^ExplicitRelOps, is_operator(op_equals_equals)));\n+// FIXME, below check fails without this use\n+auto r = a <=> b;\n+static_assert (has_mem (^^ExplicitRelOps, is_operator(op_spaceship)));\n+\n+struct NoEqualDecl\n+{\n+ auto operator<=>(const NoEqualDecl&) const\n+ { return std::strong_ordering::equal; }\n+};\n+static_assert (!has_mem (^^NoEqualDecl, is_operator(op_equals_equals)));\n+static_assert (has_mem (^^NoEqualDecl, is_operator(op_spaceship)));\n+\n+struct ImplicitRelOps\n+{\n+ // operator== is implicitly declared\n+ auto operator<=>(const ImplicitRelOps&) const = default;\n+};\n+// FIXME crash\n+// static_assert (has_mem (^^ImplicitRelOps, is_operator(op_equals_equals)));\n+// static_assert (has_mem (^^ImplicitRelOps, is_operator(op_spaceship)));\ndiff --git a/gcc/testsuite/g++.dg/reflect/members_of6.C b/gcc/testsuite/g++.dg/reflect/members_of6.C\nnew file mode 100644\nindex 00000000000..fa72c9e97af\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/members_of6.C\n@@ -0,0 +1,34 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::members_of.\n+\n+#include \n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+struct S\n+{\n+ auto operator <=> (const S &) const = default;\n+};\n+\n+struct T\n+{\n+ auto operator <=> (this T, T) = default;\n+ auto operator <=> (this const T &, const T &) = default;\n+};\n+\n+constexpr access_context uctx = access_context::unchecked ();\n+\n+static_assert (members_of (^^S, uctx).size () == 8);\n+static_assert (operator_of (members_of (^^T, uctx)[0]) == op_spaceship);\n+static_assert ((members_of (^^S, uctx) | std::views::drop (1) | std::views::filter (is_special_member_function) | std::views::filter (is_defaulted) | std::ranges::to ()).size () == 6);\n+static_assert ((members_of (^^S, uctx) | std::views::drop (1) | std::views::filter (is_operator_function) | std::views::filter (is_defaulted) | std::ranges::to ()).size () == 3);\n+// TODO: Shouldn't the above have 2 implicitly-declared equality\n+// operators?\n+static_assert (members_of (^^T, uctx).size () == 9);\n+static_assert (operator_of (members_of (^^T, uctx)[0]) == op_spaceship);\n+static_assert (operator_of (members_of (^^T, uctx)[1]) == op_spaceship);\n+static_assert ((members_of (^^T, uctx) | std::views::drop (2) | std::views::filter (is_special_member_function) | std::views::filter (is_defaulted) | std::ranges::to ()).size () == 6);\n+static_assert ((members_of (^^T, uctx) | std::views::drop (2) | std::views::filter (is_operator_function) | std::views::filter (is_defaulted) | std::ranges::to ()).size () == 3);\ndiff --git a/gcc/testsuite/g++.dg/reflect/members_of7.C b/gcc/testsuite/g++.dg/reflect/members_of7.C\nnew file mode 100644\nindex 00000000000..54024055f2d\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/members_of7.C\n@@ -0,0 +1,32 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::members_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr access_context uctx = access_context::unchecked ();\n+\n+namespace N\n+{\n+}\n+\n+consteval std::size_t\n+foo ()\n+{\n+ return members_of (^^N, uctx).size ();\n+}\n+\n+namespace N\n+{\n+ static_assert (foo () == 0);\n+ int a;\n+ static_assert (foo () == 1);\n+ void bar (int);\n+ static_assert (foo () == 2);\n+ void baz (long);\n+ static_assert (foo () == 3);\n+ void baz (short, float);\n+ static_assert (foo () == 4);\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/metafn-ptr1.C b/gcc/testsuite/g++.dg/reflect/metafn-ptr1.C\nnew file mode 100644\nindex 00000000000..271063c5f72\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/metafn-ptr1.C\n@@ -0,0 +1,19 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Try to invoke a metafunction through a function pointer.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+consteval size_t\n+invoke (size_t (*fp)(info))\n+{\n+ return fp (^^int);\n+}\n+\n+void\n+g ()\n+{\n+ static_assert (invoke (size_of) == sizeof (int));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/ns1.C b/gcc/testsuite/g++.dg/reflect/ns1.C\nnew file mode 100644\nindex 00000000000..280c288af9d\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/ns1.C\n@@ -0,0 +1,37 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflections on namespaces.\n+\n+constexpr auto glob = ^^::;\n+\n+namespace Q { }\n+constexpr auto q = ^^Q;\n+namespace Q { }\n+static_assert (q == ^^Q);\n+\n+namespace A { namespace B { using C = int; } }\n+constexpr auto r = ^^A::B::C &;\n+\n+namespace N {\n+ using T = int;\n+ namespace M {\n+ using TT = int;\n+ }\n+}\n+\n+void\n+f1 ()\n+{\n+ constexpr auto n = ^^N;\n+ [: n :]::T i = 42;\n+ typename [: n :]::T it = 42;\n+\n+ constexpr auto t = ^^N::T;\n+ typename [: t :] j = 42;\n+\n+ constexpr auto m = ^^N::M;\n+ [: m :]::TT k = 42;\n+ typename [: m :]::TT kt = 42;\n+\n+ constexpr auto m2 = ^^t;\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/ns2.C b/gcc/testsuite/g++.dg/reflect/ns2.C\nnew file mode 100644\nindex 00000000000..482b8754713\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/ns2.C\n@@ -0,0 +1,21 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflections on namespaces. Invalid stuff.\n+\n+void foo (int);\n+\n+namespace N {\n+}\n+\n+void\n+f1 ()\n+{\n+ constexpr auto r = ^^::;\n+ [: r :] foo (0); // { dg-error \"expected\" }\n+\n+ constexpr auto q = ^^int;\n+ [: q :]::T x; // { dg-error \"reflection not usable in a splice scope|expected\" }\n+ // { dg-message \".int. is not a class, namespace, or enumeration\" \"\" { target *-*-* } .-1 }\n+\n+ constexpr auto x = ^^N::X; // { dg-error \".N::X. has not been declared\" }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/ns3.C b/gcc/testsuite/g++.dg/reflect/ns3.C\nnew file mode 100644\nindex 00000000000..4d810ebbd17\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/ns3.C\n@@ -0,0 +1,15 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test dependent namespaces.\n+\n+using info = decltype(^^int);\n+\n+template int fn() {\n+ return [:R:]::v;\n+}\n+\n+namespace NS {\n+ int v = 1;\n+}\n+\n+int a = fn<^^NS>();\ndiff --git a/gcc/testsuite/g++.dg/reflect/ns4.C b/gcc/testsuite/g++.dg/reflect/ns4.C\nnew file mode 100644\nindex 00000000000..7d03d826035\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/ns4.C\n@@ -0,0 +1,94 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test dependent namespaces in typenames.\n+\n+using info = decltype(^^void);\n+\n+namespace N {\n+ struct A { int i; using Q = int; };\n+ template\n+ struct B { T t; };\n+ static int glob;\n+ using U = int;\n+ int foo (int i) { return i; }\n+ template\n+ T baz (T t) { return t; }\n+ template\n+ constexpr T pi = 3.14;\n+\n+ namespace M {\n+ struct C { int i; };\n+ template\n+ struct D { T t; };\n+ int mglob;\n+ using V = int;\n+ void bar () { }\n+ template\n+ T qux (T t) { return t; }\n+ template\n+ constexpr T pi2 = 3.14;\n+ }\n+}\n+\n+template\n+void\n+f ()\n+{\n+ typename [:R:]::A a{1};\n+ typename[:R:]::template B b{1};\n+ typename [:R:]::A::Q i1;\n+ typename [:R:]::U u;\n+ [:R:]::M::bar ();\n+ [:R:]::M::mglob++;\n+ typename [:R:]::M::V i2;\n+ typename [:R:]::M::C c{1};\n+ typename [:R:]::M::template D d{1};\n+\n+ // Not a TYPENAME_TYPE, but let's test it.\n+ [:R:]::template baz(42);\n+ double d1 = [:R:]::template pi;\n+ int i3 = [:R:]::foo (42);\n+ [:R:]::glob++;\n+ [:R:]::M::template qux(42);\n+ double d2 = [:R:]::M::template pi2;\n+}\n+\n+template\n+void\n+g ()\n+{\n+ typename [:R:]::C c{1};\n+ typename [:R:]::template D d{1};\n+ [:R:]::mglob++;\n+ typename [:R:]::V v;\n+ [:R:]::bar ();\n+ [:R:]::template qux(42);\n+ double d2 = [:R:]::template pi2;\n+}\n+\n+template\n+void\n+bad ()\n+{\n+ typename [:R:]::NOTHERE x; // { dg-error \".NOTHERE. is not a member of .N.\" }\n+ typename [:R:]::M::NOTHERE y; // { dg-error \".NOTHERE. is not a member of .N::M.\" }\n+}\n+\n+template\n+struct E {\n+ typename [:R:]::A a;\n+ typename[:R:]::template B b;\n+ typename [:R:]::U u;\n+ typename [:R:]::M::V v;\n+ typename [:R:]::M::C c{1};\n+ typename [:R:]::M::template D d{1};\n+};\n+\n+void\n+doit ()\n+{\n+ f<^^N>();\n+ bad<^^N>();\n+ E<^^N> e;\n+ g<^^N::M>();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/ns5.C b/gcc/testsuite/g++.dg/reflect/ns5.C\nnew file mode 100644\nindex 00000000000..236b2927453\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/ns5.C\n@@ -0,0 +1,45 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^void);\n+\n+template\n+void foo () { }\n+void bar () { }\n+namespace N { }\n+namespace M = N;\n+template\n+T vt{};\n+template\n+concept C = true;\n+static int i;\n+enum E { X };\n+struct S { static int si; };\n+template\n+struct D { static T di; };\n+template\n+using Z = D;\n+\n+template void fn1 () { typename [:R:]::X x; }\t// { dg-error \"not usable in a splice scope\" }\n+template void fn2 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn3 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn4 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn5 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn6 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn7 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn8 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn9 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn10 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+template void fn11 () { typename [:R:]::X x; } // { dg-error \"not usable in a splice scope\" }\n+\n+template void fn1<^^foo>(); // { dg-message \"required from here\" }\n+template void fn2<^^foo>();\t // { dg-message \"required from here\" }\n+template void fn3<^^bar>();\t // { dg-message \"required from here\" }\n+template void fn4<^^vt>(); // { dg-message \"required from here\" }\n+template void fn5<^^vt>();\t // { dg-message \"required from here\" }\n+template void fn6<^^C>();\t // { dg-message \"required from here\" }\n+template void fn7<^^i>();\t // { dg-message \"required from here\" }\n+template void fn8<^^X>();\t // { dg-message \"required from here\" }\n+template void fn9<^^S::si>();\t // { dg-message \"required from here\" }\n+template void fn10<^^D::di>(); // { dg-message \"required from here\" }\n+template void fn11<^^Z>();\t // { dg-message \"required from here\" }\ndiff --git a/gcc/testsuite/g++.dg/reflect/ns6.C b/gcc/testsuite/g++.dg/reflect/ns6.C\nnew file mode 100644\nindex 00000000000..6eb6e35f436\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/ns6.C\n@@ -0,0 +1,17 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+namespace N { void foo (); }\n+\n+// P2996 doesn't allow this.\n+namespace [:^^N:] { } // { dg-error \"expected\" }\n+\n+// But this is fine.\n+namespace A = [:^^N:];\n+using namespace [:^^A:];\n+\n+void\n+g ()\n+{\n+ foo ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/null1.C b/gcc/testsuite/g++.dg/reflect/null1.C\nnew file mode 100644\nindex 00000000000..58eaa09d13b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/null1.C\n@@ -0,0 +1,30 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test null reflection.\n+\n+#include \n+\n+struct S {};\n+\n+static_assert(std::meta::info() == std::meta::info());\n+static_assert(std::meta::info{} == std::meta::info{});\n+static_assert(std::meta::info() != ^^S);\n+static_assert(std::meta::info{} != ^^S);\n+\n+constexpr std::meta::info g;\n+constexpr std::meta::info g2{};\n+static_assert(g == std::meta::info());\n+static_assert(g == g2);\n+constexpr std::meta::info *g3{};\n+constexpr std::meta::info *g4{};\n+\n+consteval void\n+f ()\n+{\n+ std::meta::info m;\n+ std::meta::info m2{};\n+ static std::meta::info m3;\n+ static std::meta::info m4{};\n+ static constexpr std::meta::info m5;\n+ static constexpr std::meta::info m6{};\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/null2.C b/gcc/testsuite/g++.dg/reflect/null2.C\nnew file mode 100644\nindex 00000000000..73b4ce4cff8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/null2.C\n@@ -0,0 +1,7 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Here, x is a null reflection so should be allowed to compare equal\n+// to itself. meta::info should be const-default-constructible.\n+\n+constexpr decltype(^^::) x;\n+static_assert(x == x);\ndiff --git a/gcc/testsuite/g++.dg/reflect/null3.C b/gcc/testsuite/g++.dg/reflect/null3.C\nnew file mode 100644\nindex 00000000000..2fbd7cc8368\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/null3.C\n@@ -0,0 +1,9 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test null reflection.\n+\n+using info = decltype(^^int);\n+consteval info foo () { return {}; }\n+static_assert (foo () == info ());\n+consteval auto bar () { return info{}; }\n+static_assert (bar () == info ());\ndiff --git a/gcc/testsuite/g++.dg/reflect/null4.C b/gcc/testsuite/g++.dg/reflect/null4.C\nnew file mode 100644\nindex 00000000000..28e6972da98\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/null4.C\n@@ -0,0 +1,18 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test null reflection.\n+\n+using info = decltype(^^int);\n+\n+struct S {\n+ info i = {};\n+};\n+\n+static_assert (S{}.i == info ());\n+\n+struct Q {\n+ info i;\n+ consteval Q() : i{} {}\n+};\n+\n+static_assert (Q{}.i == info ());\ndiff --git a/gcc/testsuite/g++.dg/reflect/null5.C b/gcc/testsuite/g++.dg/reflect/null5.C\nnew file mode 100644\nindex 00000000000..f768a482f9b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/null5.C\n@@ -0,0 +1,26 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test null reflection.\n+\n+using info = decltype(^^int);\n+\n+inline constexpr info Ag {};\n+\n+consteval info return_null() {\n+ return info{};\n+}\n+\n+template \n+struct S {\n+ static constexpr info Bt {^^::};\n+ static constexpr info Ct {};\n+ static constexpr info Dt = return_null();\n+};\n+\n+template struct S;\n+\n+int main() {\n+ template for (auto _ : {0}) {\n+ constexpr info A {};\n+ }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/object_of1.C b/gcc/testsuite/g++.dg/reflect/object_of1.C\nnew file mode 100644\nindex 00000000000..37b2a5f0fc3\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/object_of1.C\n@@ -0,0 +1,85 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::object_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+int x;\n+int& y = x;\n+\n+static_assert (^^x != ^^y);\n+static_assert (object_of (^^x) == object_of (^^y));\n+static_assert (is_object (object_of (^^x)));\n+static_assert (is_object (object_of (^^y)));\n+\n+constexpr int i = 1;\n+static_assert (object_of (^^i) == reflect_object (i));\n+static_assert (is_object (object_of (^^i)));\n+\n+constexpr const int *p = &i;\n+constexpr auto ro = object_of (^^p);\n+static_assert (^^p != ro);\n+static_assert (!is_variable (ro));\n+static_assert (is_object (ro));\n+static_assert (!is_value (ro));\n+static_assert (ro == reflect_object (p));\n+static_assert (ro != reflect_constant (&i));\n+\n+void\n+g ()\n+{\n+ constexpr int &r = x;\n+ constexpr auto r1 = object_of (^^r);\n+ static_assert (is_object (object_of (^^r)));\n+ static int sl = 42;\n+ constexpr auto r2 = object_of (^^sl);\n+ static_assert (is_object (object_of (^^sl)));\n+}\n+\n+const int &rc = 42;\n+// Here, object_of yields _ZGR2rc_.\n+static_assert (object_of (^^rc) != reflect_constant (42));\n+static_assert (!is_variable (object_of (^^rc)));\n+static_assert (is_object (object_of (^^rc)));\n+static_assert (!is_value (object_of (^^rc)));\n+\n+struct A { const int ci = 0; int nci; };\n+struct B : A { mutable int i; };\n+\n+B arr[2];\n+static_assert (object_of (^^arr) != ^^arr);\n+static_assert (is_object (object_of (^^arr)));\n+static_assert (reflect_object (arr) == object_of (^^arr));\n+static_assert (reflect_object (arr[0]) != object_of (^^arr));\n+static_assert (type_of (object_of (^^arr)) == ^^B[2]);\n+\n+const A &r = arr[1];\n+static_assert (object_of (^^r) != ^^r);\n+static_assert (is_object (object_of (^^r)));\n+static_assert (reflect_object (arr[1]) != object_of (^^r));\n+// TODO Fails because the array index has types long int x int.\n+//static_assert (reflect_object (static_cast(arr[1])) == object_of (^^r));\n+static_assert (type_of (^^r) == ^^const A&);\n+static_assert (type_of (object_of (^^r)) == ^^A);\n+\n+struct S { int i; } s;\n+static_assert (object_of (^^s) != ^^s);\n+static_assert (is_object (object_of (^^s)));\n+static_assert (reflect_object (s) == object_of (^^s));\n+static_assert (type_of (object_of (^^s)) == ^^S);\n+\n+template\n+struct X { };\n+constexpr auto T = ^^X<1, x, S{}>;\n+constexpr auto o1 = object_of (template_arguments_of (T)[1]);\n+constexpr auto o2 = object_of (template_arguments_of (T)[2]);\n+static_assert (is_object (o1));\n+static_assert (is_object (o2));\n+static_assert (o1 == template_arguments_of (T)[1]);\n+static_assert (o2 == template_arguments_of (T)[2]);\n+static_assert (o1 == reflect_object (x));\n+static_assert (type_of (o1) == ^^int);\n+// ??? May not be true.\n+static_assert (type_of (o2) == ^^const S);\ndiff --git a/gcc/testsuite/g++.dg/reflect/object_of2.C b/gcc/testsuite/g++.dg/reflect/object_of2.C\nnew file mode 100644\nindex 00000000000..8737764bd9c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/object_of2.C\n@@ -0,0 +1,26 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::object_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+void fn ();\n+constexpr auto r1 = object_of (reflect_constant (3)); // { dg-error \"uncaught exception\" }\n+constexpr auto r2 = object_of (^^fn); // { dg-error \"uncaught exception\" }\n+\n+static int G;\n+\n+void\n+f (int p)\n+{\n+ int i = 42;\n+ constexpr auto r3 = object_of (^^p); // { dg-error \"uncaught exception\" }\n+ constexpr auto r4 = object_of (^^i); // { dg-error \"uncaught exception\" }\n+}\n+\n+template\n+struct X { };\n+constexpr auto T = ^^X<1>;\n+constexpr auto o = object_of (template_arguments_of (T)[0]); // { dg-error \"uncaught exception\" }\ndiff --git a/gcc/testsuite/g++.dg/reflect/odr1.C b/gcc/testsuite/g++.dg/reflect/odr1.C\nnew file mode 100644\nindex 00000000000..7678d65149e\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/odr1.C\n@@ -0,0 +1,29 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^void);\n+\n+template\n+void\n+f ()\n+{\n+ [:val:];\t // { dg-error \"use of local variable with automatic storage from containing function\" }\n+ [:val:] = {};\t // { dg-error \"use of local variable with automatic storage from containing function\" }\n+ /* This is ill-formed because:\n+ - the splice-expression designates b,\n+ - the splice-expression names b ([basic.def.odr]/5),\n+ - the splice-expression odr-uses b ([basic.def.odr]/5),\n+ - however, the local entity b is not odr-usable from the scope inhabited\n+ by the splice-expression ([basic.def.odr]/10.2). Since the local\n+ entity b is odr-used within a scope where b is not odr-usable,\n+ the program is ill-formed (also [basic.def.odr]/10). */\n+ [:val:] z; // { dg-error \"use of local variable with automatic storage from containing function|expected\" }\n+ float a = [:val:]; // { dg-error \"use of local variable with automatic storage from containing function\" }\n+}\n+\n+void\n+g ()\n+{\n+ float b = 2.5f;\n+ f<^^b>();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/offset_of1.C b/gcc/testsuite/g++.dg/reflect/offset_of1.C\nnew file mode 100644\nindex 00000000000..41f5c71d6c3\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/offset_of1.C\n@@ -0,0 +1,132 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::offset_of.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+int arr[] = {1, 2, 3};\n+auto [a1, a2, a3] = arr;\n+void fn();\n+auto &fn2();\n+enum Enum { A };\n+using Alias = int;\n+struct B {};\n+struct S : B {\n+ int mem;\n+ int : 0;\n+};\n+struct T {\n+ T ();\n+ T (const T &);\n+ ~T ();\n+};\n+struct U {\n+ int u;\n+};\n+template struct TCls {};\n+template void TFn();\n+template int TVar;\n+template concept Concept = requires { true; };\n+namespace NS {};\n+namespace NSAlias = NS;\n+\n+constexpr auto ctx = std::meta::access_context::current ();\n+\n+consteval bool\n+has_offset_of (info r)\n+{\n+ try { offset_of (r); }\n+ catch (std::meta::exception &) { return false; }\n+ return true;\n+}\n+\n+static_assert (!has_offset_of (std::meta::reflect_constant (42)));\n+static_assert (!has_offset_of (std::meta::reflect_object (arr[1])));\n+static_assert (!has_offset_of (^^arr));\n+static_assert (!has_offset_of (^^a3));\n+static_assert (!has_offset_of (^^fn));\n+static_assert (!has_offset_of (^^fn2));\n+static_assert (!has_offset_of (^^Enum::A));\n+static_assert (!has_offset_of (^^Alias));\n+static_assert (!has_offset_of (^^S));\n+static_assert (has_offset_of (^^S::mem));\n+static_assert (has_offset_of (std::meta::members_of (^^S, ctx)[1]));\n+static_assert (!has_offset_of (^^TCls));\n+static_assert (!has_offset_of (^^TFn));\n+static_assert (!has_offset_of (^^TVar));\n+static_assert (!has_offset_of (^^Concept));\n+static_assert (!has_offset_of (^^NSAlias));\n+static_assert (!has_offset_of (^^NS));\n+static_assert (has_offset_of (std::meta::bases_of (^^S, ctx)[0]));\n+static_assert (!has_offset_of (std::meta::data_member_spec (^^int, { .name = \"member\" })));\n+void bar (long, const T f, int g[2], T &);\n+\n+int\n+foo (int a, const long b, T c, int d[4], T &e)\n+{\n+ static_assert (!has_offset_of (^^a));\n+ static_assert (!has_offset_of (^^b));\n+ static_assert (!has_offset_of (^^c));\n+ static_assert (!has_offset_of (^^d));\n+ static_assert (!has_offset_of (^^e));\n+ static_assert (!has_offset_of (parameters_of (^^foo)[0]));\n+ static_assert (!has_offset_of (parameters_of (^^bar)[0]));\n+ return 0;\n+}\n+\n+struct V\n+{\n+ char a;\n+ short b;\n+ char c;\n+ int d;\n+ char e;\n+ long long f;\n+ int : 2;\n+ int g : 3;\n+ union {\n+ int h;\n+ long i;\n+ };\n+};\n+\n+union W\n+{\n+ int a;\n+ double b;\n+};\n+\n+static_assert (offset_of (^^V::a).bytes == offsetof (V, a));\n+static_assert (offset_of (^^V::a).bits == 0);\n+static_assert (offset_of (^^V::b).bytes == offsetof (V, b));\n+static_assert (offset_of (^^V::b).bits == 0);\n+static_assert (offset_of (^^V::c).bytes == offsetof (V, c));\n+static_assert (offset_of (^^V::c).bits == 0);\n+static_assert (offset_of (^^V::d).bytes == offsetof (V, d));\n+static_assert (offset_of (^^V::d).bits == 0);\n+static_assert (offset_of (^^V::e).bytes == offsetof (V, e));\n+static_assert (offset_of (^^V::e).bits == 0);\n+static_assert (offset_of (^^V::f).bytes == offsetof (V, f));\n+static_assert (offset_of (^^V::f).bits == 0);\n+static_assert (offset_of (^^V::g).bytes == offsetof (V, f) + sizeof (long long));\n+static_assert (offset_of (^^V::g).bits == 2);\n+static_assert (offset_of (^^V::h).bytes == 0);\n+static_assert (offset_of (^^V::h).bits == 0);\n+static_assert (offset_of (^^V::i).bytes == 0);\n+static_assert (offset_of (^^V::i).bits == 0);\n+static_assert (offset_of (^^W::a).bytes == 0);\n+static_assert (offset_of (^^W::a).bits == 0);\n+static_assert (offset_of (^^W::b).bytes == 0);\n+static_assert (offset_of (^^W::b).bits == 0);\n+static_assert (offset_of (^^V::f) < offset_of (^^V::g));\n+static_assert (offset_of (^^V::f) > offset_of (^^V::e));\n+static_assert (offset_of (^^V::g) == offset_of (^^V::g));\n+static_assert (offset_of (^^V::e).total_bits () == offsetof (V, e) * __CHAR_BIT__);\n+static_assert (offset_of (^^V::g).total_bits () == (offsetof (V, f) + sizeof (long long)) * __CHAR_BIT__ + 2);\n+using mo = decltype (offset_of (^^V::g));\n+static_assert (dealias (^^mo) == ^^std::meta::member_offset);\n+constexpr std::meta::member_offset mov = { .bytes = 1, .bits = 2 };\n+static_assert (mov.total_bits () == __CHAR_BIT__ + 2);\ndiff --git a/gcc/testsuite/g++.dg/reflect/operator_of1.C b/gcc/testsuite/g++.dg/reflect/operator_of1.C\nnew file mode 100644\nindex 00000000000..fa85f2478f5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/operator_of1.C\n@@ -0,0 +1,250 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::operator_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+struct cls {\n+ int dm;\n+ static int static_dm;\n+ void mem_fun ();\n+ static void static_mem_fun ();\n+ int &ref_dm = dm;\n+ using type = int;\n+} cls_var;\n+union onion { };\n+static union { int anon; };\n+using alias = cls;\n+void fun ();\n+int var;\n+int &ref = var;\n+int &&rref = 42;\n+int *ptr = &var;\n+namespace ns {}\n+namespace ns_alias = ns;\n+enum Enum { A };\n+enum class Enum_class { A };\n+\n+template struct incomplete_cls;\n+template struct cls_tmpl {};\n+template void fun_tmpl ();\n+template concept conc = requires { true; };\n+template int var_tmpl;\n+template using cls_tmpl_alias = cls_tmpl;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+consteval bool\n+is_operator (info r)\n+{\n+ try { operator_of (r); }\n+ catch (std::meta::exception &) { return false; }\n+ return true;\n+}\n+\n+static_assert (!is_operator (null_reflection));\n+static_assert (!is_operator (^^::));\n+static_assert (!is_operator (^^ns));\n+static_assert (!is_operator (^^ns_alias));\n+static_assert (!is_operator (reflect_constant (3)));\n+static_assert (!is_operator (^^cls));\n+static_assert (!is_operator (^^cls::dm));\n+static_assert (!is_operator (^^cls::ref_dm));\n+static_assert (!is_operator (^^cls::static_dm));\n+static_assert (!is_operator (^^cls::mem_fun));\n+static_assert (!is_operator (^^cls::static_mem_fun));\n+static_assert (!is_operator (^^cls::type));\n+static_assert (!is_operator (^^cls_var));\n+static_assert (!is_operator (^^onion));\n+static_assert (!is_operator (^^anon));\n+static_assert (!is_operator (^^fun));\n+static_assert (!is_operator (^^alias));\n+static_assert (!is_operator (^^var));\n+static_assert (!is_operator (^^ref));\n+static_assert (!is_operator (^^rref));\n+static_assert (!is_operator (^^ptr));\n+static_assert (!is_operator (^^cls_tmpl));\n+static_assert (!is_operator (^^cls_tmpl));\n+static_assert (!is_operator (^^incomplete_cls));\n+static_assert (!is_operator (^^fun_tmpl));\n+static_assert (!is_operator (^^fun_tmpl));\n+static_assert (!is_operator (^^conc));\n+static_assert (!is_operator (substitute (^^conc, { ^^int })));\n+static_assert (!is_operator (^^var_tmpl));\n+static_assert (!is_operator (^^var_tmpl));\n+static_assert (!is_operator (^^cls_tmpl_alias));\n+static_assert (!is_operator (^^cls_tmpl_alias));\n+static_assert (!is_operator (^^Enum));\n+static_assert (!is_operator (^^Enum::A));\n+static_assert (!is_operator (^^Enum_class));\n+static_assert (!is_operator (^^Enum_class::A));\n+static_assert (!is_operator (^^decomp));\n+static_assert (!is_operator (^^decomp_ref));\n+static_assert (!is_operator (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_operator (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_operator (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template\n+void\n+f ()\n+{\n+ static_assert (!is_operator (^^T));\n+ static_assert (!is_operator (R));\n+ static_assert (!is_operator (R2));\n+ static_assert (!is_operator (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f();\n+ static_assert (!is_operator (^^p));\n+ static_assert (!is_operator (^^c));\n+}\n+\n+struct S\n+{\n+ using size_t = decltype (sizeof 0);\n+ void *operator new (size_t, void *);\n+ void *operator new[] (size_t, void *);\n+ void operator delete (void *);\n+ void operator delete[] (void *);\n+ S &operator () (const S &);\n+ S &operator [] (const S &);\n+ S &operator = (const S &);\n+ S &operator << (int);\n+ S &operator >> (int);\n+ S &operator ++ ();\n+ S &operator -- ();\n+ S &operator ~ ();\n+ S &operator ! ();\n+ S &operator + (const S &);\n+ S &operator - (const S &);\n+ S &operator * (const S &);\n+ S &operator / (const S &);\n+ S &operator % (const S &);\n+ S &operator ^ (const S &);\n+ S &operator & (const S &);\n+ S &operator | (const S &);\n+ S &operator += (const S &);\n+ S &operator -= (const S &);\n+ S &operator *= (const S &);\n+ S &operator /= (const S &);\n+ S &operator %= (const S &);\n+ S &operator ^= (const S &);\n+ S &operator &= (const S &);\n+ S &operator |= (const S &);\n+ S &operator <<= (int);\n+ S &operator >>= (int);\n+ bool operator == (const S &);\n+ bool operator != (const S &);\n+ bool operator < (const S &);\n+ bool operator > (const S &);\n+ bool operator <= (const S &);\n+ bool operator >= (const S &);\n+ int operator <=> (const S &);\n+ bool operator && (const S &);\n+ bool operator || (const S &);\n+ S &operator , (const S &);\n+ S *operator -> ();\n+ S &operator ->* (const S &);\n+ S &operator co_await ();\n+};\n+\n+struct T\n+{\n+ T &operator ++ (int);\n+ T &operator -- (int);\t\n+ T &operator + ();\n+ T &operator - ();\n+};\n+\n+struct U\n+{\n+ U &operator compl ();\n+ U &operator not ();\n+ U &operator xor (const U &);\n+ U &operator bitand (const U &);\n+ U &operator bitor (const U &);\n+ U &operator xor_eq (const U &);\n+ U &operator and_eq (const U &);\n+ U &operator or_eq (const U &);\n+ bool operator and (const U &);\n+ bool operator or (const U &);\n+\n+ template\n+ S &operator () (const Args&...);\n+ template\n+ S &operator [] (const Args&...);\n+};\n+\n+static_assert (operator_of (^^S::operator new) == op_new);\n+static_assert (operator_of (^^S::operator delete) == std::meta::op_delete);\n+static_assert (operator_of (^^S::operator new[]) == std::meta::operators::op_array_new);\n+static_assert (operator_of (^^S::operator delete[]) == op_array_delete);\n+static_assert (operator_of (^^S::operator co_await) == op_co_await);\n+static_assert (operator_of (^^S::operator ()) == op_parentheses);\n+static_assert (operator_of (^^S::operator []) == op_square_brackets);\n+static_assert (operator_of (^^S::operator ->) == op_arrow);\n+static_assert (operator_of (^^S::operator ->*) == op_arrow_star);\n+static_assert (operator_of (^^S::operator ~) == op_tilde);\n+static_assert (operator_of (^^S::operator !) == op_exclamation);\n+static_assert (operator_of (^^S::operator +) == op_plus);\n+static_assert (operator_of (^^S::operator -) == op_minus);\n+static_assert (operator_of (^^S::operator *) == op_star);\n+static_assert (operator_of (^^S::operator /) == op_slash);\n+static_assert (operator_of (^^S::operator %) == op_percent);\n+static_assert (operator_of (^^S::operator ^) == op_caret);\n+static_assert (operator_of (^^S::operator &) == op_ampersand);\n+static_assert (operator_of (^^S::operator =) == op_equals);\n+static_assert (operator_of (^^S::operator |) == op_pipe);\n+static_assert (operator_of (^^S::operator +=) == op_plus_equals);\n+static_assert (operator_of (^^S::operator -=) == op_minus_equals);\n+static_assert (operator_of (^^S::operator *=) == op_star_equals);\n+static_assert (operator_of (^^S::operator /=) == op_slash_equals);\n+static_assert (operator_of (^^S::operator %=) == op_percent_equals);\n+static_assert (operator_of (^^S::operator ^=) == op_caret_equals);\n+static_assert (operator_of (^^S::operator &=) == op_ampersand_equals);\n+static_assert (operator_of (^^S::operator |=) == op_pipe_equals);\n+static_assert (operator_of (^^S::operator ==) == op_equals_equals);\n+static_assert (operator_of (^^S::operator !=) == op_exclamation_equals);\n+static_assert (operator_of (^^S::operator <) == op_less);\n+static_assert (operator_of (^^S::operator >) == op_greater);\n+static_assert (operator_of (^^S::operator <=) == op_less_equals);\n+static_assert (operator_of (^^S::operator >=) == op_greater_equals);\n+static_assert (operator_of (^^S::operator <=>) == op_spaceship);\n+static_assert (operator_of (^^S::operator &&) == op_ampersand_ampersand);\n+static_assert (operator_of (^^S::operator ||) == op_pipe_pipe);\n+static_assert (operator_of (^^S::operator <<) == op_less_less);\n+static_assert (operator_of (^^S::operator >>) == op_greater_greater);\n+static_assert (operator_of (^^S::operator <<=) == op_less_less_equals);\n+static_assert (operator_of (^^S::operator >>=) == op_greater_greater_equals);\n+static_assert (operator_of (^^S::operator ++) == op_plus_plus);\n+static_assert (operator_of (^^S::operator --) == op_minus_minus);\n+static_assert (operator_of (^^S::operator ,) == op_comma);\n+static_assert (operator_of (^^T::operator +) == op_plus);\n+static_assert (operator_of (^^T::operator -) == op_minus);\n+static_assert (operator_of (^^T::operator ++) == op_plus_plus);\n+static_assert (operator_of (^^T::operator --) == op_minus_minus);\n+static_assert (operator_of (^^U::operator compl) == op_tilde);\n+static_assert (operator_of (^^U::operator not) == op_exclamation);\n+static_assert (operator_of (^^U::operator bitand) == op_ampersand);\n+static_assert (operator_of (^^U::operator bitor) == op_pipe);\n+static_assert (operator_of (^^U::operator xor_eq) == op_caret_equals);\n+static_assert (operator_of (^^U::operator and_eq) == op_ampersand_equals);\n+static_assert (operator_of (^^U::operator or_eq) == op_pipe_equals);\n+static_assert (operator_of (^^U::operator and) == op_ampersand_ampersand);\n+static_assert (operator_of (^^U::operator or) == op_pipe_pipe);\n+// FIXME operator_of should work on operator templates\n+// static_assert (operator_of (^^U::operator ()) == op_parentheses);\n+// static_assert (operator_of (^^U::operator []) == op_square_brackets);\ndiff --git a/gcc/testsuite/g++.dg/reflect/override1.C b/gcc/testsuite/g++.dg/reflect/override1.C\nnew file mode 100644\nindex 00000000000..d3124f55152\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/override1.C\n@@ -0,0 +1,39 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// CWG 3117 - Overriding by a consteval virtual function\n+\n+using info = decltype(^^::);\n+\n+struct B {\n+ virtual void foo();\n+};\n+\n+struct D1 : B {\n+ consteval virtual void foo() override { } // { dg-error \"overriding\" }\n+};\n+\n+struct D2 : B {\n+ info i;\n+ consteval virtual void foo() override { }\n+};\n+\n+struct D3 : B {\n+ virtual void foo() override { }\n+};\n+\n+struct B2 {\n+ consteval virtual void foo() { }\n+};\n+\n+struct D4 : B2 {\n+ consteval virtual void foo() override { }\n+};\n+\n+struct D5 : B2 {\n+ virtual void foo() override { } // { dg-error \"overriding\" }\n+};\n+\n+struct D6 : B2 {\n+ info i;\n+ virtual void foo() override { } // { dg-error \"consteval-only type|overriding\" }\n+};\n","prefixes":["7/9","v2"]}