Patch Detail
get:
Show a patch.
patch:
Update a patch.
put:
Update a patch.
GET /api/1.0/patches/2175274/?format=api
{ "id": 2175274, "url": "http://patchwork.ozlabs.org/api/1.0/patches/2175274/?format=api", "project": { "id": 17, "url": "http://patchwork.ozlabs.org/api/1.0/projects/17/?format=api", "name": "GNU Compiler Collection", "link_name": "gcc", "list_id": "gcc-patches.gcc.gnu.org", "list_email": "gcc-patches@gcc.gnu.org", "web_url": null, "scm_url": null, "webscm_url": null }, "msgid": "<aULexOz9H_L4a_Nu@redhat.com>", "date": "2025-12-17T16:48:04", "name": "[6/9,v2] c++: C++26 Reflection [PR120775]", "commit_ref": null, "pull_url": null, "state": "new", "archived": false, "hash": "0369becb4674e4e01f8cfcb29ab57db5b3bca4a6", "submitter": { "id": 14370, "url": "http://patchwork.ozlabs.org/api/1.0/people/14370/?format=api", "name": "Marek Polacek", "email": "polacek@redhat.com" }, "delegate": null, "mbox": "http://patchwork.ozlabs.org/project/gcc/patch/aULexOz9H_L4a_Nu@redhat.com/mbox/", "series": [ { "id": 485726, "url": "http://patchwork.ozlabs.org/api/1.0/series/485726/?format=api", "date": "2025-12-17T16:42:41", "name": "c++: C++26 Reflection [PR120775]", "version": 2, "mbox": "http://patchwork.ozlabs.org/series/485726/mbox/" } ], "check": "pending", "checks": "http://patchwork.ozlabs.org/api/patches/2175274/checks/", "tags": {}, "headers": { "Return-Path": "<gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org>", "X-Original-To": [ "incoming@patchwork.ozlabs.org", "gcc-patches@gcc.gnu.org" ], "Delivered-To": [ "patchwork-incoming@legolas.ozlabs.org", "gcc-patches@gcc.gnu.org" ], "Authentication-Results": [ "legolas.ozlabs.org;\n\tdkim=pass (1024-bit key;\n unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256\n header.s=mimecast20190719 header.b=bvn3xeD8;\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=bvn3xeD8", "sourceware.org; dmarc=pass (p=quarantine dis=none)\n header.from=redhat.com", "sourceware.org; spf=pass smtp.mailfrom=redhat.com", "server2.sourceware.org;\n arc=none smtp.remote-ip=170.10.133.124" ], "Received": [ "from vm01.sourceware.org (vm01.sourceware.org [38.145.34.32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4dWg283QjGz1y0P\n\tfor <incoming@patchwork.ozlabs.org>; Thu, 18 Dec 2025 03:57:04 +1100 (AEDT)", "from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 6855D4BA2E39\n\tfor <incoming@patchwork.ozlabs.org>; Wed, 17 Dec 2025 16:57:02 +0000 (GMT)", "from us-smtp-delivery-124.mimecast.com\n (us-smtp-delivery-124.mimecast.com [170.10.133.124])\n by sourceware.org (Postfix) with ESMTP id 380224BA2E29\n for <gcc-patches@gcc.gnu.org>; Wed, 17 Dec 2025 16:48:15 +0000 (GMT)", "from mail-qk1-f200.google.com (mail-qk1-f200.google.com\n [209.85.222.200]) by relay.mimecast.com with ESMTP with STARTTLS\n (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id\n us-mta-494-95-uJ9QpN4WU28vc7PKmsw-1; Wed, 17 Dec 2025 11:48:13 -0500", "by mail-qk1-f200.google.com with SMTP id\n af79cd13be357-8b2dbd36752so1404266885a.0\n for <gcc-patches@gcc.gnu.org>; Wed, 17 Dec 2025 08:48:12 -0800 (PST)", "from redhat.com ([2603:7000:9500:10::1db4])\n by smtp.gmail.com with ESMTPSA id\n af79cd13be357-8be30d8a158sm440313185a.21.2025.12.17.08.48.06\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Wed, 17 Dec 2025 08:48:06 -0800 (PST)" ], "DKIM-Filter": [ "OpenDKIM Filter v2.11.0 sourceware.org 6855D4BA2E39", "OpenDKIM Filter v2.11.0 sourceware.org 380224BA2E29" ], "DMARC-Filter": "OpenDMARC Filter v1.4.2 sourceware.org 380224BA2E29", "ARC-Filter": "OpenARC Filter v1.0.0 sourceware.org 380224BA2E29", "ARC-Seal": "i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1765990095; cv=none;\n b=BZMG5EPLfz8/ADuz6c7qFq+edG2vvCbf/dzUSkD5RbA61PtTUKJRk2AQYLc0d0InMkNpVElo5qza75k5eKyX1umeZv7nvwlvCV0onfWS+4DV4XVhrGLhtPQ4G1AbjR4Q90+Bz4Ug2wzuug1GnIkQaHvGygY2YwTd7oPR4NrwhBA=", "ARC-Message-Signature": "i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1765990095; c=relaxed/simple;\n bh=gLOvO5+y/sC5+snvOzZLrnrxe0qmjr84odEORe54vYA=;\n h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version;\n b=gNP9hoe7a/nmPSTNxO9akzmr1K/pateL92GhyLfoLXE6Bjg3hBlb7qXNKU7Gqx0d6wnqpPMEwCVhL3grbEVU2i4SnbqQ+VhYAFu6dGZPD/j0ZljTXIHck88sLIAu1LS1hcg/2Dgl0nn5IK+f/ntHTxgX+DX4mlebBf2HzragdrE=", "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=1765990094;\n h=from:from:reply-to:subject:subject:date:date:message-id:message-id:\n to:to:cc:mime-version:mime-version:content-type:content-type:\n in-reply-to:in-reply-to:references:references;\n bh=W+L7vbGV9sSCKvbTUhUNXYsuVW3mlqcSAzmT8o5GU7E=;\n b=bvn3xeD8yiS+0KerQYooZTUKmYsODpLBx7Wuu9M793zskPKAUUopWqnhPVWgO8PDNNECDR\n 9eGt1XKBrXfDwagmIVT2VVAufkUbCsseC+GfeJGQoifamc3VbE3414pX0UwxP1y8GIQbCy\n CpScZLlgL2rIytt8aiJNU4Htkx9luns=", "X-MC-Unique": "95-uJ9QpN4WU28vc7PKmsw-1", "X-Mimecast-MFC-AGG-ID": "95-uJ9QpN4WU28vc7PKmsw_1765990092", "X-Google-DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20230601; t=1765990092; x=1766594892;\n h=user-agent:in-reply-to:content-disposition:mime-version:references\n :message-id:subject:to:from:date:x-gm-gg:x-gm-message-state:from:to\n :cc:subject:date:message-id:reply-to;\n bh=W+L7vbGV9sSCKvbTUhUNXYsuVW3mlqcSAzmT8o5GU7E=;\n b=tSNx/KOOnHBWa35Ad4bPiYNGO7d020lrrXUFkVTnSUBpI8cBHckHLvJbRZJRF83Qtw\n QRXUk0RBl+1urBELA/opKxjp9zjwDQFLVEyRRTa8QY57cFahb3moZ1FKqI6Kx7JsywOi\n 3HiMO54Em8cpdggePFKw5K8KOuoDHqVImYpd9DQKMW20ONVSTacQl7Ku2GLTn1wfgzUc\n ZuVg4NbiH/kiAZHre1GlHtUWtbRBnwDGMFa74scUSUAYusANeWazLM2LuxL6ySsh5B12\n nUE+mwhnRYUAwr+SEhDhksGGM43YaUQCrkMCdt4DiiJap6pMZwfEbQ7HKfEVGENVZymZ\n merQ==", "X-Gm-Message-State": "AOJu0YzgjhIoArxRKAYp4LqQHTD9+vcxJmcQS1/6mRJ8u281qu5U9B2U\n x15KsK4e4mnPOI236MWd4coJ1JwNSbuMiB3Uff27e7sxoopZRXLssZCLk5IHSW9zD5iFPodE043\n XiqmlmuLOMohMj+orK2r+CBrHzH+esiFiaLo48I+I9KPBWLwUGZ8IhPXHUxC0BpC7ZG4XupVZcy\n q7kGh24AzaFSRy1W7yv8b5PCWfurqXbpo4vRQM6ueP0A==", "X-Gm-Gg": "AY/fxX66QK2kWSx/wJpx+Wi+nhCqiUUEbt8mhk/rOFGgISNxHIGzD7TX8QugEQGjzlj\n 1G4YWC6cPuf5cgHDHofqM7WnoyevNTZsDaTTUhbWrWTGcxTQz+zT8V89dNR4VqUdMe6kbtxdNzt\n 1aBtwZTXOfu7yUsFJ+R+74laJm1EplTpeQF2OHkbZxiRRKYO7SBApGIXVLtjidquhlQHh+K4iI1\n A3lD626nUG9mE/igZ711hYvsiu65bG8MHk5fP7NFrSmZtjGJMEZcXKaalK1GeTQWg7hc7Pg3Tjy\n rSNts1QWkvTSBE3iheu6bwBKCb7DQMMJnLIZV/svSNrHuuwyC1yAH7JbZworodIJDA==", "X-Received": [ "by 2002:a05:620a:1994:b0:8a1:c9eb:5171 with SMTP id\n af79cd13be357-8bb3a36d82fmr2435881085a.41.1765990089694;\n Wed, 17 Dec 2025 08:48:09 -0800 (PST)", "by 2002:a05:620a:1994:b0:8a1:c9eb:5171 with SMTP id\n af79cd13be357-8bb3a36d82fmr2435862685a.41.1765990087443;\n Wed, 17 Dec 2025 08:48:07 -0800 (PST)" ], "X-Google-Smtp-Source": "\n AGHT+IFcasAEiIew4FcHghHxCE89gBf9+ssB+TxZaejv6Z2TsXneDdIJ7Zs37HAn2pjw1XwNYtCt+g==", "Date": "Wed, 17 Dec 2025 11:48:04 -0500", "From": "Marek Polacek <polacek@redhat.com>", "To": "GCC Patches <gcc-patches@gcc.gnu.org>, Jason Merrill <jason@redhat.com>,\n Jakub Jelinek <jakub@redhat.com>, Jonathan Wakely <jwakely@redhat.com>", "Subject": "[PATCH 6/9 v2] c++: C++26 Reflection [PR120775]", "Message-ID": "<aULexOz9H_L4a_Nu@redhat.com>", "References": "<aULdgYtbcyGQIxK1@redhat.com>", "MIME-Version": "1.0", "In-Reply-To": "<aULdgYtbcyGQIxK1@redhat.com>", "User-Agent": "Mutt/2.2.14 (2025-02-20)", "X-Mimecast-Spam-Score": "0", "X-Mimecast-MFC-PROC-ID": "joJeoVds33-0In1ADNp6UVKQotDbiBRZ_UvZbc8ZBog_1765990092", "X-Mimecast-Originator": "redhat.com", "Content-Type": "text/plain; charset=us-ascii", "Content-Disposition": "inline", "X-BeenThere": "gcc-patches@gcc.gnu.org", "X-Mailman-Version": "2.1.30", "Precedence": "list", "List-Id": "Gcc-patches mailing list <gcc-patches.gcc.gnu.org>", "List-Unsubscribe": "<https://gcc.gnu.org/mailman/options/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=unsubscribe>", "List-Archive": "<https://gcc.gnu.org/pipermail/gcc-patches/>", "List-Post": "<mailto:gcc-patches@gcc.gnu.org>", "List-Help": "<mailto:gcc-patches-request@gcc.gnu.org?subject=help>", "List-Subscribe": "<https://gcc.gnu.org/mailman/listinfo/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=subscribe>", "Errors-To": "gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org" }, "content": "Testsuite bits part #2.\n\n-- >8 --", "diff": "diff --git a/gcc/testsuite/g++.dg/reflect/has_c_language_linkage1.C b/gcc/testsuite/g++.dg/reflect/has_c_language_linkage1.C\nnew file mode 100644\nindex 00000000000..7916414c739\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_c_language_linkage1.C\n@@ -0,0 +1,156 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_c_language_linkage.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_c_language_linkage (null_reflection));\n+static_assert (!has_c_language_linkage (^^::));\n+static_assert (!has_c_language_linkage (^^ns));\n+static_assert (!has_c_language_linkage (^^std));\n+static_assert (!has_c_language_linkage (^^std::meta));\n+static_assert (!has_c_language_linkage (^^ns));\n+static_assert (!has_c_language_linkage (^^ns_alias));\n+static_assert (!has_c_language_linkage (reflect_constant (3)));\n+static_assert (!has_c_language_linkage (^^cls));\n+static_assert (!has_c_language_linkage (^^cls::dm));\n+static_assert (!has_c_language_linkage (^^cls::ref_dm));\n+static_assert (!has_c_language_linkage (^^cls::static_dm));\n+static_assert (!has_c_language_linkage (^^cls::mem_fun));\n+static_assert (!has_c_language_linkage (^^cls::static_mem_fun));\n+static_assert (!has_c_language_linkage (^^cls::type));\n+static_assert (!has_c_language_linkage (^^cls_var));\n+static_assert (!has_c_language_linkage (^^onion));\n+static_assert (!has_c_language_linkage (^^anon));\n+static_assert (!has_c_language_linkage (^^fun));\n+static_assert (!has_c_language_linkage (^^alias));\n+static_assert (!has_c_language_linkage (^^var));\n+static_assert (!has_c_language_linkage (^^ref));\n+static_assert (!has_c_language_linkage (^^rref));\n+static_assert (!has_c_language_linkage (^^ptr));\n+static_assert (!has_c_language_linkage (^^cls_tmpl));\n+static_assert (!has_c_language_linkage (^^cls_tmpl<int>));\n+static_assert (!has_c_language_linkage (^^incomplete_cls<int>));\n+static_assert (!has_c_language_linkage (^^fun_tmpl));\n+static_assert (!has_c_language_linkage (^^fun_tmpl<int>));\n+static_assert (!has_c_language_linkage (^^conc));\n+static_assert (!has_c_language_linkage (substitute (^^conc, { ^^int })));\n+static_assert (!has_c_language_linkage (^^var_tmpl));\n+static_assert (!has_c_language_linkage (^^var_tmpl<int>));\n+static_assert (!has_c_language_linkage (^^cls_tmpl_alias));\n+static_assert (!has_c_language_linkage (^^cls_tmpl_alias<int>));\n+static_assert (!has_c_language_linkage (^^Enum));\n+static_assert (!has_c_language_linkage (^^Enum::A));\n+static_assert (!has_c_language_linkage (^^Enum_class));\n+static_assert (!has_c_language_linkage (^^Enum_class::A));\n+static_assert (!has_c_language_linkage (^^decomp));\n+static_assert (!has_c_language_linkage (^^decomp_ref));\n+static_assert (!has_c_language_linkage (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"a\" });\n+static_assert (!has_c_language_linkage (dms));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_c_language_linkage (^^T));\n+ static_assert (!has_c_language_linkage (R));\n+ static_assert (!has_c_language_linkage (R2));\n+ static_assert (!has_c_language_linkage (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ int v;\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (!has_c_language_linkage (^^p));\n+ static_assert (!has_c_language_linkage (^^c));\n+ static_assert (!has_c_language_linkage (^^v));\n+}\n+\n+static int var2;\n+static int baz () { return 0; }\n+\n+static_assert (!has_c_language_linkage (^^var2));\n+static_assert (!has_c_language_linkage (^^baz));\n+\n+namespace {\n+ void qux () {}\n+ int var3;\n+ namespace NN {\n+ int var4;\n+ }\n+ struct S2 {};\n+}\n+\n+namespace NM {\n+ int var5;\n+ struct S3 {};\n+}\n+\n+extern \"C\" {\n+ void corge (int);\n+ typedef void plugh (int);\n+}\n+\n+int\n+main ()\n+{\n+}\n+\n+extern \"C\" int garply (long, ...);\n+\n+const int ci = 42;\n+extern const int ci2 = 42;\n+\n+static_assert (!has_c_language_linkage (^^qux));\n+static_assert (!has_c_language_linkage (^^var3));\n+static_assert (!has_c_language_linkage (^^NN));\n+static_assert (!has_c_language_linkage (^^NN::var4));\n+static_assert (!has_c_language_linkage (^^NM::var5));\n+static_assert (!has_c_language_linkage (^^S2));\n+static_assert (!has_c_language_linkage (^^NM::S3));\n+static_assert (has_c_language_linkage (^^corge));\n+static_assert (has_c_language_linkage (^^main));\n+static_assert (has_c_language_linkage (^^garply));\n+static_assert (!has_c_language_linkage (^^ci));\n+static_assert (!has_c_language_linkage (^^ci2));\n+// TODO: We don't have TYPE_LANGUAGE nor DECL_LANGUAGE on TYPE_DECLs.\n+//static_assert (has_c_language_linkage (^^plugh));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_default_argument1.C b/gcc/testsuite/g++.dg/reflect/has_default_argument1.C\nnew file mode 100644\nindex 00000000000..4d86824fa0a\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_default_argument1.C\n@@ -0,0 +1,132 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_default_argument.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_default_argument (null_reflection));\n+static_assert (!has_default_argument (^^::));\n+static_assert (!has_default_argument (^^ns));\n+static_assert (!has_default_argument (^^ns_alias));\n+static_assert (!has_default_argument (reflect_constant (3)));\n+static_assert (!has_default_argument (^^cls));\n+static_assert (!has_default_argument (^^cls::dm));\n+static_assert (!has_default_argument (^^cls::ref_dm));\n+static_assert (!has_default_argument (^^cls::static_dm));\n+static_assert (!has_default_argument (^^cls::mem_fun));\n+static_assert (!has_default_argument (^^cls::static_mem_fun));\n+static_assert (!has_default_argument (^^cls::type));\n+static_assert (!has_default_argument (^^cls_var));\n+static_assert (!has_default_argument (^^onion));\n+static_assert (!has_default_argument (^^anon));\n+static_assert (!has_default_argument (^^fun));\n+static_assert (!has_default_argument (^^alias));\n+static_assert (!has_default_argument (^^var));\n+static_assert (!has_default_argument (^^ref));\n+static_assert (!has_default_argument (^^rref));\n+static_assert (!has_default_argument (^^ptr));\n+static_assert (!has_default_argument (^^cls_tmpl));\n+static_assert (!has_default_argument (^^cls_tmpl<int>));\n+static_assert (!has_default_argument (^^incomplete_cls<int>));\n+static_assert (!has_default_argument (^^fun_tmpl));\n+static_assert (!has_default_argument (^^fun_tmpl<int>));\n+static_assert (!has_default_argument (^^conc));\n+static_assert (!has_default_argument (substitute (^^conc, { ^^int })));\n+static_assert (!has_default_argument (^^var_tmpl));\n+static_assert (!has_default_argument (^^var_tmpl<int>));\n+static_assert (!has_default_argument (^^cls_tmpl_alias));\n+static_assert (!has_default_argument (^^cls_tmpl_alias<int>));\n+static_assert (!has_default_argument (^^Enum));\n+static_assert (!has_default_argument (^^Enum::A));\n+static_assert (!has_default_argument (^^Enum_class));\n+static_assert (!has_default_argument (^^Enum_class::A));\n+static_assert (!has_default_argument (^^decomp));\n+static_assert (!has_default_argument (^^decomp_ref));\n+static_assert (!has_default_argument (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"n\" });\n+static_assert (!has_default_argument (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!has_default_argument (bases_of (^^Derived, access_context::unchecked ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_default_argument (^^T));\n+ static_assert (!has_default_argument (R));\n+ static_assert (!has_default_argument (R2));\n+ static_assert (!has_default_argument (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^p, ^^c>();\n+ static_assert (!has_default_argument (^^p));\n+ static_assert (!has_default_argument (^^c));\n+}\n+\n+void h (int a, int b);\n+static_assert (!has_default_argument (parameters_of (^^h)[0]));\n+static_assert (!has_default_argument (parameters_of (^^h)[1]));\n+constexpr auto ha = parameters_of (^^h)[0];\n+constexpr auto hb = parameters_of (^^h)[1];\n+void h (int c, int d = 42);\n+static_assert (!has_default_argument (parameters_of (^^h)[0]));\n+static_assert (has_default_argument (parameters_of (^^h)[1]));\n+static_assert (!has_default_argument (ha));\n+static_assert (has_default_argument (hb));\n+void h (int c = 5, int d);\n+static_assert (has_default_argument (parameters_of (^^h)[0]));\n+static_assert (has_default_argument (parameters_of (^^h)[1]));\n+static_assert (has_default_argument (ha));\n+static_assert (has_default_argument (hb));\n+\n+void\n+h (int e, int f)\n+{\n+ static_assert (has_default_argument (parameters_of (^^h)[0]));\n+ static_assert (has_default_argument (parameters_of (^^h)[1]));\n+ static_assert (has_default_argument (ha));\n+ static_assert (has_default_argument (hb));\n+ static_assert (!has_default_argument (^^e));\n+ static_assert (!has_default_argument (^^f));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_default_argument2.C b/gcc/testsuite/g++.dg/reflect/has_default_argument2.C\nnew file mode 100644\nindex 00000000000..2edec192219\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_default_argument2.C\n@@ -0,0 +1,32 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_default_argument.\n+\n+#include <meta>\n+\n+void foo (int a, const int b = 42);\n+constexpr auto parm1info = std::meta::parameters_of (^^foo)[0];\n+constexpr auto parm2info = std::meta::parameters_of (^^foo)[1];\n+static_assert (!std::meta::has_default_argument (parm1info));\n+static_assert ( std::meta::has_default_argument (parm2info));\n+void foo (int = 14, const int);\n+static_assert ( std::meta::has_default_argument (parm1info));\n+static_assert ( std::meta::has_default_argument (parm2info));\n+static_assert (std::meta::type_of (parm1info) == ^^int);\n+static_assert (std::meta::type_of (parm2info) == ^^int);\n+\n+void\n+foo (int c, const int d)\n+{\n+ constexpr auto p = std::meta::parameters_of (^^foo)[1];\n+ static_assert (p == parm2info);\n+ static_assert (std::meta::has_default_argument (p));\n+ static_assert (std::meta::type_of (p) == ^^int);\n+ static_assert (std::meta::type_of (std::meta::variable_of (p)) == ^^const int);\n+ static_assert (std::meta::type_of (^^d) == ^^const int);\n+\n+ static_assert ( std::meta::has_default_argument (parm1info));\n+ static_assert ( std::meta::has_default_argument (parm2info));\n+ static_assert (std::meta::type_of (parm1info) == ^^int);\n+ static_assert (std::meta::type_of (parm2info) == ^^int);\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_default_member_initializer1.C b/gcc/testsuite/g++.dg/reflect/has_default_member_initializer1.C\nnew file mode 100644\nindex 00000000000..ab48ffef556\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_default_member_initializer1.C\n@@ -0,0 +1,133 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_default_member_initializer.\n+\n+#include <meta>\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+ int dm2 = 42;\n+ int &ref_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 <int N>\n+ void foo ();\n+ template <int N>\n+ static void bar ();\n+ cls () : ref_dm2 (dm2) {}\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_default_member_initializer (null_reflection));\n+static_assert (!has_default_member_initializer (^^::));\n+static_assert (!has_default_member_initializer (^^ns));\n+static_assert (!has_default_member_initializer (^^ns_alias));\n+static_assert (!has_default_member_initializer (reflect_constant (3)));\n+static_assert (!has_default_member_initializer (^^cls));\n+static_assert (!has_default_member_initializer (^^cls::dm));\n+static_assert (has_default_member_initializer (^^cls::ref_dm));\n+static_assert (has_default_member_initializer (^^cls::dm2));\n+static_assert (!has_default_member_initializer (^^cls::ref_dm2));\n+static_assert (!has_default_member_initializer (^^cls::static_dm));\n+static_assert (!has_default_member_initializer (^^cls::mem_fun));\n+static_assert (!has_default_member_initializer (^^cls::static_mem_fun));\n+static_assert (!has_default_member_initializer (^^cls::type));\n+static_assert (!has_default_member_initializer (^^cls::E));\n+static_assert (!has_default_member_initializer (^^cls::B));\n+static_assert (!has_default_member_initializer (^^cls::C));\n+static_assert (!has_default_member_initializer (^^cls::D));\n+static_assert (!has_default_member_initializer (^^cls::F));\n+static_assert (!has_default_member_initializer (^^cls::F::G));\n+static_assert (!has_default_member_initializer (^^cls::F::H));\n+static_assert (!has_default_member_initializer (^^cls::S));\n+static_assert (!has_default_member_initializer (^^cls::U));\n+static_assert (!has_default_member_initializer (^^cls::foo));\n+static_assert (!has_default_member_initializer (^^cls::foo <0>));\n+static_assert (!has_default_member_initializer (^^cls::bar));\n+static_assert (!has_default_member_initializer (^^cls::bar <42>));\n+static_assert (!has_default_member_initializer (^^cls_var));\n+static_assert (!has_default_member_initializer (^^onion));\n+static_assert (!has_default_member_initializer (^^anon));\n+static_assert (!has_default_member_initializer (^^fun));\n+static_assert (!has_default_member_initializer (^^alias));\n+static_assert (!has_default_member_initializer (^^var));\n+static_assert (!has_default_member_initializer (^^ref));\n+static_assert (!has_default_member_initializer (^^rref));\n+static_assert (!has_default_member_initializer (^^ptr));\n+static_assert (!has_default_member_initializer (^^cls_tmpl));\n+static_assert (!has_default_member_initializer (^^cls_tmpl<int>));\n+static_assert (!has_default_member_initializer (^^incomplete_cls<int>));\n+static_assert (!has_default_member_initializer (^^fun_tmpl));\n+static_assert (!has_default_member_initializer (^^fun_tmpl<int>));\n+static_assert (!has_default_member_initializer (^^conc));\n+static_assert (!has_default_member_initializer (substitute (^^conc, { ^^int })));\n+static_assert (!has_default_member_initializer (^^var_tmpl));\n+static_assert (!has_default_member_initializer (^^var_tmpl<int>));\n+static_assert (!has_default_member_initializer (^^cls_tmpl_alias));\n+static_assert (!has_default_member_initializer (^^cls_tmpl_alias<int>));\n+static_assert (!has_default_member_initializer (^^Enum));\n+static_assert (!has_default_member_initializer (^^Enum::A));\n+static_assert (!has_default_member_initializer (^^Enum_class));\n+static_assert (!has_default_member_initializer (^^Enum_class::A));\n+static_assert (!has_default_member_initializer (^^decomp));\n+static_assert (!has_default_member_initializer (^^decomp_ref));\n+static_assert (!has_default_member_initializer (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"a\" });\n+static_assert (!has_default_member_initializer (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!has_default_member_initializer (bases_of (^^Derived, access_context::unchecked ())[0]));\n+\n+void\n+foo (int x, int y = 10)\n+{\n+ static_assert (!has_default_member_initializer (^^x));\n+ static_assert (!has_default_member_initializer (parameters_of (^^foo)[0]));\n+ static_assert (!has_default_member_initializer (parameters_of (^^foo)[1]));\n+ int v;\n+ static_assert (!has_default_member_initializer (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!has_default_member_initializer (^^S));\n+ static_assert (!has_default_member_initializer (^^E));\n+ static_assert (!has_default_member_initializer (^^F));\n+ static_assert (!has_default_member_initializer (^^G));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_ellipsis_parameter1.C b/gcc/testsuite/g++.dg/reflect/has_ellipsis_parameter1.C\nnew file mode 100644\nindex 00000000000..e749ce5b066\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_ellipsis_parameter1.C\n@@ -0,0 +1,148 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_ellipsis_parameter.\n+\n+#include <meta>\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+ void mem_fun2 (int, ...);\n+ void mem_fun3 (...);\n+ void mem_fun4 (int);\n+ static void static_mem_fun ();\n+ static void static_mem_fun2 (int, long, ...);\n+ static void static_mem_fun3 (...);\n+ static void static_mem_fun4 (long);\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+void fun2 (int, ...);\n+void fun3 (...);\n+void fun4 (int, int);\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+using funt = int ();\n+using funt2 = int (int, ...);\n+using funt3 = int (...);\n+using funt4 = int (int, long);\n+\n+template<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> void fun_tmpl2 (int, ...);\n+template<typename> void fun_tmpl3 (...);\n+template<typename> void fun_tmpl4 (long, int);\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+using inc_arr = int[];\n+using com_arr = int[42];\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_ellipsis_parameter (null_reflection));\n+static_assert (!has_ellipsis_parameter (^^::));\n+static_assert (!has_ellipsis_parameter (^^ns));\n+static_assert (!has_ellipsis_parameter (^^ns_alias));\n+static_assert (!has_ellipsis_parameter (reflect_constant (3)));\n+static_assert (!has_ellipsis_parameter (^^cls));\n+static_assert (!has_ellipsis_parameter (^^cls::dm));\n+static_assert (!has_ellipsis_parameter (^^cls::ref_dm));\n+static_assert (!has_ellipsis_parameter (^^cls::static_dm));\n+static_assert (!has_ellipsis_parameter (^^cls::mem_fun));\n+static_assert (has_ellipsis_parameter (^^cls::mem_fun2));\n+static_assert (has_ellipsis_parameter (^^cls::mem_fun3));\n+static_assert (!has_ellipsis_parameter (^^cls::mem_fun4));\n+static_assert (!has_ellipsis_parameter (^^cls::static_mem_fun));\n+static_assert (has_ellipsis_parameter (^^cls::static_mem_fun2));\n+static_assert (has_ellipsis_parameter (^^cls::static_mem_fun3));\n+static_assert (!has_ellipsis_parameter (^^cls::static_mem_fun4));\n+static_assert (!has_ellipsis_parameter (^^cls::type));\n+static_assert (!has_ellipsis_parameter (^^cls_var));\n+static_assert (!has_ellipsis_parameter (^^onion));\n+static_assert (!has_ellipsis_parameter (^^anon));\n+static_assert (!has_ellipsis_parameter (^^fun));\n+static_assert (has_ellipsis_parameter (^^fun2));\n+static_assert (has_ellipsis_parameter (^^fun3));\n+static_assert (!has_ellipsis_parameter (^^fun4));\n+static_assert (!has_ellipsis_parameter (type_of (^^fun)));\n+static_assert (has_ellipsis_parameter (type_of (^^fun2)));\n+static_assert (has_ellipsis_parameter (type_of (^^fun3)));\n+static_assert (!has_ellipsis_parameter (type_of (^^fun4)));\n+static_assert (!has_ellipsis_parameter (^^alias));\n+static_assert (!has_ellipsis_parameter (^^var));\n+static_assert (!has_ellipsis_parameter (^^ref));\n+static_assert (!has_ellipsis_parameter (^^rref));\n+static_assert (!has_ellipsis_parameter (^^ptr));\n+static_assert (!has_ellipsis_parameter (^^cls_tmpl));\n+static_assert (!has_ellipsis_parameter (^^cls_tmpl<int>));\n+static_assert (!has_ellipsis_parameter (^^incomplete_cls<int>));\n+static_assert (!has_ellipsis_parameter (^^fun_tmpl));\n+static_assert (!has_ellipsis_parameter (^^fun_tmpl<int>));\n+static_assert (!has_ellipsis_parameter (^^fun_tmpl2));\n+static_assert (has_ellipsis_parameter (^^fun_tmpl2<int>));\n+static_assert (!has_ellipsis_parameter (^^fun_tmpl3));\n+static_assert (has_ellipsis_parameter (^^fun_tmpl3<int>));\n+static_assert (!has_ellipsis_parameter (^^fun_tmpl4));\n+static_assert (!has_ellipsis_parameter (^^fun_tmpl4<int>));\n+static_assert (!has_ellipsis_parameter (^^conc));\n+static_assert (!has_ellipsis_parameter (substitute (^^conc, { ^^int })));\n+static_assert (!has_ellipsis_parameter (^^var_tmpl));\n+static_assert (!has_ellipsis_parameter (^^var_tmpl<int>));\n+static_assert (!has_ellipsis_parameter (^^cls_tmpl_alias));\n+static_assert (!has_ellipsis_parameter (^^cls_tmpl_alias<int>));\n+static_assert (!has_ellipsis_parameter (^^Enum));\n+static_assert (!has_ellipsis_parameter (^^Enum::A));\n+static_assert (!has_ellipsis_parameter (^^Enum_class));\n+static_assert (!has_ellipsis_parameter (^^Enum_class::A));\n+static_assert (!has_ellipsis_parameter (^^decomp));\n+static_assert (!has_ellipsis_parameter (^^decomp_ref));\n+static_assert (!has_ellipsis_parameter (^^arr));\n+static_assert (!has_ellipsis_parameter (^^inc_arr));\n+static_assert (!has_ellipsis_parameter (^^com_arr));\n+static_assert (!has_ellipsis_parameter (^^funt));\n+static_assert (has_ellipsis_parameter (^^funt2));\n+static_assert (has_ellipsis_parameter (^^funt3));\n+static_assert (!has_ellipsis_parameter (^^funt4));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = u8\"a\" });\n+static_assert (!has_ellipsis_parameter (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!has_ellipsis_parameter (bases_of (^^Derived, access_context::unchecked ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_ellipsis_parameter (^^T));\n+ static_assert (!has_ellipsis_parameter (R));\n+ static_assert (!has_ellipsis_parameter (R2));\n+ static_assert (!has_ellipsis_parameter (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (!has_ellipsis_parameter (^^p));\n+ static_assert (!has_ellipsis_parameter (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_external_linkage1.C b/gcc/testsuite/g++.dg/reflect/has_external_linkage1.C\nnew file mode 100644\nindex 00000000000..e6e791123fd\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_external_linkage1.C\n@@ -0,0 +1,149 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_external_linkage.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_external_linkage (null_reflection));\n+static_assert (has_external_linkage (^^::));\n+static_assert (has_external_linkage (^^ns));\n+static_assert (has_external_linkage (^^std));\n+static_assert (has_external_linkage (^^std::meta));\n+static_assert (has_external_linkage (^^ns_alias));\n+static_assert (!has_external_linkage (reflect_constant (3)));\n+static_assert (has_external_linkage (^^cls));\n+static_assert (!has_external_linkage (^^cls::dm));\n+static_assert (!has_external_linkage (^^cls::ref_dm));\n+static_assert (has_external_linkage (^^cls::static_dm));\n+static_assert (has_external_linkage (^^cls::mem_fun));\n+static_assert (has_external_linkage (^^cls::static_mem_fun));\n+static_assert (!has_external_linkage (^^cls::type));\n+static_assert (has_external_linkage (^^cls_var));\n+static_assert (has_external_linkage (^^onion));\n+static_assert (!has_external_linkage (^^anon));\n+static_assert (has_external_linkage (^^fun));\n+static_assert (!has_external_linkage (^^alias));\n+static_assert (has_external_linkage (^^var));\n+static_assert (has_external_linkage (^^ref));\n+static_assert (has_external_linkage (^^rref));\n+static_assert (has_external_linkage (^^ptr));\n+static_assert (has_external_linkage (^^cls_tmpl));\n+static_assert (has_external_linkage (^^cls_tmpl<int>));\n+static_assert (has_external_linkage (^^incomplete_cls<int>));\n+static_assert (has_external_linkage (^^fun_tmpl));\n+static_assert (has_external_linkage (^^fun_tmpl<int>));\n+static_assert (has_external_linkage (^^conc));\n+static_assert (!has_external_linkage (substitute (^^conc, { ^^int })));\n+static_assert (has_external_linkage (^^var_tmpl));\n+static_assert (has_external_linkage (^^var_tmpl<int>));\n+static_assert (!has_external_linkage (^^cls_tmpl_alias));\n+static_assert (!has_external_linkage (^^cls_tmpl_alias<int>));\n+static_assert (has_external_linkage (^^Enum));\n+static_assert (!has_external_linkage (^^Enum::A));\n+static_assert (has_external_linkage (^^Enum_class));\n+static_assert (!has_external_linkage (^^Enum_class::A));\n+static_assert (!has_external_linkage (^^decomp));\n+static_assert (!has_external_linkage (^^decomp_ref));\n+static_assert (has_external_linkage (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!has_external_linkage (dms));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_external_linkage (^^T));\n+ static_assert (has_external_linkage (R));\n+ static_assert (has_external_linkage (R2));\n+ static_assert (has_external_linkage (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ int v;\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (!has_external_linkage (^^p));\n+ static_assert (!has_external_linkage (^^c));\n+ static_assert (!has_external_linkage (^^v));\n+}\n+\n+static int var2;\n+static int baz () { return 0; }\n+\n+static_assert (!has_external_linkage (^^var2));\n+static_assert (!has_external_linkage (^^baz));\n+\n+namespace {\n+ void qux () {}\n+ int var3;\n+ namespace NN {\n+ int var4;\n+ }\n+ struct S2 {};\n+}\n+\n+namespace NM {\n+ int var5;\n+ struct S3 {};\n+}\n+\n+extern \"C\" {\n+ void corge (int);\n+}\n+\n+int\n+main ()\n+{\n+}\n+\n+const int ci = 42;\n+extern const int ci2 = 42;\n+\n+static_assert (!has_external_linkage (^^qux));\n+static_assert (!has_external_linkage (^^var3));\n+static_assert (!has_external_linkage (^^NN));\n+static_assert (!has_external_linkage (^^NN::var4));\n+static_assert (has_external_linkage (^^NM::var5));\n+static_assert (!has_external_linkage (^^S2));\n+static_assert (has_external_linkage (^^NM::S3));\n+static_assert (has_external_linkage (^^corge));\n+static_assert (has_external_linkage (^^main));\n+static_assert (!has_external_linkage (^^ci));\n+static_assert (has_external_linkage (^^ci2));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_external_linkage2.C b/gcc/testsuite/g++.dg/reflect/has_external_linkage2.C\nnew file mode 100644\nindex 00000000000..a0b88254dbc\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_external_linkage2.C\n@@ -0,0 +1,13 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection -fmodules\" }\n+// Test std::meta::has_external_linkage.\n+\n+module;\n+\n+#include <meta>\n+\n+module has_external_linkage:counter;\n+\n+int counter = 0;\n+\n+static_assert (!std::meta::has_external_linkage (^^counter));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_identifier1.C b/gcc/testsuite/g++.dg/reflect/has_identifier1.C\nnew file mode 100644\nindex 00000000000..ea51f0f63a8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_identifier1.C\n@@ -0,0 +1,241 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_identifier.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+\n+struct S { };\n+using T = int;\n+using U = S;\n+enum E { E1, E2 };\n+enum { E3, E4 };\n+typedef enum { E5, E6 } E7;\n+union P { int a; };\n+\n+static_assert (!has_identifier (null_reflection));\n+static_assert (!has_identifier (^^int));\n+static_assert (has_identifier (^^T));\n+static_assert (!has_identifier (^^::));\n+static_assert (has_identifier (^^S));\n+static_assert (has_identifier (^^U));\n+static_assert (has_identifier (^^P));\n+static_assert (!has_identifier (^^const S));\n+static_assert (!has_identifier (^^const volatile U));\n+static_assert (!has_identifier (^^P volatile));\n+static_assert (has_identifier (^^std));\n+static_assert (has_identifier (^^std::meta));\n+static_assert (!has_identifier (^^int *));\n+static_assert (!has_identifier (^^int));\n+static_assert (!has_identifier (^^unsigned long long));\n+static_assert (!has_identifier (^^long &&));\n+static_assert (has_identifier (^^E1));\n+static_assert (has_identifier (^^E));\n+static_assert (!has_identifier (^^E const));\n+static_assert (!has_identifier (^^volatile E));\n+static_assert (!has_identifier (^^const E volatile));\n+static_assert (!has_identifier (parent_of (^^E3)));\n+static_assert (has_identifier (parent_of (^^E5)));\n+static_assert (has_identifier (^^E7));\n+static_assert (has_identifier (dealias (^^E7)));\n+[[=1]] int w;\n+static_assert (!has_identifier (annotations_of (^^w)[0]));\n+static_assert (!has_identifier (data_member_spec (^^int, { .bit_width = 0 })));\n+static_assert (!has_identifier (data_member_spec (^^long, { .bit_width = 6 })));\n+static_assert (has_identifier (data_member_spec (^^long, { .name = \"dms\", .bit_width = 6 })));\n+static_assert (has_identifier (data_member_spec (^^long, { .name = u8\"dms\", .alignment = 2 * alignof (long) })));\n+\n+namespace N {}\n+namespace NA = N;\n+static_assert (has_identifier (^^N));\n+static_assert (has_identifier (^^NA));\n+\n+namespace {\n+ int a;\n+ namespace M {}\n+ static_assert (has_identifier (^^a));\n+ static_assert (!has_identifier (parent_of (^^a)));\n+ static_assert (has_identifier (^^M));\n+ static_assert (!has_identifier (parent_of (^^M)));\n+ static_assert (!has_identifier (parent_of (parent_of (^^M))));\n+}\n+\n+typedef struct {\n+ int a;\n+ static_assert (has_identifier (^^a));\n+ static_assert (!has_identifier (parent_of (^^a)));\n+} SV;\n+static_assert (has_identifier (^^SV));\n+static_assert (has_identifier (parent_of (^^SV::a)));\n+static_assert (has_identifier (dealias (^^SV)));\n+\n+template <int N>\n+struct ST\n+{\n+ static_assert (has_identifier (^^ST));\n+ static_assert (!has_identifier (^^ST <N>));\n+};\n+\n+struct V\n+{\n+ V () { int a; static_assert (!has_identifier (parent_of (^^a))); }\n+ V (int, long) { int a; static_assert (!has_identifier (parent_of (^^a))); }\n+ template <typename T>\n+ V (long, T &) { int a; static_assert (!has_identifier (parent_of (^^a))); }\n+ ~V () { int a; static_assert (!has_identifier (parent_of (^^a))); }\n+ V &operator = (const V &) { int a; static_assert (!has_identifier (parent_of (^^a))); return *this; }\n+ V &operator + (const V &) { int a; static_assert (!has_identifier (parent_of (^^a))); return *this; }\n+ template <typename T>\n+ V &operator * (const T &) { int a; static_assert (!has_identifier (parent_of (^^a))); return *this; }\n+ operator int () { int a; static_assert (!has_identifier (parent_of (^^a))); return *this; }\n+ void foo () { int a; static_assert (has_identifier (parent_of (^^a))); }\n+ template <int N>\n+ void bar () { int a; static_assert (has_identifier (parent_of (^^a))); }\n+};\n+\n+struct W\n+{\n+ template <typename T>\n+ explicit operator T () { int a; static_assert (!has_identifier (parent_of (^^a))); }\n+};\n+\n+int\n+operator \"\"_a (const char *)\n+{\n+ int a;\n+ static_assert (has_identifier (parent_of (^^a)));\n+ return 0;\n+}\n+\n+int v;\n+static_assert (!has_identifier (^^V::operator =));\n+static_assert (!has_identifier (^^V::operator +));\n+//static_assert (!has_identifier (^^V::operator *));\n+static_assert (!has_identifier (^^V::operator *<int>));\n+static_assert (!has_identifier (^^V::operator int));\n+static_assert (has_identifier (^^V::foo));\n+static_assert (has_identifier (^^V::bar));\n+static_assert (!has_identifier (^^V::bar <0>));\n+\n+void foo (int);\n+static_assert (has_identifier (^^foo));\n+\n+int arr[3];\n+\n+void\n+foo (int a)\n+{\n+ auto [b, c, d] = arr;\n+ static_assert (has_identifier (^^foo));\n+ static_assert (has_identifier (^^a));\n+ static_assert (has_identifier (^^b));\n+ static_assert (has_identifier (^^c));\n+ static_assert (has_identifier (^^d));\n+}\n+\n+template <int N>\n+void\n+bar (int a)\n+{\n+ auto [...b, c] = arr;\n+ static_assert (has_identifier (^^foo));\n+ static_assert (has_identifier (^^a));\n+ static_assert (has_identifier (^^c));\n+}\n+\n+void\n+baz ()\n+{\n+ auto a = [] {\n+ int a;\n+ static_assert (has_identifier (^^a));\n+ static_assert (!has_identifier (parent_of (^^a)));\n+ static_assert (!has_identifier (parent_of (parent_of (^^a))));\n+ static_assert (has_identifier (parent_of (parent_of (parent_of (^^a)))));\n+ };\n+ using t = decltype (a);\n+ static_assert (has_identifier (^^t));\n+ static_assert (!has_identifier (dealias (^^t)));\n+}\n+\n+void qux (int, int b, int c, int d, int);\n+constexpr auto p0 = parameters_of (^^qux)[0];\n+constexpr auto p1 = parameters_of (^^qux)[1];\n+constexpr auto p2 = parameters_of (^^qux)[2];\n+constexpr auto p3 = parameters_of (^^qux)[3];\n+constexpr auto p4 = parameters_of (^^qux)[4];\n+static_assert (!has_identifier (p0));\n+static_assert (has_identifier (p1));\n+static_assert (has_identifier (p2));\n+static_assert (has_identifier (p3));\n+static_assert (!has_identifier (p4));\n+void qux (int a, int, int c, int e, int);\n+static_assert (has_identifier (p0));\n+static_assert (has_identifier (p1));\n+static_assert (has_identifier (p2));\n+static_assert (!has_identifier (p3));\n+static_assert (!has_identifier (p4));\n+\n+void\n+qux (int a, int, int, int e, int)\n+{\n+ static_assert (has_identifier (p0));\n+ static_assert (has_identifier (p1));\n+ static_assert (has_identifier (p2));\n+ static_assert (!has_identifier (p3));\n+ static_assert (!has_identifier (p4));\n+ static_assert (has_identifier (variable_of (p0)));\n+ static_assert (!has_identifier (variable_of (p1)));\n+ static_assert (!has_identifier (variable_of (p2)));\n+ static_assert (has_identifier (variable_of (p3)));\n+ static_assert (!has_identifier (variable_of (p4)));\n+}\n+\n+void qux (int f, int, int, int, int g);\n+static_assert (!has_identifier (p0));\n+static_assert (has_identifier (p1));\n+static_assert (has_identifier (p2));\n+static_assert (!has_identifier (p3));\n+static_assert (has_identifier (p4));\n+\n+template <typename... T>\n+void\n+freddy (int a, T... b)\n+{\n+}\n+\n+static_assert (has_identifier (parameters_of (^^freddy <int, long, char>)[0]));\n+static_assert (!has_identifier (parameters_of (^^freddy <int, long, char>)[1]));\n+\n+struct {\n+ int a;\n+} s;\n+\n+static_assert (has_identifier (^^s));\n+static_assert (!has_identifier (type_of (^^s)));\n+\n+void\n+corge ()\n+{\n+ __extension__ constexpr bool b = has_identifier (({ struct S2 { }; ^^S2; }));\n+}\n+\n+typedef struct {\n+ int b;\n+} TN;\n+\n+static_assert (has_identifier (parent_of (^^TN::b)));\n+static_assert (has_identifier (^^TN));\n+static_assert (has_identifier (dealias (^^TN)));\n+\n+typedef enum {\n+ E8,\n+ E9 = has_identifier (parent_of (^^E8)) ? 2 : 3,\n+} E10;\n+static_assert (E9 == 3);\n+static_assert (has_identifier (parent_of (^^E8)));\n+static_assert (has_identifier (^^E10));\n+static_assert (has_identifier (dealias (^^E10)));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_identifier2.C b/gcc/testsuite/g++.dg/reflect/has_identifier2.C\nnew file mode 100644\nindex 00000000000..49f0092da24\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_identifier2.C\n@@ -0,0 +1,57 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_identifier.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+namespace N\n+{\n+ consteval bool\n+ has_identifier (info r) { return std::meta::has_identifier (r); }\n+ consteval std::vector<info>\n+ parameters_of (info r) { return std::meta::parameters_of (r); }\n+ consteval info\n+ variable_of (info r) { return std::meta::variable_of (r); }\n+}\n+\n+void qux (int, int b, int c, int d, int);\n+constexpr auto p0 = N::parameters_of (^^qux)[0];\n+constexpr auto p1 = N::parameters_of (^^qux)[1];\n+constexpr auto p2 = N::parameters_of (^^qux)[2];\n+constexpr auto p3 = N::parameters_of (^^qux)[3];\n+constexpr auto p4 = N::parameters_of (^^qux)[4];\n+static_assert (!N::has_identifier (p0));\n+static_assert (N::has_identifier (p1));\n+static_assert (N::has_identifier (p2));\n+static_assert (N::has_identifier (p3));\n+static_assert (!N::has_identifier (p4));\n+void qux (int a, int, int c, int e, int);\n+static_assert (N::has_identifier (p0));\n+static_assert (N::has_identifier (p1));\n+static_assert (N::has_identifier (p2));\n+static_assert (!N::has_identifier (p3));\n+static_assert (!N::has_identifier (p4));\n+\n+void\n+qux (int a, int, int, int e, int)\n+{\n+ static_assert (N::has_identifier (p0));\n+ static_assert (N::has_identifier (p1));\n+ static_assert (N::has_identifier (p2));\n+ static_assert (!N::has_identifier (p3));\n+ static_assert (!N::has_identifier (p4));\n+ static_assert (N::has_identifier (N::variable_of (p0)));\n+ static_assert (!N::has_identifier (N::variable_of (p1)));\n+ static_assert (!N::has_identifier (N::variable_of (p2)));\n+ static_assert (N::has_identifier (N::variable_of (p3)));\n+ static_assert (!N::has_identifier (N::variable_of (p4)));\n+}\n+\n+void qux (int f, int, int, int, int g);\n+static_assert (!N::has_identifier (p0));\n+static_assert (N::has_identifier (p1));\n+static_assert (N::has_identifier (p2));\n+static_assert (!N::has_identifier (p3));\n+static_assert (N::has_identifier (p4));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_internal_linkage1.C b/gcc/testsuite/g++.dg/reflect/has_internal_linkage1.C\nnew file mode 100644\nindex 00000000000..79365436109\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_internal_linkage1.C\n@@ -0,0 +1,149 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_internal_linkage.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_internal_linkage (null_reflection));\n+static_assert (!has_internal_linkage (^^::));\n+static_assert (!has_internal_linkage (^^ns));\n+static_assert (!has_internal_linkage (^^std));\n+static_assert (!has_internal_linkage (^^std::meta));\n+static_assert (!has_internal_linkage (^^ns_alias));\n+static_assert (!has_internal_linkage (reflect_constant (3)));\n+static_assert (!has_internal_linkage (^^cls));\n+static_assert (!has_internal_linkage (^^cls::dm));\n+static_assert (!has_internal_linkage (^^cls::ref_dm));\n+static_assert (!has_internal_linkage (^^cls::static_dm));\n+static_assert (!has_internal_linkage (^^cls::mem_fun));\n+static_assert (!has_internal_linkage (^^cls::static_mem_fun));\n+static_assert (!has_internal_linkage (^^cls::type));\n+static_assert (!has_internal_linkage (^^cls_var));\n+static_assert (!has_internal_linkage (^^onion));\n+static_assert (!has_internal_linkage (^^anon));\n+static_assert (!has_internal_linkage (^^fun));\n+static_assert (!has_internal_linkage (^^alias));\n+static_assert (!has_internal_linkage (^^var));\n+static_assert (!has_internal_linkage (^^ref));\n+static_assert (!has_internal_linkage (^^rref));\n+static_assert (!has_internal_linkage (^^ptr));\n+static_assert (!has_internal_linkage (^^cls_tmpl));\n+static_assert (!has_internal_linkage (^^cls_tmpl<int>));\n+static_assert (!has_internal_linkage (^^incomplete_cls<int>));\n+static_assert (!has_internal_linkage (^^fun_tmpl));\n+static_assert (!has_internal_linkage (^^fun_tmpl<int>));\n+static_assert (!has_internal_linkage (^^conc));\n+static_assert (!has_internal_linkage (substitute (^^conc, { ^^int })));\n+static_assert (!has_internal_linkage (^^var_tmpl));\n+static_assert (!has_internal_linkage (^^var_tmpl<int>));\n+static_assert (!has_internal_linkage (^^cls_tmpl_alias));\n+static_assert (!has_internal_linkage (^^cls_tmpl_alias<int>));\n+static_assert (!has_internal_linkage (^^Enum));\n+static_assert (!has_internal_linkage (^^Enum::A));\n+static_assert (!has_internal_linkage (^^Enum_class));\n+static_assert (!has_internal_linkage (^^Enum_class::A));\n+static_assert (!has_internal_linkage (^^decomp));\n+static_assert (!has_internal_linkage (^^decomp_ref));\n+static_assert (!has_internal_linkage (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!has_internal_linkage (dms));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_internal_linkage (^^T));\n+ static_assert (!has_internal_linkage (R));\n+ static_assert (!has_internal_linkage (R2));\n+ static_assert (!has_internal_linkage (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ int v;\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (!has_internal_linkage (^^p));\n+ static_assert (!has_internal_linkage (^^c));\n+ static_assert (!has_internal_linkage (^^v));\n+}\n+\n+static int var2;\n+static int baz () { return 0; }\n+\n+static_assert (has_internal_linkage (^^var2));\n+static_assert (has_internal_linkage (^^baz));\n+\n+namespace {\n+ void qux () {}\n+ int var3;\n+ namespace NN {\n+ int var4;\n+ }\n+ struct S2 {};\n+}\n+\n+namespace NM {\n+ int var5;\n+ struct S3 {};\n+}\n+\n+extern \"C\" {\n+ void corge (int);\n+}\n+\n+int\n+main ()\n+{\n+}\n+\n+const int ci = 42;\n+extern const int ci2 = 42;\n+\n+static_assert (has_internal_linkage (^^qux));\n+static_assert (has_internal_linkage (^^var3));\n+static_assert (has_internal_linkage (^^NN));\n+static_assert (has_internal_linkage (^^NN::var4));\n+static_assert (!has_internal_linkage (^^NM::var5));\n+static_assert (has_internal_linkage (^^S2));\n+static_assert (!has_internal_linkage (^^NM::S3));\n+static_assert (!has_internal_linkage (^^corge));\n+static_assert (!has_internal_linkage (^^main));\n+static_assert (has_internal_linkage (^^ci));\n+static_assert (!has_internal_linkage (^^ci2));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_internal_linkage2.C b/gcc/testsuite/g++.dg/reflect/has_internal_linkage2.C\nnew file mode 100644\nindex 00000000000..4bfbdb77745\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_internal_linkage2.C\n@@ -0,0 +1,13 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection -fmodules\" }\n+// Test std::meta::has_internal_linkage.\n+\n+module;\n+\n+#include <meta>\n+\n+module has_internal_linkage:counter;\n+\n+int counter = 0;\n+\n+static_assert (!std::meta::has_internal_linkage (^^counter));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_linkage1.C b/gcc/testsuite/g++.dg/reflect/has_linkage1.C\nnew file mode 100644\nindex 00000000000..3eeb1c575d5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_linkage1.C\n@@ -0,0 +1,149 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_linkage.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_linkage (null_reflection));\n+static_assert (has_linkage (^^::));\n+static_assert (has_linkage (^^ns));\n+static_assert (has_linkage (^^std));\n+static_assert (has_linkage (^^std::meta));\n+static_assert (has_linkage (^^ns_alias));\n+static_assert (!has_linkage (reflect_constant (3)));\n+static_assert (has_linkage (^^cls));\n+static_assert (!has_linkage (^^cls::dm));\n+static_assert (!has_linkage (^^cls::ref_dm));\n+static_assert (has_linkage (^^cls::static_dm));\n+static_assert (has_linkage (^^cls::mem_fun));\n+static_assert (has_linkage (^^cls::static_mem_fun));\n+static_assert (!has_linkage (^^cls::type));\n+static_assert (has_linkage (^^cls_var));\n+static_assert (has_linkage (^^onion));\n+static_assert (!has_linkage (^^anon));\n+static_assert (has_linkage (^^fun));\n+static_assert (!has_linkage (^^alias));\n+static_assert (has_linkage (^^var));\n+static_assert (has_linkage (^^ref));\n+static_assert (has_linkage (^^rref));\n+static_assert (has_linkage (^^ptr));\n+static_assert (has_linkage (^^cls_tmpl));\n+static_assert (has_linkage (^^cls_tmpl<int>));\n+static_assert (has_linkage (^^incomplete_cls<int>));\n+static_assert (has_linkage (^^fun_tmpl));\n+static_assert (has_linkage (^^fun_tmpl<int>));\n+static_assert (has_linkage (^^conc));\n+static_assert (!has_linkage (substitute (^^conc, { ^^int })));\n+static_assert (has_linkage (^^var_tmpl));\n+static_assert (has_linkage (^^var_tmpl<int>));\n+static_assert (!has_linkage (^^cls_tmpl_alias));\n+static_assert (!has_linkage (^^cls_tmpl_alias<int>));\n+static_assert (has_linkage (^^Enum));\n+static_assert (!has_linkage (^^Enum::A));\n+static_assert (has_linkage (^^Enum_class));\n+static_assert (!has_linkage (^^Enum_class::A));\n+static_assert (!has_linkage (^^decomp));\n+static_assert (!has_linkage (^^decomp_ref));\n+static_assert (has_linkage (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!has_linkage (dms));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_linkage (^^T));\n+ static_assert (has_linkage (R));\n+ static_assert (has_linkage (R2));\n+ static_assert (has_linkage (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ int v;\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (!has_linkage (^^p));\n+ static_assert (!has_linkage (^^c));\n+ static_assert (!has_linkage (^^v));\n+}\n+\n+static int var2;\n+static int baz () { return 0; }\n+\n+static_assert (has_linkage (^^var2));\n+static_assert (has_linkage (^^baz));\n+\n+namespace {\n+ void qux () {}\n+ int var3;\n+ namespace NN {\n+ int var4;\n+ }\n+ struct S2 {};\n+}\n+\n+namespace NM {\n+ int var5;\n+ struct S3 {};\n+}\n+\n+extern \"C\" {\n+ void corge (int);\n+}\n+\n+int\n+main ()\n+{\n+}\n+\n+const int ci = 42;\n+extern const int ci2 = 42;\n+\n+static_assert (has_linkage (^^qux));\n+static_assert (has_linkage (^^var3));\n+static_assert (has_linkage (^^NN));\n+static_assert (has_linkage (^^NN::var4));\n+static_assert (has_linkage (^^NM::var5));\n+static_assert (has_linkage (^^S2));\n+static_assert (has_linkage (^^NM::S3));\n+static_assert (has_linkage (^^corge));\n+static_assert (has_linkage (^^main));\n+static_assert (has_linkage (^^ci));\n+static_assert (has_linkage (^^ci2));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_module_linkage1.C b/gcc/testsuite/g++.dg/reflect/has_module_linkage1.C\nnew file mode 100644\nindex 00000000000..bc8887de88c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_module_linkage1.C\n@@ -0,0 +1,149 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection -fmodules\" }\n+// Test std::meta::has_module_linkage.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_module_linkage (null_reflection));\n+static_assert (!has_module_linkage (^^::));\n+static_assert (!has_module_linkage (^^ns));\n+static_assert (!has_module_linkage (^^std));\n+static_assert (!has_module_linkage (^^std::meta));\n+static_assert (!has_module_linkage (^^ns_alias));\n+static_assert (!has_module_linkage (reflect_constant (3)));\n+static_assert (!has_module_linkage (^^cls));\n+static_assert (!has_module_linkage (^^cls::dm));\n+static_assert (!has_module_linkage (^^cls::ref_dm));\n+static_assert (!has_module_linkage (^^cls::static_dm));\n+static_assert (!has_module_linkage (^^cls::mem_fun));\n+static_assert (!has_module_linkage (^^cls::static_mem_fun));\n+static_assert (!has_module_linkage (^^cls::type));\n+static_assert (!has_module_linkage (^^cls_var));\n+static_assert (!has_module_linkage (^^onion));\n+static_assert (!has_module_linkage (^^anon));\n+static_assert (!has_module_linkage (^^fun));\n+static_assert (!has_module_linkage (^^alias));\n+static_assert (!has_module_linkage (^^var));\n+static_assert (!has_module_linkage (^^ref));\n+static_assert (!has_module_linkage (^^rref));\n+static_assert (!has_module_linkage (^^ptr));\n+static_assert (!has_module_linkage (^^cls_tmpl));\n+static_assert (!has_module_linkage (^^cls_tmpl<int>));\n+static_assert (!has_module_linkage (^^incomplete_cls<int>));\n+static_assert (!has_module_linkage (^^fun_tmpl));\n+static_assert (!has_module_linkage (^^fun_tmpl<int>));\n+static_assert (!has_module_linkage (^^conc));\n+static_assert (!has_module_linkage (substitute (^^conc, { ^^int })));\n+static_assert (!has_module_linkage (^^var_tmpl));\n+static_assert (!has_module_linkage (^^var_tmpl<int>));\n+static_assert (!has_module_linkage (^^cls_tmpl_alias));\n+static_assert (!has_module_linkage (^^cls_tmpl_alias<int>));\n+static_assert (!has_module_linkage (^^Enum));\n+static_assert (!has_module_linkage (^^Enum::A));\n+static_assert (!has_module_linkage (^^Enum_class));\n+static_assert (!has_module_linkage (^^Enum_class::A));\n+static_assert (!has_module_linkage (^^decomp));\n+static_assert (!has_module_linkage (^^decomp_ref));\n+static_assert (!has_module_linkage (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!has_module_linkage (dms));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_module_linkage (^^T));\n+ static_assert (!has_module_linkage (R));\n+ static_assert (!has_module_linkage (R2));\n+ static_assert (!has_module_linkage (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ int v;\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (!has_module_linkage (^^p));\n+ static_assert (!has_module_linkage (^^c));\n+ static_assert (!has_module_linkage (^^v));\n+}\n+\n+static int var2;\n+static int baz () { return 0; }\n+\n+static_assert (!has_module_linkage (^^var2));\n+static_assert (!has_module_linkage (^^baz));\n+\n+namespace {\n+ void qux () {}\n+ int var3;\n+ namespace NN {\n+ int var4;\n+ }\n+ struct S2 {};\n+}\n+\n+namespace NM {\n+ int var5;\n+ struct S3 {};\n+}\n+\n+extern \"C\" {\n+ void corge (int);\n+}\n+\n+int\n+main ()\n+{\n+}\n+\n+const int ci = 42;\n+extern const int ci2 = 42;\n+\n+static_assert (!has_module_linkage (^^qux));\n+static_assert (!has_module_linkage (^^var3));\n+static_assert (!has_module_linkage (^^NN));\n+static_assert (!has_module_linkage (^^NN::var4));\n+static_assert (!has_module_linkage (^^NM::var5));\n+static_assert (!has_module_linkage (^^S2));\n+static_assert (!has_module_linkage (^^NM::S3));\n+static_assert (!has_module_linkage (^^corge));\n+static_assert (!has_module_linkage (^^main));\n+static_assert (!has_module_linkage (^^ci));\n+static_assert (!has_module_linkage (^^ci2));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_module_linkage2.C b/gcc/testsuite/g++.dg/reflect/has_module_linkage2.C\nnew file mode 100644\nindex 00000000000..fe0d14a58f8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_module_linkage2.C\n@@ -0,0 +1,13 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection -fmodules\" }\n+// Test std::meta::has_module_linkage.\n+\n+module;\n+\n+#include <meta>\n+\n+module has_module_linkage:counter;\n+\n+int counter = 0;\n+\n+static_assert (std::meta::has_module_linkage (^^counter));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_parent1.C b/gcc/testsuite/g++.dg/reflect/has_parent1.C\nnew file mode 100644\nindex 00000000000..8d5dd737795\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_parent1.C\n@@ -0,0 +1,138 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_parent.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_parent (null_reflection));\n+static_assert (!has_parent (^^::));\n+static_assert (has_parent (^^ns));\n+static_assert (has_parent (^^ns_alias));\n+static_assert (!has_parent (reflect_constant (3)));\n+static_assert (has_parent (^^cls));\n+static_assert (has_parent (^^cls::dm));\n+static_assert (has_parent (^^cls::ref_dm));\n+static_assert (has_parent (^^cls::static_dm));\n+static_assert (has_parent (^^cls::mem_fun));\n+static_assert (has_parent (^^cls::static_mem_fun));\n+static_assert (has_parent (^^cls::type));\n+static_assert (has_parent (^^cls_var));\n+static_assert (has_parent (^^onion));\n+static_assert (has_parent (^^anon));\n+static_assert (has_parent (^^fun));\n+static_assert (has_parent (^^alias));\n+static_assert (has_parent (^^var));\n+static_assert (has_parent (^^ref));\n+static_assert (has_parent (^^rref));\n+static_assert (has_parent (^^ptr));\n+static_assert (has_parent (^^cls_tmpl));\n+static_assert (has_parent (^^cls_tmpl<int>));\n+static_assert (has_parent (^^incomplete_cls<int>));\n+static_assert (has_parent (^^fun_tmpl));\n+static_assert (has_parent (^^fun_tmpl<int>));\n+static_assert (has_parent (^^conc));\n+static_assert (!has_parent (substitute (^^conc, { ^^int })));\n+static_assert (has_parent (^^var_tmpl));\n+static_assert (has_parent (^^var_tmpl<int>));\n+static_assert (has_parent (^^cls_tmpl_alias));\n+static_assert (has_parent (^^cls_tmpl_alias<int>));\n+static_assert (has_parent (^^Enum));\n+static_assert (has_parent (^^Enum::A));\n+static_assert (has_parent (^^Enum_class));\n+static_assert (has_parent (^^Enum_class::A));\n+static_assert (has_parent (^^decomp));\n+static_assert (has_parent (^^decomp_ref));\n+static_assert (has_parent (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!has_parent (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (has_parent (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_parent (^^T));\n+ static_assert (has_parent (R));\n+ static_assert (has_parent (R2));\n+ static_assert (has_parent (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (has_parent (^^p));\n+ static_assert (has_parent (^^c));\n+ static_assert (has_parent (parameters_of (^^g)[0]));\n+}\n+\n+int\n+main ()\n+{\n+}\n+\n+namespace N\n+{\n+ extern \"C\" void foo (int);\n+ void baz (int);\n+}\n+extern \"C\" void bar ();\n+\n+static_assert (!has_parent (^^main));\n+static_assert (!has_parent (^^N::foo));\n+static_assert (!has_parent (^^bar));\n+static_assert (has_parent (^^N::baz));\n+\n+enum F {\n+ F1,\n+ F2 = has_parent (^^F1),\n+ F3 = has_parent (^^F2) + 1,\n+};\n+static_assert (F2 == 1 && F3 == 2);\n+\n+void\n+qux ()\n+{\n+ auto a = [] () { int b; static_assert (has_parent (^^b)); };\n+ static_assert (has_parent (^^a));\n+ static_assert (has_parent (type_of (^^a)));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_template_arguments1.C b/gcc/testsuite/g++.dg/reflect/has_template_arguments1.C\nnew file mode 100644\nindex 00000000000..0062f0f43d7\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_template_arguments1.C\n@@ -0,0 +1,111 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_template_arguments.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+using U = cls_tmpl<int>;\n+typedef cls_tmpl<int> TYPE;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!has_template_arguments (^^int));\n+static_assert (!has_template_arguments (null_reflection));\n+static_assert (!has_template_arguments (^^::));\n+static_assert (!has_template_arguments (^^ns));\n+static_assert (!has_template_arguments (^^ns_alias));\n+static_assert (!has_template_arguments (reflect_constant (3)));\n+static_assert (!has_template_arguments (^^cls));\n+static_assert (!has_template_arguments (^^cls::dm));\n+static_assert (!has_template_arguments (^^cls::ref_dm));\n+static_assert (!has_template_arguments (^^cls::static_dm));\n+static_assert (!has_template_arguments (^^cls::mem_fun));\n+static_assert (!has_template_arguments (^^cls::static_mem_fun));\n+static_assert (!has_template_arguments (^^cls::type));\n+static_assert (!has_template_arguments (^^cls_var));\n+static_assert (!has_template_arguments (^^onion));\n+static_assert (!has_template_arguments (^^anon));\n+static_assert (!has_template_arguments (^^fun));\n+static_assert (!has_template_arguments (^^alias));\n+static_assert (!has_template_arguments (^^var));\n+static_assert (!has_template_arguments (^^ref));\n+static_assert (!has_template_arguments (^^rref));\n+static_assert (!has_template_arguments (^^ptr));\n+static_assert (!has_template_arguments (^^cls_tmpl));\n+static_assert (has_template_arguments (^^cls_tmpl<int>));\n+static_assert (has_template_arguments (^^incomplete_cls<int>));\n+static_assert (!has_template_arguments (^^fun_tmpl));\n+static_assert (has_template_arguments (^^fun_tmpl<int>));\n+static_assert (!has_template_arguments (^^conc));\n+static_assert (!has_template_arguments (substitute (^^conc, { ^^int })));\n+static_assert (!has_template_arguments (^^var_tmpl));\n+static_assert (has_template_arguments (^^var_tmpl<int>));\n+static_assert (!has_template_arguments (^^cls_tmpl_alias));\n+static_assert (has_template_arguments (^^cls_tmpl_alias<int>));\n+static_assert (!has_template_arguments (^^Enum));\n+static_assert (!has_template_arguments (^^Enum::A));\n+static_assert (!has_template_arguments (^^Enum_class));\n+static_assert (!has_template_arguments (^^Enum_class::A));\n+static_assert (!has_template_arguments (^^decomp));\n+static_assert (!has_template_arguments (^^decomp_ref));\n+static_assert (!has_template_arguments (^^arr));\n+static_assert (!has_template_arguments (^^U));\n+static_assert (!has_template_arguments (^^TYPE));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!has_template_arguments (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!has_template_arguments (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!has_template_arguments (^^T));\n+ static_assert (!has_template_arguments (R));\n+ static_assert (has_template_arguments (R2));\n+ static_assert (has_template_arguments (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^var_tmpl<int>, ^^cls_tmpl<int>>();\n+ static_assert (!has_template_arguments (^^p));\n+ static_assert (!has_template_arguments (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_template_arguments2.C b/gcc/testsuite/g++.dg/reflect/has_template_arguments2.C\nnew file mode 100644\nindex 00000000000..db22eb40091\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_template_arguments2.C\n@@ -0,0 +1,75 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_template_arguments.\n+\n+#include <meta>\n+#include <vector>\n+\n+using namespace std::meta;\n+\n+template <typename P1, auto P2, template <typename...> class P3>\n+struct class_tmpl {\n+ template <typename> struct inner {};\n+};\n+static_assert (!has_template_arguments (^^class_tmpl));\n+static_assert (has_template_arguments (^^class_tmpl<int, 9, std::vector>));\n+\n+template <typename P1, auto P2, template <typename...> class P3>\n+void fn_tmpl ();\n+static_assert (!has_template_arguments (^^fn_tmpl));\n+static_assert (has_template_arguments (^^fn_tmpl<int, 9, std::vector>));\n+\n+template <typename P1, auto P2, template <typename...> class P3>\n+int var_tmpl = 0;\n+static_assert (!has_template_arguments (^^var_tmpl));\n+static_assert (has_template_arguments (^^var_tmpl<int, 9, std::vector>));\n+\n+template <typename P1, auto P2, template <typename...> class P3>\n+using alias = int;\n+static_assert (!has_template_arguments (^^alias));\n+static_assert (has_template_arguments (^^alias<int, 9, std::vector>));\n+\n+template <typename T>\n+using dep_alias = class_tmpl<int, 9, std::vector>::template inner<T>;\n+static_assert (!has_template_arguments (^^dep_alias));\n+static_assert (has_template_arguments (^^dep_alias<int>));\n+\n+struct Der : class_tmpl<int, 9, std::vector> {};\n+static_assert (!has_template_arguments (^^Der));\n+\n+template <typename T, T> struct A {};\n+static_assert (!has_template_arguments (^^A));\n+static_assert (has_template_arguments (^^A<int, 5>));\n+\n+template <typename... Ts> struct B {};\n+static_assert (!has_template_arguments (^^B));\n+static_assert (has_template_arguments (^^B<int, bool>));\n+\n+struct S {\n+ int mem;\n+ bool operator==(const S&) const = default;\n+};\n+template <auto... Vs> struct auto_pack {};\n+static_assert (!has_template_arguments (^^auto_pack));\n+static_assert (has_template_arguments (^^auto_pack<4, S{3}>));\n+\n+template <float> struct float_targ {};\n+constexpr float F = 4.5f;\n+static_assert (!has_template_arguments (^^float_targ));\n+static_assert (has_template_arguments (^^float_targ<F>));\n+\n+template <const float *> struct ptr_targ {};\n+constexpr float Fs[] = {4.5, 5.5, 6.5};\n+static_assert (!has_template_arguments (^^ptr_targ));\n+static_assert (has_template_arguments (^^ptr_targ<Fs>));\n+static_assert (has_template_arguments (^^ptr_targ<nullptr>));\n+\n+template <const int &> struct ref_targ {};\n+const int I = 5;\n+using T = ref_targ<I>;\n+static_assert (!has_template_arguments (^^ref_targ));\n+static_assert (has_template_arguments (dealias(^^T)));\n+\n+template <std::meta::info> struct refl_targ {};\n+static_assert (!has_template_arguments (^^refl_targ));\n+static_assert (has_template_arguments (^^refl_targ<^^int>));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_template_arguments3.C b/gcc/testsuite/g++.dg/reflect/has_template_arguments3.C\nnew file mode 100644\nindex 00000000000..c36027ed153\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_template_arguments3.C\n@@ -0,0 +1,48 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_template_arguments.\n+\n+#include <meta>\n+#include <vector>\n+\n+using namespace std::meta;\n+\n+struct S {\n+ template<typename T>\n+ struct N { };\n+};\n+\n+template<typename T>\n+struct TS {\n+ template<typename U>\n+ struct N { };\n+};\n+\n+static_assert (!has_template_arguments (^^S::N));\n+static_assert (has_template_arguments (^^S::N<int>));\n+static_assert (!has_template_arguments (^^TS<int>::N));\n+static_assert (has_template_arguments (^^TS<int>::N<int>));\n+\n+template<typename T>\n+struct A { };\n+\n+template<typename T>\n+struct A<T*> { };\n+\n+template<>\n+struct A<int> { };\n+\n+static_assert (!has_template_arguments (^^A));\n+static_assert (has_template_arguments (^^A<int>));\n+static_assert (has_template_arguments (^^A<int *>));\n+\n+template<typename = int>\n+struct B { };\n+static_assert (has_template_arguments (^^B<>));\n+\n+struct C {\n+ using Alias = A<int>;\n+};\n+\n+static_assert (has_template_arguments (dealias (^^C::Alias)));\n+static_assert (!has_template_arguments (^^C::Alias));\ndiff --git a/gcc/testsuite/g++.dg/reflect/has_template_arguments4.C b/gcc/testsuite/g++.dg/reflect/has_template_arguments4.C\nnew file mode 100644\nindex 00000000000..42f1461d388\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/has_template_arguments4.C\n@@ -0,0 +1,23 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::has_template_arguments.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+struct S {\n+ template<typename T>\n+ void fn (T) { }\n+};\n+\n+template<typename T>\n+struct TS {\n+ template<typename U>\n+ void fn (T) { }\n+};\n+\n+static_assert (!has_template_arguments (^^S::fn));\n+static_assert (has_template_arguments (^^S::fn<int>));\n+static_assert (!has_template_arguments (^^TS<int>::fn));\n+static_assert (has_template_arguments (^^TS<int>::fn<int>));\ndiff --git a/gcc/testsuite/g++.dg/reflect/identifier_of1.C b/gcc/testsuite/g++.dg/reflect/identifier_of1.C\nnew file mode 100644\nindex 00000000000..c51d864575e\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/identifier_of1.C\n@@ -0,0 +1,181 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::identifier_of.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+struct C { };\n+\n+constexpr std::string_view sv = identifier_of (^^C);\n+static_assert (sv == \"C\");\n+static_assert (sv.data ()[0] == 'C');\n+static_assert (sv.data ()[1] == '\\0');\n+\n+struct S { };\n+using T = int;\n+using U = S;\n+enum E { E1, E2 };\n+enum { E3, E4 };\n+typedef enum { E5, E6 } E7;\n+\n+static_assert (identifier_of (^^T) == std::string_view (\"T\"));\n+static_assert (identifier_of (^^S) == std::string_view (\"S\"));\n+static_assert (identifier_of (^^U) == std::string_view (\"U\"));\n+static_assert (identifier_of (^^std) == std::string_view (\"std\"));\n+static_assert (identifier_of (^^std::meta) == std::string_view (\"meta\"));\n+static_assert (identifier_of (^^E1) == std::string_view (\"E1\"));\n+static_assert (identifier_of (^^E) == std::string_view (\"E\"));\n+static_assert (identifier_of (parent_of (^^E5)) == std::string_view (\"E7\"));\n+static_assert (identifier_of (^^E7) == std::string_view (\"E7\"));\n+static_assert (identifier_of (dealias (^^E7)) == std::string_view (\"E7\"));\n+static_assert (identifier_of (data_member_spec (^^long, { .name = \"foo\", .bit_width = 6 })) == std::string_view (\"foo\"));\n+static_assert (identifier_of (data_member_spec (^^long, { .name = \"extremely_long_string_used_as_identifier\" })) == std::string_view (\"extremely_long_string_used_as_identifier\"));\n+\n+namespace N {}\n+namespace NA = N;\n+static_assert (identifier_of (^^N) == std::string_view (\"N\"));\n+static_assert (identifier_of (^^NA) == std::string_view (\"NA\"));\n+\n+namespace {\n+ int a;\n+ namespace M {}\n+ static_assert (identifier_of (^^a) == std::string_view (\"a\"));\n+ static_assert (identifier_of (^^M) == std::string_view (\"M\"));\n+}\n+\n+typedef struct {\n+ int a;\n+ static_assert (identifier_of (^^a) == std::string_view (\"a\"));\n+} SV;\n+static_assert (identifier_of (^^SV) == std::string_view (\"SV\"));\n+static_assert (identifier_of (parent_of (^^SV::a)) == std::string_view (\"SV\"));\n+static_assert (identifier_of (dealias (^^SV)) == std::string_view (\"SV\"));\n+\n+template <int N>\n+struct ST\n+{\n+ static_assert (identifier_of (^^ST) == std::string_view (\"ST\"));\n+};\n+static_assert (identifier_of (^^ST) == std::string_view (\"ST\"));\n+\n+struct V\n+{\n+ void foo () { int a; static_assert (identifier_of (parent_of (^^a)) == std::string_view (\"foo\")); }\n+ template <int N>\n+ void bar () { int a; static_assert (identifier_of (parent_of (^^a)) == std::string_view (\"bar\")); }\n+};\n+static_assert (identifier_of (^^V::foo) == std::string_view (\"foo\"));\n+static_assert (identifier_of (^^V::bar) == std::string_view (\"bar\"));\n+\n+int\n+operator \"\"_a (const char *)\n+{\n+ int a;\n+ static_assert (identifier_of (parent_of (^^a)) == std::string_view (\"_a\"));\n+ return 0;\n+}\n+\n+int v;\n+static_assert (identifier_of (^^v) == std::string_view (\"v\"));\n+template<typename T>\n+T vtempl;\n+static_assert (identifier_of (^^vtempl) == std::string_view (\"vtempl\"));\n+\n+void foo (int);\n+static_assert (identifier_of (^^foo) == std::string_view (\"foo\"));\n+\n+int arr[3];\n+\n+void\n+foo (int a)\n+{\n+ auto [b, c, d] = arr;\n+ static_assert (identifier_of (^^foo) == std::string_view (\"foo\"));\n+ static_assert (identifier_of (^^a) == std::string_view (\"a\"));\n+ static_assert (identifier_of (^^b) == std::string_view (\"b\"));\n+ static_assert (identifier_of (^^c) == std::string_view (\"c\"));\n+ static_assert (identifier_of (^^d) == std::string_view (\"d\"));\n+}\n+\n+template <int N>\n+void\n+bar (int a)\n+{\n+ auto [...b, c] = arr;\n+ static_assert (identifier_of (^^a) == std::string_view (\"a\"));\n+ static_assert (identifier_of (^^c) == std::string_view (\"c\"));\n+}\n+static_assert (identifier_of (^^bar) == std::string_view (\"bar\"));\n+\n+void\n+baz ()\n+{\n+ auto a = [] {\n+ int a;\n+ static_assert (identifier_of (^^a) == std::string_view (\"a\"));\n+ static_assert (identifier_of (parent_of (parent_of (parent_of (^^a)))) == std::string_view (\"baz\"));\n+ };\n+ using t = decltype (a);\n+ static_assert (identifier_of (^^t) == std::string_view (\"t\"));\n+}\n+\n+void qux (int, int b, int c, int d, int);\n+constexpr auto p0 = parameters_of (^^qux)[0];\n+constexpr auto p1 = parameters_of (^^qux)[1];\n+constexpr auto p2 = parameters_of (^^qux)[2];\n+constexpr auto p3 = parameters_of (^^qux)[3];\n+constexpr auto p4 = parameters_of (^^qux)[4];\n+static_assert (identifier_of (p1) == std::string_view (\"b\"));\n+static_assert (identifier_of (p2) == std::string_view (\"c\"));\n+static_assert (identifier_of (p3) == std::string_view (\"d\"));\n+void qux (int a, int, int c, int e, int);\n+static_assert (identifier_of (p0) == std::string_view (\"a\"));\n+static_assert (identifier_of (p1) == std::string_view (\"b\"));\n+static_assert (identifier_of (p2) == std::string_view (\"c\"));\n+\n+void\n+qux (int a, int, int, int e, int)\n+{\n+ static_assert (identifier_of (p0) == std::string_view (\"a\"));\n+ static_assert (identifier_of (p1) == std::string_view (\"b\"));\n+ static_assert (identifier_of (p2) == std::string_view (\"c\"));\n+ static_assert (identifier_of (variable_of (p0)) == std::string_view (\"a\"));\n+ static_assert (identifier_of (variable_of (p3)) == std::string_view (\"e\"));\n+}\n+\n+void qux (int f, int, int, int, int g);\n+static_assert (identifier_of (p1) == std::string_view (\"b\"));\n+static_assert (identifier_of (p2) == std::string_view (\"c\"));\n+static_assert (identifier_of (p4) == std::string_view (\"g\"));\n+\n+template <typename... T>\n+void\n+freddy (int a, T... b)\n+{\n+}\n+\n+static_assert (identifier_of (parameters_of (^^freddy <int, long, char>)[0]) == std::string_view (\"a\"));\n+\n+struct {\n+ int a;\n+} s;\n+\n+static_assert (identifier_of (^^s) == std::string_view (\"s\"));\n+\n+typedef struct {\n+ int b;\n+} TN;\n+\n+static_assert (identifier_of (parent_of (^^TN::b)) == std::string_view (\"TN\"));\n+static_assert (identifier_of (^^TN) == std::string_view (\"TN\"));\n+static_assert (identifier_of (dealias (^^TN)) == std::string_view (\"TN\"));\n+\n+typedef enum {\n+ E8,\n+ E9\n+} E10;\n+static_assert (identifier_of (parent_of (^^E8)) == std::string_view (\"E10\"));\n+static_assert (identifier_of (^^E10) == std::string_view (\"E10\"));\n+static_assert (identifier_of (dealias (^^E10)) == std::string_view (\"E10\"));\ndiff --git a/gcc/testsuite/g++.dg/reflect/identifier_of2.C b/gcc/testsuite/g++.dg/reflect/identifier_of2.C\nnew file mode 100644\nindex 00000000000..115382fb5a3\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/identifier_of2.C\n@@ -0,0 +1,6 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-require-iconv \"IBM1047\" }\n+// { dg-additional-options \"-freflection -fexec-charset=IBM1047\" }\n+// Test std::meta::identifier_of.\n+\n+#include \"identifier_of1.C\"\ndiff --git a/gcc/testsuite/g++.dg/reflect/init1.C b/gcc/testsuite/g++.dg/reflect/init1.C\nnew file mode 100644\nindex 00000000000..7de12a4d1c2\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init1.C\n@@ -0,0 +1,59 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test various forms of initialization with reflections.\n+\n+#include <initializer_list>\n+\n+using info = decltype(^^int);\n+\n+struct S { int i; };\n+struct X {\n+ consteval operator info() { return ^^int; }\n+};\n+\n+struct Y {\n+ info i = ^^int;\n+};\n+\n+constexpr Y y;\n+\n+struct W {\n+ consteval W() { }\n+ decltype(^^::) i = ^^W::i;\n+};\n+\n+constinit info r = ^^int;\n+constinit info *p = &r;\n+\n+consteval void\n+f ()\n+{\n+ constexpr auto refl = ^^S;\n+ auto a1 = refl;\n+ auto a2(refl);\n+ auto a3 = { refl };\n+ auto a4{refl};\n+\n+ constexpr decltype(refl) arr[] = { refl };\n+ constexpr auto ra = arr[0];\n+ typename [: ra :] s = { .i = 42 };\n+\n+ constexpr static auto srefl = ^^S;\n+ constexpr static auto *p = &srefl;\n+ constexpr auto *const *q = &p;\n+ typename [: **q :] s2 = { .i = 42 };\n+}\n+\n+void\n+g ()\n+{\n+ f ();\n+}\n+\n+void\n+h ()\n+{\n+ X x;\n+ typename [: x :] i = 42;\n+ typename [: X{} :] j = i;\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/init10.C b/gcc/testsuite/g++.dg/reflect/init10.C\nnew file mode 100644\nindex 00000000000..115c3eeac12\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init10.C\n@@ -0,0 +1,24 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test member list initializers.\n+\n+using info = decltype(^^int);\n+\n+struct A {\n+ info i;\n+ consteval A() : i{^^void} {}\n+};\n+\n+A a1; // { dg-error \"consteval-only variable .a1.\" }\n+constinit A a2;\n+constexpr A a3;\n+\n+struct B {\n+ info i;\n+ info j;\n+ consteval B() : i{}, j{i} {}\n+};\n+\n+B b1; // { dg-error \"consteval-only variable .b1.\" }\n+constinit B b2;\n+constexpr B b3;\ndiff --git a/gcc/testsuite/g++.dg/reflect/init11.C b/gcc/testsuite/g++.dg/reflect/init11.C\nnew file mode 100644\nindex 00000000000..7173023e602\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init11.C\n@@ -0,0 +1,25 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test invalid reflections in member init lists.\n+\n+using info = decltype(^^void);\n+\n+struct A {\n+ info i;\n+ constexpr A() : i{^^void} {} // { dg-error \"consteval-only\" }\n+};\n+\n+struct B {\n+ info i;\n+ B() : i{^^void} {} // { dg-error \"consteval-only\" }\n+};\n+\n+struct C {\n+ info i;\n+ constexpr C() : i{} {} // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+};\n+\n+struct D {\n+ info i;\n+ D() : i{} {} // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+};\ndiff --git a/gcc/testsuite/g++.dg/reflect/init12.C b/gcc/testsuite/g++.dg/reflect/init12.C\nnew file mode 100644\nindex 00000000000..8ec456d1cba\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init12.C\n@@ -0,0 +1,29 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test consteval-only type smuggling.\n+\n+using info = decltype(^^int);\n+\n+template<typename T>\n+constexpr const void *\n+foo (const T *__location)\n+{\n+ const void *__loc = __location;\n+ return __loc;\n+}\n+\n+template<typename T>\n+constexpr const void *\n+bar (const T *__location)\n+{\n+ const void *__loc = __location;\n+ return __loc;\n+}\n+\n+void\n+g ()\n+{\n+ constexpr static auto r = ^^int;\n+ constexpr auto x = foo<info>(&r); // { dg-error \"pointer into an object of consteval-only type\" }\n+ constexpr auto y = bar<info>(nullptr);\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/init13.C b/gcc/testsuite/g++.dg/reflect/init13.C\nnew file mode 100644\nindex 00000000000..6b9277a971a\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init13.C\n@@ -0,0 +1,55 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^::);\n+\n+constexpr info A {};\n+constexpr info B = ^^::;\n+inline constexpr info C = ^^::;\n+\n+template<typename T>\n+struct S {\n+ static constexpr info B {^^T};\n+\n+ void wow () {\n+ constexpr info D {^^T};\n+ }\n+};\n+\n+consteval void\n+foo ()\n+{\n+ info A = ^^::;\n+ constexpr info B = ^^::;\n+}\n+\n+constexpr void\n+bar ()\n+{\n+ constexpr info A = ^^::;\n+ static constexpr info B = ^^::;\n+}\n+\n+constexpr void\n+tux ()\n+{\n+ if consteval {\n+ constexpr info A = ^^::;\n+ static constexpr info B = ^^::;\n+ }\n+}\n+\n+void\n+qux ()\n+{\n+ constexpr info A {};\n+ constexpr info B = ^^::;\n+ static constexpr info C = ^^::;\n+ foo ();\n+ consteval { bar (); }\n+ consteval { tux (); }\n+ tux ();\n+ bar ();\n+}\n+\n+template struct S<int>;\ndiff --git a/gcc/testsuite/g++.dg/reflect/init14.C b/gcc/testsuite/g++.dg/reflect/init14.C\nnew file mode 100644\nindex 00000000000..e0e95d47deb\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init14.C\n@@ -0,0 +1,16 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+template<typename T>\n+struct S {\n+ static constexpr auto s = ^^T;\n+ void foo () { constexpr auto s = ^^T; }\n+};\n+template struct S<int>;\n+\n+constexpr void\n+bud ()\n+{\n+ if consteval { static constexpr auto a = ^^::; }\n+}\n+auto bar () { return &bud; }\ndiff --git a/gcc/testsuite/g++.dg/reflect/init15.C b/gcc/testsuite/g++.dg/reflect/init15.C\nnew file mode 100644\nindex 00000000000..1e9836395f0\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init15.C\n@@ -0,0 +1,29 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^::);\n+\n+consteval info identity(info i) { return i; }\n+consteval int something_of(info) { return 10; }\n+consteval void do_something(info) {}\n+\n+void fox() {\n+ if not consteval {\n+ constexpr info X {};\n+ constexpr info A = ^^::;\n+ constexpr info B = identity(A);\n+ static constexpr info D = ^^::;\n+\n+ static_assert(X == info{});\n+ static_assert(A == ^^::);\n+ static_assert(B == ^^::);\n+ static_assert(D == ^^::);\n+\n+ consteval {\n+ do_something(X);\n+ do_something(A);\n+ int H = something_of(A);\n+ constexpr int I = something_of(A);\n+ }\n+ }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/init16.C b/gcc/testsuite/g++.dg/reflect/init16.C\nnew file mode 100644\nindex 00000000000..621b1c57d3b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init16.C\n@@ -0,0 +1,47 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^::);\n+\n+consteval info identity(info i) {\n+ return i;\n+}\n+\n+consteval int something_of(info) {\n+ return 10;\n+}\n+\n+consteval void do_something(info) {}\n+\n+template <info>\n+void do_something_runtime() {}\n+\n+void fox() {\n+ if not consteval {\n+ constexpr info X {};\n+ constexpr info A = ^^::;\n+ constexpr info B = identity(A);\n+ static constexpr info D = ^^::;\n+\n+ static_assert(X == info{});\n+ static_assert(A == ^^::);\n+ static_assert(B == ^^::);\n+ static_assert(D == ^^::);\n+\n+ consteval {\n+ do_something(X);\n+ do_something(A);\n+ int H = something_of(A);\n+ constexpr int I = something_of(A);\n+ }\n+\n+ do_something(X);\n+ do_something(A);\n+ do_something_runtime<X>();\n+ do_something_runtime<A>();\n+ int C = something_of(A);\n+ constexpr int E = something_of(A);\n+ identity(A); // { dg-error \"consteval-only expressions\" }\n+ identity(B); // { dg-error \"consteval-only expressions\" }\n+ }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/init17.C b/gcc/testsuite/g++.dg/reflect/init17.C\nnew file mode 100644\nindex 00000000000..c0bb11e070b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init17.C\n@@ -0,0 +1,30 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^int);\n+\n+consteval int\n+foo (info i)\n+{\n+ return 42;\n+}\n+\n+consteval info\n+bar ()\n+{\n+ return __extension__ ({ constexpr auto a = ^^int; a; });\n+}\n+\n+struct S {\n+ info i;\n+};\n+\n+void\n+g ()\n+{\n+ __extension__ constexpr int i = foo (({ constexpr auto a = ^^int; a; }));\n+ __extension__ static constexpr info r = ({ constexpr auto a = ^^int; a; });\n+ constexpr info o = bar ();\n+ __extension__ constexpr auto sz = sizeof (({ constexpr auto a = ^^int; a; }));\n+ __extension__ constexpr S s{({ constexpr auto a = ^^int; a; })};\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/init2.C b/gcc/testsuite/g++.dg/reflect/init2.C\nnew file mode 100644\nindex 00000000000..4c248fd9821\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init2.C\n@@ -0,0 +1,18 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test various forms of initialization with reflections. Invalid.\n+\n+consteval void\n+f ()\n+{\n+ constexpr static auto srefl = ^^int;\n+ constexpr auto *p = &srefl;\n+ constexpr auto **q = &p; // { dg-error \"unable to deduce\" }\n+ // { dg-message \"types .auto\\\\*. and .std::meta::info\\\\* const.\" \"\" { target *-*-* } .-1 }\n+}\n+\n+void\n+g ()\n+{\n+ f ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/init3.C b/gcc/testsuite/g++.dg/reflect/init3.C\nnew file mode 100644\nindex 00000000000..d5313609291\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init3.C\n@@ -0,0 +1,8 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+template <auto R = ^^::> class S {};\n+S s;\n+\n+template <auto R = ^^int> class S2 {};\n+S2 s2;\ndiff --git a/gcc/testsuite/g++.dg/reflect/init4.C b/gcc/testsuite/g++.dg/reflect/init4.C\nnew file mode 100644\nindex 00000000000..6d9a39b40e0\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init4.C\n@@ -0,0 +1,63 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test that we properly detect compounded consteval-only types.\n+\n+using info = decltype(^^int);\n+constexpr static info glob = ^^::;\n+constexpr info array[3] = { glob, glob, glob };\n+consteval info foo () { return ^^::; }\n+\n+struct A {\n+ info i = ^^int;\n+};\n+constexpr A a;\n+\n+struct B {\n+ A a;\n+};\n+constexpr B b;\n+\n+struct C {\n+ const info *i = &glob;\n+};\n+constexpr C c;\n+\n+struct D {\n+ int i;\n+ C c;\n+ consteval D() : c{}, i{42} { }\n+};\n+constexpr D d;\n+\n+struct E {\n+ info arr[2];\n+ consteval E() : arr{glob, glob} { }\n+};\n+constexpr E e;\n+\n+struct F {\n+ const info &r;\n+ consteval F() : r{glob} { }\n+};\n+constexpr F f;\n+\n+struct G {\n+ B b;\n+};\n+constexpr G g;\n+\n+struct H {\n+ info (*fp)();\n+};\n+constexpr H h{foo}; // { dg-error \"address of immediate function\" }\n+\n+union U {\n+ int n;\n+ info i;\n+};\n+constexpr U u{.i = glob };\n+\n+struct I {\n+ info i;\n+};\n+constexpr info I::*pmi = &I::i;\ndiff --git a/gcc/testsuite/g++.dg/reflect/init5.C b/gcc/testsuite/g++.dg/reflect/init5.C\nnew file mode 100644\nindex 00000000000..dd9f07bf4d6\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init5.C\n@@ -0,0 +1,21 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^void);\n+\n+struct Base { };\n+struct Derived : Base {\n+ info k;\n+ consteval Derived() : Base(), k(^^int) {}\n+};\n+consteval const Base &fn1() {\n+ static constexpr Derived d;\n+ return d;\n+}\n+constexpr auto &ref = fn1(); // { dg-error \"reference into an object of consteval-only type\" }\n+\n+consteval void *fn2() {\n+ static constexpr auto v = ^^int;\n+ return (void *)&v;\n+}\n+constexpr const void *ptr = fn2(); // { dg-error \"pointer into an object of consteval-only type\" }\ndiff --git a/gcc/testsuite/g++.dg/reflect/init6.C b/gcc/testsuite/g++.dg/reflect/init6.C\nnew file mode 100644\nindex 00000000000..3febb88cba5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init6.C\n@@ -0,0 +1,37 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+using info = decltype(^^int);\n+\n+struct S {\n+ info i;\n+};\n+\n+struct N {\n+ info i = ^^void;\n+};\n+\n+S s1; // { dg-error \"consteval-only variable\" }\n+constinit S s2{};\n+constexpr S s3{^^int};\n+\n+N n1; // { dg-error \"consteval-only variable\" }\n+constinit N n2;\n+constexpr N n3;\n+\n+template<typename T>\n+struct X {\n+ T t;\n+};\n+\n+X<info> x1; // { dg-error \"consteval-only variable\" }\n+constinit X<info> x2{};\n+constexpr X<info> x3{^^int};\n+\n+void\n+g ()\n+{\n+ static constexpr S s{^^void};\n+ static constexpr X<info> x{^^void};\n+ static constexpr N n;\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/init7.C b/gcc/testsuite/g++.dg/reflect/init7.C\nnew file mode 100644\nindex 00000000000..3f8405ba2bc\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init7.C\n@@ -0,0 +1,41 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test that we properly detect using consteval-only variables without\n+// constexpr/constinit.\n+\n+using info = decltype(^^int);\n+\n+info r1 = ^^int; // { dg-error \"consteval-only variable .r1. not declared .constexpr. used outside a constant-evaluated context\" }\n+const info r2 = ^^int; // { dg-error \"consteval-only variable .r2. not declared .constexpr. used outside a constant-evaluated context\" }\n+\n+constexpr info r3 = ^^int;\n+constinit info r4 = ^^int;\n+const info *const p1 = &r3; // { dg-error \"consteval-only variable .p1. not declared .constexpr. used outside a constant-evaluated context\" }\n+info *p2; // { dg-error \"consteval-only variable .p2. not declared .constexpr. used outside a constant-evaluated context\" }\n+const info &q = r3; // { dg-error \"consteval-only variable .q. not declared .constexpr. used outside a constant-evaluated context\" }\n+\n+void\n+g ()\n+{\n+ info l1 = ^^int; // { dg-error \"consteval-only variable .l1. not declared .constexpr. used outside a constant-evaluated context\" }\n+ const info l2 = ^^int; // { dg-error \"consteval-only variable .l2. not declared .constexpr. used outside a constant-evaluated context\" }\n+ constexpr info l3 = ^^int;\n+ static info l4 = ^^int; // { dg-error \"consteval-only variable .l4. not declared .constexpr. used outside a constant-evaluated context\" }\n+ static const info l5 = ^^int; // { dg-error \"consteval-only variable .l5. not declared .constexpr. used outside a constant-evaluated context\" }\n+ static constexpr info l6 = ^^int;\n+ static constinit info l7 = ^^int;\n+}\n+\n+consteval void\n+f ()\n+{\n+ info l1 = ^^int;\n+ const info l2 = ^^int;\n+ constexpr info l3 = ^^int;\n+ // Are these really OK? Only if we don't call this function, I suppose.\n+ // See error8.C for that scenario.\n+ static info l4 = ^^int;\n+ static const info l5 = ^^int;\n+ static constexpr info l6 = ^^int;\n+ static constinit info l7 = ^^int;\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/init8.C b/gcc/testsuite/g++.dg/reflect/init8.C\nnew file mode 100644\nindex 00000000000..b044c5b69d8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init8.C\n@@ -0,0 +1,16 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test member list initializers.\n+\n+using info = decltype(^^int);\n+\n+struct A {\n+ info i;\n+ consteval A() : i{^^void} {}\n+};\n+\n+static_assert (A{}.i == ^^void);\n+constexpr A a;\n+static_assert (a.i == ^^void);\n+constexpr A a2;\n+static_assert (a2.i == ^^void);\ndiff --git a/gcc/testsuite/g++.dg/reflect/init9.C b/gcc/testsuite/g++.dg/reflect/init9.C\nnew file mode 100644\nindex 00000000000..c088a2d9a7c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/init9.C\n@@ -0,0 +1,53 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test returning consteval-only exprs.\n+\n+using info = decltype(^^int);\n+\n+info foo (); // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+constexpr info bar (); // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+void baz (info); // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+\n+consteval info\n+ok1 ()\n+{\n+ return ^^int;\n+}\n+\n+consteval info\n+ok2 ()\n+{\n+ constexpr info r = ^^int;\n+ return r;\n+}\n+\n+consteval auto\n+ok3 (info i)\n+{\n+ return i;\n+}\n+\n+constexpr info\n+bad1 () // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+{\n+ return ^^int; // { dg-error \"consteval-only expressions\" }\n+}\n+\n+info\n+bad2 () // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+{\n+ return ^^int; // { dg-error \"consteval-only expressions\" }\n+}\n+\n+constexpr auto\n+bad3 (info i) // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+{\n+ return i; // { dg-error \"consteval-only expressions\" }\n+}\n+\n+template<info R>\n+info\n+bad4 () // { dg-error \"function of consteval-only type must be declared .consteval.\" }\n+{\n+ return R; // { dg-error \"consteval-only expressions\" }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_accessible1.C b/gcc/testsuite/g++.dg/reflect/is_accessible1.C\nnew file mode 100644\nindex 00000000000..87f12d59fcf\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_accessible1.C\n@@ -0,0 +1,131 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_accessible.\n+\n+#include <meta>\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 <int N>\n+ void foo ();\n+ template <int N>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+constexpr access_context gctx = access_context::current ();\n+\n+static_assert (is_accessible (null_reflection, gctx));\n+static_assert (is_accessible (^^::, gctx));\n+static_assert (is_accessible (^^ns, gctx));\n+static_assert (is_accessible (^^ns_alias, gctx));\n+static_assert (is_accessible (reflect_constant (3), gctx));\n+static_assert (is_accessible (^^cls, gctx));\n+static_assert (is_accessible (^^cls::dm, gctx));\n+static_assert (is_accessible (^^cls::ref_dm, gctx));\n+static_assert (is_accessible (^^cls::static_dm, gctx));\n+static_assert (is_accessible (^^cls::mem_fun, gctx));\n+static_assert (is_accessible (^^cls::static_mem_fun, gctx));\n+static_assert (is_accessible (^^cls::type, gctx));\n+static_assert (is_accessible (^^cls::E, gctx));\n+static_assert (is_accessible (^^cls::B, gctx));\n+static_assert (is_accessible (^^cls::C, gctx));\n+static_assert (is_accessible (^^cls::D, gctx));\n+static_assert (is_accessible (^^cls::F, gctx));\n+static_assert (is_accessible (^^cls::F::G, gctx));\n+static_assert (is_accessible (^^cls::F::H, gctx));\n+static_assert (is_accessible (^^cls::S, gctx));\n+static_assert (is_accessible (^^cls::U, gctx));\n+static_assert (is_accessible (^^cls::foo, gctx));\n+static_assert (is_accessible (^^cls::foo <0>, gctx));\n+static_assert (is_accessible (^^cls::bar, gctx));\n+static_assert (is_accessible (^^cls::bar <42>, gctx));\n+static_assert (is_accessible (^^cls_var, gctx));\n+static_assert (is_accessible (^^onion, gctx));\n+static_assert (is_accessible (^^anon, gctx));\n+static_assert (is_accessible (^^fun, gctx));\n+static_assert (is_accessible (^^alias, gctx));\n+static_assert (is_accessible (^^var, gctx));\n+static_assert (is_accessible (^^ref, gctx));\n+static_assert (is_accessible (^^rref, gctx));\n+static_assert (is_accessible (^^ptr, gctx));\n+static_assert (is_accessible (^^cls_tmpl, gctx));\n+static_assert (is_accessible (^^cls_tmpl<int>, gctx));\n+static_assert (is_accessible (^^incomplete_cls<int>, gctx));\n+static_assert (is_accessible (^^fun_tmpl, gctx));\n+static_assert (is_accessible (^^fun_tmpl<int>, gctx));\n+static_assert (is_accessible (^^conc, gctx));\n+static_assert (is_accessible (substitute (^^conc, { ^^int }), gctx));\n+static_assert (is_accessible (^^var_tmpl, gctx));\n+static_assert (is_accessible (^^var_tmpl<int>, gctx));\n+static_assert (is_accessible (^^cls_tmpl_alias, gctx));\n+static_assert (is_accessible (^^cls_tmpl_alias<int>, gctx));\n+static_assert (is_accessible (^^Enum, gctx));\n+static_assert (is_accessible (^^Enum::A, gctx));\n+static_assert (is_accessible (^^Enum_class, gctx));\n+static_assert (is_accessible (^^Enum_class::A, gctx));\n+static_assert (is_accessible (^^decomp, gctx));\n+static_assert (is_accessible (^^decomp_ref, gctx));\n+static_assert (is_accessible (^^arr, gctx));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (is_accessible (dms, gctx));\n+\n+struct Base {};\n+struct Derived : Base {};\n+struct Derived2 : private Base {};\n+static_assert (is_accessible (bases_of (^^Derived, gctx)[0], gctx));\n+static_assert (!is_accessible (bases_of (^^Derived2, access_context::unchecked ())[0], gctx));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (is_accessible (^^x, gctx));\n+ static_assert (is_accessible (parameters_of (^^foo)[0], gctx));\n+ int v;\n+ static_assert (is_accessible (^^v, gctx));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (is_accessible (^^S, gctx));\n+ static_assert (is_accessible (^^E, gctx));\n+ static_assert (is_accessible (^^F, gctx));\n+ static_assert (is_accessible (^^G, gctx));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_accessible2.C b/gcc/testsuite/g++.dg/reflect/is_accessible2.C\nnew file mode 100644\nindex 00000000000..8e69c1851da\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_accessible2.C\n@@ -0,0 +1,470 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_accessible.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+struct A { int a; };\n+struct B { int b; };\n+struct C { int c; };\n+\n+struct D : A, protected B, private C {\n+ static consteval access_context foo () { return access_context::current (); }\n+ int d;\n+public:\n+ struct E {};\n+ enum F { F1 };\n+ int bar () { return 0; }\n+ template <typename T>\n+ void baz () { }\n+ using g = int;\n+ static constexpr int j = 42;\n+protected:\n+ int e;\n+ struct G {};\n+ enum H { H1 };\n+ int qux () { return 0; }\n+ template <typename T>\n+ void freddy () { }\n+ using h = int;\n+ static constexpr int k = 42;\n+private:\n+ int f;\n+ struct I {};\n+ enum J { J1 };\n+ int corge () { return 0; }\n+ template <typename T>\n+ void garply () {}\n+ using i = int;\n+ static constexpr int l = 42;\n+ friend struct K;\n+ friend void plugh ();\n+public:\n+ void waldo ()\n+ {\n+ constexpr auto ctx = access_context::current ();\n+ static_assert (is_accessible (^^d, ctx));\n+ static_assert (is_accessible (^^E, ctx));\n+ static_assert (is_accessible (^^F, ctx));\n+ static_assert (is_accessible (^^F1, ctx));\n+ static_assert (is_accessible (^^bar, ctx));\n+ static_assert (is_accessible (^^baz, ctx));\n+ static_assert (is_accessible (^^g, ctx));\n+ static_assert (is_accessible (^^j, ctx));\n+ static_assert (is_accessible (^^e, ctx));\n+ static_assert (is_accessible (^^G, ctx));\n+ static_assert (is_accessible (^^H, ctx));\n+ static_assert (is_accessible (^^H1, ctx));\n+ static_assert (is_accessible (^^qux, ctx));\n+ static_assert (is_accessible (^^freddy, ctx));\n+ static_assert (is_accessible (^^h, ctx));\n+ static_assert (is_accessible (^^k, ctx));\n+ static_assert (is_accessible (^^f, ctx));\n+ static_assert (is_accessible (^^I, ctx));\n+ static_assert (is_accessible (^^J, ctx));\n+ static_assert (is_accessible (^^J1, ctx));\n+ static_assert (is_accessible (^^corge, ctx));\n+ static_assert (is_accessible (^^garply, ctx));\n+ static_assert (is_accessible (^^i, ctx));\n+ static_assert (is_accessible (^^l, ctx));\n+ static_assert (is_accessible (^^waldo, ctx));\n+ }\n+ static constexpr info rd = ^^d;\n+ static constexpr info rE = ^^E;\n+ static constexpr info rF = ^^F;\n+ static constexpr info rF1 = ^^F1;\n+ static constexpr info rbar = ^^bar;\n+ static constexpr info rbaz = ^^baz;\n+ static constexpr info rg = ^^g;\n+ static constexpr info rj = ^^j;\n+ static constexpr info re = ^^e;\n+ static constexpr info rG = ^^G;\n+ static constexpr info rH = ^^H;\n+ static constexpr info rH1 = ^^H1;\n+ static constexpr info rqux = ^^qux;\n+ static constexpr info rfreddy = ^^freddy;\n+ static constexpr info rh = ^^h;\n+ static constexpr info rk = ^^k;\n+ static constexpr info rf = ^^f;\n+ static constexpr info rI = ^^I;\n+ static constexpr info rJ = ^^J;\n+ static constexpr info rJ1 = ^^J1;\n+ static constexpr info rcorge = ^^corge;\n+ static constexpr info rgarply = ^^garply;\n+ static constexpr info ri = ^^i;\n+ static constexpr info rl = ^^l;\n+ static constexpr info rwaldo = ^^waldo;\n+};\n+\n+constexpr auto gctx = access_context::current ();\n+static_assert (is_accessible (D::rd, gctx));\n+static_assert (is_accessible (D::rE, gctx));\n+static_assert (is_accessible (D::rF, gctx));\n+static_assert (is_accessible (D::rF1, gctx));\n+static_assert (is_accessible (D::rbar, gctx));\n+static_assert (is_accessible (D::rbaz, gctx));\n+static_assert (is_accessible (D::rg, gctx));\n+static_assert (is_accessible (D::rj, gctx));\n+static_assert (!is_accessible (D::re, gctx));\n+static_assert (!is_accessible (D::rG, gctx));\n+static_assert (!is_accessible (D::rH, gctx));\n+static_assert (!is_accessible (D::rH1, gctx));\n+static_assert (!is_accessible (D::rqux, gctx));\n+static_assert (!is_accessible (D::rfreddy, gctx));\n+static_assert (!is_accessible (D::rh, gctx));\n+static_assert (!is_accessible (D::rk, gctx));\n+static_assert (!is_accessible (D::rf, gctx));\n+static_assert (!is_accessible (D::rI, gctx));\n+static_assert (!is_accessible (D::rJ, gctx));\n+static_assert (!is_accessible (D::rJ1, gctx));\n+static_assert (!is_accessible (D::rcorge, gctx));\n+static_assert (!is_accessible (D::rgarply, gctx));\n+static_assert (!is_accessible (D::ri, gctx));\n+static_assert (!is_accessible (D::rl, gctx));\n+static_assert (is_accessible (D::rwaldo, gctx));\n+static_assert (is_accessible (D::rd, D::foo ()));\n+static_assert (is_accessible (D::rE, D::foo ()));\n+static_assert (is_accessible (D::rF, D::foo ()));\n+static_assert (is_accessible (D::rF1, D::foo ()));\n+static_assert (is_accessible (D::rbar, D::foo ()));\n+static_assert (is_accessible (D::rbaz, D::foo ()));\n+static_assert (is_accessible (D::rg, D::foo ()));\n+static_assert (is_accessible (D::rj, D::foo ()));\n+static_assert (is_accessible (D::re, D::foo ()));\n+static_assert (is_accessible (D::rG, D::foo ()));\n+static_assert (is_accessible (D::rH, D::foo ()));\n+static_assert (is_accessible (D::rH1, D::foo ()));\n+static_assert (is_accessible (D::rqux, D::foo ()));\n+static_assert (is_accessible (D::rfreddy, D::foo ()));\n+static_assert (is_accessible (D::rh, D::foo ()));\n+static_assert (is_accessible (D::rk, D::foo ()));\n+static_assert (is_accessible (D::rf, D::foo ()));\n+static_assert (is_accessible (D::rI, D::foo ()));\n+static_assert (is_accessible (D::rJ, D::foo ()));\n+static_assert (is_accessible (D::rJ1, D::foo ()));\n+static_assert (is_accessible (D::rcorge, D::foo ()));\n+static_assert (is_accessible (D::rgarply, D::foo ()));\n+static_assert (is_accessible (D::ri, D::foo ()));\n+static_assert (is_accessible (D::rl, D::foo ()));\n+static_assert (is_accessible (D::rwaldo, D::foo ()));\n+constexpr auto uctx = access_context::unchecked ();\n+static_assert (is_accessible (D::rd, uctx));\n+static_assert (is_accessible (D::rE, uctx));\n+static_assert (is_accessible (D::rF, uctx));\n+static_assert (is_accessible (D::rF1, uctx));\n+static_assert (is_accessible (D::rbar, uctx));\n+static_assert (is_accessible (D::rbaz, uctx));\n+static_assert (is_accessible (D::rg, uctx));\n+static_assert (is_accessible (D::rj, uctx));\n+static_assert (is_accessible (D::re, uctx));\n+static_assert (is_accessible (D::rG, uctx));\n+static_assert (is_accessible (D::rH, uctx));\n+static_assert (is_accessible (D::rH1, uctx));\n+static_assert (is_accessible (D::rqux, uctx));\n+static_assert (is_accessible (D::rfreddy, uctx));\n+static_assert (is_accessible (D::rh, uctx));\n+static_assert (is_accessible (D::rk, uctx));\n+static_assert (is_accessible (D::rf, uctx));\n+static_assert (is_accessible (D::rI, uctx));\n+static_assert (is_accessible (D::rJ, uctx));\n+static_assert (is_accessible (D::rJ1, uctx));\n+static_assert (is_accessible (D::rcorge, uctx));\n+static_assert (is_accessible (D::rgarply, uctx));\n+static_assert (is_accessible (D::ri, uctx));\n+static_assert (is_accessible (D::rl, uctx));\n+static_assert (is_accessible (D::rwaldo, uctx));\n+\n+struct K {\n+ static constexpr auto ctx = access_context::current ();\n+ static_assert (is_accessible (D::rd, ctx));\n+ static_assert (is_accessible (D::rE, ctx));\n+ static_assert (is_accessible (D::rF, ctx));\n+ static_assert (is_accessible (D::rF1, ctx));\n+ static_assert (is_accessible (D::rbar, ctx));\n+ static_assert (is_accessible (D::rbaz, ctx));\n+ static_assert (is_accessible (D::rg, ctx));\n+ static_assert (is_accessible (D::rj, ctx));\n+ static_assert (is_accessible (D::re, ctx));\n+ static_assert (is_accessible (D::rG, ctx));\n+ static_assert (is_accessible (D::rH, ctx));\n+ static_assert (is_accessible (D::rH1, ctx));\n+ static_assert (is_accessible (D::rqux, ctx));\n+ static_assert (is_accessible (D::rfreddy, ctx));\n+ static_assert (is_accessible (D::rh, ctx));\n+ static_assert (is_accessible (D::rk, ctx));\n+ static_assert (is_accessible (D::rf, ctx));\n+ static_assert (is_accessible (D::rI, ctx));\n+ static_assert (is_accessible (D::rJ, ctx));\n+ static_assert (is_accessible (D::rJ1, ctx));\n+ static_assert (is_accessible (D::rcorge, ctx));\n+ static_assert (is_accessible (D::rgarply, ctx));\n+ static_assert (is_accessible (D::ri, ctx));\n+ static_assert (is_accessible (D::rl, ctx));\n+ static_assert (is_accessible (D::rwaldo, ctx));\n+ static constexpr auto uctx = access_context::unprivileged ();\n+ static_assert (is_accessible (D::rd, uctx));\n+ static_assert (is_accessible (D::rE, uctx));\n+ static_assert (is_accessible (D::rF, uctx));\n+ static_assert (is_accessible (D::rF1, uctx));\n+ static_assert (is_accessible (D::rbar, uctx));\n+ static_assert (is_accessible (D::rbaz, uctx));\n+ static_assert (is_accessible (D::rg, uctx));\n+ static_assert (is_accessible (D::rj, uctx));\n+ static_assert (!is_accessible (D::re, uctx));\n+ static_assert (!is_accessible (D::rG, uctx));\n+ static_assert (!is_accessible (D::rH, uctx));\n+ static_assert (!is_accessible (D::rH1, uctx));\n+ static_assert (!is_accessible (D::rqux, uctx));\n+ static_assert (!is_accessible (D::rfreddy, uctx));\n+ static_assert (!is_accessible (D::rh, uctx));\n+ static_assert (!is_accessible (D::rk, uctx));\n+ static_assert (!is_accessible (D::rf, uctx));\n+ static_assert (!is_accessible (D::rI, uctx));\n+ static_assert (!is_accessible (D::rJ, uctx));\n+ static_assert (!is_accessible (D::rJ1, uctx));\n+ static_assert (!is_accessible (D::rcorge, uctx));\n+ static_assert (!is_accessible (D::rgarply, uctx));\n+ static_assert (!is_accessible (D::ri, uctx));\n+ static_assert (!is_accessible (D::rl, uctx));\n+ static_assert (is_accessible (D::rwaldo, uctx));\n+};\n+\n+void\n+plugh ()\n+{\n+ static constexpr auto ctx = access_context::current ();\n+ static_assert (is_accessible (D::rd, ctx));\n+ static_assert (is_accessible (D::rE, ctx));\n+ static_assert (is_accessible (D::rF, ctx));\n+ static_assert (is_accessible (D::rF1, ctx));\n+ static_assert (is_accessible (D::rbar, ctx));\n+ static_assert (is_accessible (D::rbaz, ctx));\n+ static_assert (is_accessible (D::rg, ctx));\n+ static_assert (is_accessible (D::rj, ctx));\n+ static_assert (is_accessible (D::re, ctx));\n+ static_assert (is_accessible (D::rG, ctx));\n+ static_assert (is_accessible (D::rH, ctx));\n+ static_assert (is_accessible (D::rH1, ctx));\n+ static_assert (is_accessible (D::rqux, ctx));\n+ static_assert (is_accessible (D::rfreddy, ctx));\n+ static_assert (is_accessible (D::rh, ctx));\n+ static_assert (is_accessible (D::rk, ctx));\n+ static_assert (is_accessible (D::rf, ctx));\n+ static_assert (is_accessible (D::rI, ctx));\n+ static_assert (is_accessible (D::rJ, ctx));\n+ static_assert (is_accessible (D::rJ1, ctx));\n+ static_assert (is_accessible (D::rcorge, ctx));\n+ static_assert (is_accessible (D::rgarply, ctx));\n+ static_assert (is_accessible (D::ri, ctx));\n+ static_assert (is_accessible (D::rl, ctx));\n+ static_assert (is_accessible (D::rwaldo, ctx));\n+}\n+\n+void\n+xyzzy ()\n+{\n+ static constexpr auto ctx = access_context::current ();\n+ static_assert (is_accessible (D::rd, ctx));\n+ static_assert (is_accessible (D::rE, ctx));\n+ static_assert (is_accessible (D::rF, ctx));\n+ static_assert (is_accessible (D::rF1, ctx));\n+ static_assert (is_accessible (D::rbar, ctx));\n+ static_assert (is_accessible (D::rbaz, ctx));\n+ static_assert (is_accessible (D::rg, ctx));\n+ static_assert (is_accessible (D::rj, ctx));\n+ static_assert (!is_accessible (D::re, ctx));\n+ static_assert (!is_accessible (D::rG, ctx));\n+ static_assert (!is_accessible (D::rH, ctx));\n+ static_assert (!is_accessible (D::rH1, ctx));\n+ static_assert (!is_accessible (D::rqux, ctx));\n+ static_assert (!is_accessible (D::rfreddy, ctx));\n+ static_assert (!is_accessible (D::rh, ctx));\n+ static_assert (!is_accessible (D::rk, ctx));\n+ static_assert (!is_accessible (D::rf, ctx));\n+ static_assert (!is_accessible (D::rI, ctx));\n+ static_assert (!is_accessible (D::rJ, ctx));\n+ static_assert (!is_accessible (D::rJ1, ctx));\n+ static_assert (!is_accessible (D::rcorge, ctx));\n+ static_assert (!is_accessible (D::rgarply, ctx));\n+ static_assert (!is_accessible (D::ri, ctx));\n+ static_assert (!is_accessible (D::rl, ctx));\n+ static_assert (is_accessible (D::rwaldo, ctx));\n+}\n+\n+struct L : public D\n+{\n+ static constexpr auto ctx = access_context::current ();\n+ static_assert (is_accessible (D::rd, ctx));\n+ static_assert (is_accessible (D::rE, ctx));\n+ static_assert (is_accessible (D::rF, ctx));\n+ static_assert (is_accessible (D::rF1, ctx));\n+ static_assert (is_accessible (D::rbar, ctx));\n+ static_assert (is_accessible (D::rbaz, ctx));\n+ static_assert (is_accessible (D::rg, ctx));\n+ static_assert (is_accessible (D::rj, ctx));\n+ static_assert (!is_accessible (D::re, ctx));\n+ static_assert (is_accessible (D::rG, ctx));\n+ static_assert (is_accessible (D::rH, ctx));\n+ static_assert (is_accessible (D::rH1, ctx));\n+ static_assert (!is_accessible (D::rqux, ctx));\n+ static_assert (!is_accessible (D::rfreddy, ctx));\n+ static_assert (is_accessible (D::rh, ctx));\n+ static_assert (is_accessible (D::rk, ctx));\n+ static_assert (!is_accessible (D::rf, ctx));\n+ static_assert (!is_accessible (D::rI, ctx));\n+ static_assert (!is_accessible (D::rJ, ctx));\n+ static_assert (!is_accessible (D::rJ1, ctx));\n+ static_assert (!is_accessible (D::rcorge, ctx));\n+ static_assert (!is_accessible (D::rgarply, ctx));\n+ static_assert (!is_accessible (D::ri, ctx));\n+ static_assert (!is_accessible (D::rl, ctx));\n+ static_assert (is_accessible (D::rwaldo, ctx));\n+ friend void thud ();\n+};\n+\n+consteval {\n+ constexpr auto ctx = L::ctx.via (^^L);\n+ static_assert (is_accessible (D::rd, ctx));\n+ static_assert (is_accessible (D::rE, ctx));\n+ static_assert (is_accessible (D::rF, ctx));\n+ static_assert (is_accessible (D::rF1, ctx));\n+ static_assert (is_accessible (D::rbar, ctx));\n+ static_assert (is_accessible (D::rbaz, ctx));\n+ static_assert (is_accessible (D::rg, ctx));\n+ static_assert (is_accessible (D::rj, ctx));\n+ static_assert (is_accessible (D::re, ctx));\n+ static_assert (is_accessible (D::rG, ctx));\n+ static_assert (is_accessible (D::rH, ctx));\n+ static_assert (is_accessible (D::rH1, ctx));\n+ static_assert (is_accessible (D::rqux, ctx));\n+ static_assert (is_accessible (D::rfreddy, ctx));\n+ static_assert (is_accessible (D::rh, ctx));\n+ static_assert (is_accessible (D::rk, ctx));\n+ static_assert (!is_accessible (D::rf, ctx));\n+ static_assert (!is_accessible (D::rI, ctx));\n+ static_assert (!is_accessible (D::rJ, ctx));\n+ static_assert (!is_accessible (D::rJ1, ctx));\n+ static_assert (!is_accessible (D::rcorge, ctx));\n+ static_assert (!is_accessible (D::rgarply, ctx));\n+ static_assert (!is_accessible (D::ri, ctx));\n+ static_assert (!is_accessible (D::rl, ctx));\n+ static_assert (is_accessible (D::rwaldo, ctx));\n+}\n+\n+void\n+thud ()\n+{\n+ static constexpr auto ctx = access_context::current ();\n+ static_assert (is_accessible (D::rd, ctx));\n+ static_assert (is_accessible (D::rE, ctx));\n+ static_assert (is_accessible (D::rF, ctx));\n+ static_assert (is_accessible (D::rF1, ctx));\n+ static_assert (is_accessible (D::rbar, ctx));\n+ static_assert (is_accessible (D::rbaz, ctx));\n+ static_assert (is_accessible (D::rg, ctx));\n+ static_assert (is_accessible (D::rj, ctx));\n+ static_assert (!is_accessible (D::re, ctx));\n+ // TODO: clang++ disagrees with GCC on the D::r{G,H,H12,h,k} cases.\n+ static_assert (is_accessible (D::rG, ctx));\n+ static_assert (is_accessible (D::rH, ctx));\n+ static_assert (is_accessible (D::rH1, ctx));\n+ static_assert (!is_accessible (D::rqux, ctx));\n+ static_assert (!is_accessible (D::rfreddy, ctx));\n+ static_assert (is_accessible (D::rh, ctx));\n+ static_assert (is_accessible (D::rk, ctx));\n+ static_assert (!is_accessible (D::rf, ctx));\n+ static_assert (!is_accessible (D::rI, ctx));\n+ static_assert (!is_accessible (D::rJ, ctx));\n+ static_assert (!is_accessible (D::rJ1, ctx));\n+ static_assert (!is_accessible (D::rcorge, ctx));\n+ static_assert (!is_accessible (D::rgarply, ctx));\n+ static_assert (!is_accessible (D::ri, ctx));\n+ static_assert (!is_accessible (D::rl, ctx));\n+ static_assert (is_accessible (D::rwaldo, ctx));\n+ static constexpr auto ctx2 = access_context::current ().via (^^L);\n+ static_assert (is_accessible (D::rd, ctx2));\n+ static_assert (is_accessible (D::rE, ctx2));\n+ static_assert (is_accessible (D::rF, ctx2));\n+ static_assert (is_accessible (D::rF1, ctx2));\n+ static_assert (is_accessible (D::rbar, ctx2));\n+ static_assert (is_accessible (D::rbaz, ctx2));\n+ static_assert (is_accessible (D::rg, ctx2));\n+ static_assert (is_accessible (D::rj, ctx2));\n+ static_assert (is_accessible (D::re, ctx2));\n+ static_assert (is_accessible (D::rG, ctx2));\n+ static_assert (is_accessible (D::rH, ctx2));\n+ static_assert (is_accessible (D::rH1, ctx2));\n+ static_assert (is_accessible (D::rqux, ctx2));\n+ static_assert (is_accessible (D::rfreddy, ctx2));\n+ static_assert (is_accessible (D::rh, ctx2));\n+ static_assert (is_accessible (D::rk, ctx2));\n+ static_assert (!is_accessible (D::rf, ctx2));\n+ static_assert (!is_accessible (D::rI, ctx2));\n+ static_assert (!is_accessible (D::rJ, ctx2));\n+ static_assert (!is_accessible (D::rJ1, ctx2));\n+ static_assert (!is_accessible (D::rcorge, ctx2));\n+ static_assert (!is_accessible (D::rgarply, ctx2));\n+ static_assert (!is_accessible (D::ri, ctx2));\n+ static_assert (!is_accessible (D::rl, ctx2));\n+ static_assert (is_accessible (D::rwaldo, ctx2));\n+}\n+\n+struct M : D\n+{\n+ static constexpr auto ctx = access_context::current ();\n+ static_assert (is_accessible (^^D::A::a, ctx));\n+ static_assert (is_accessible (^^D::B::b, ctx));\n+ static_assert (is_accessible (^^::C::c, ctx));\n+};\n+\n+consteval {\n+ constexpr auto ctx = M::ctx.via (^^M);\n+ static_assert (!is_accessible (^^::C::c, ctx));\n+}\n+\n+static union { int a; };\n+\n+static_assert (is_accessible (^^a, gctx));\n+static_assert (is_accessible (^^a, D::foo ()));\n+static_assert (is_accessible (^^a, uctx));\n+\n+struct N\n+{\n+ union { int a; };\n+protected:\n+ union { int b; };\n+private:\n+ union { int c; };\n+public:\n+ static constexpr auto ctx = access_context::current ();\n+ static constexpr info ra = ^^a;\n+ static constexpr info rb = ^^b;\n+ static constexpr info rc = ^^c;\n+};\n+\n+struct O : public N\n+{\n+ static constexpr auto ctx = access_context::current ();\n+};\n+\n+static_assert (is_accessible (N::ra, gctx));\n+// TODO: clang++ disagrees with g++ on the N::r{b,c} cases with gctx and O::ctx.\n+static_assert (!is_accessible (N::rb, gctx));\n+static_assert (!is_accessible (N::rc, gctx));\n+static_assert (is_accessible (N::ra, N::ctx));\n+// TODO: This case ICEs.\n+//static_assert (is_accessible (N::rb, N::ctx));\n+static_assert (is_accessible (N::rc, N::ctx));\n+static_assert (is_accessible (N::ra, N::ctx.via (^^N)));\n+static_assert (is_accessible (N::rb, N::ctx.via (^^N)));\n+static_assert (is_accessible (N::rc, N::ctx.via (^^N)));\n+static_assert (is_accessible (N::ra, O::ctx));\n+static_assert (!is_accessible (N::rb, O::ctx));\n+static_assert (!is_accessible (N::rc, O::ctx));\n+static_assert (is_accessible (N::ra, O::ctx.via (^^O)));\n+static_assert (is_accessible (N::rb, O::ctx.via (^^O)));\n+static_assert (!is_accessible (N::rc, O::ctx.via (^^O)));\n+static_assert (is_accessible (^^A::a, O::ctx));\n+static_assert (!is_accessible (^^A::a, O::ctx.via (^^O)));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_alias_template1.C b/gcc/testsuite/g++.dg/reflect/is_alias_template1.C\nnew file mode 100644\nindex 00000000000..8db2b7e632b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_alias_template1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_alias_template.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_alias_template (null_reflection));\n+static_assert (!is_alias_template (^^::));\n+static_assert (!is_alias_template (^^ns));\n+static_assert (!is_alias_template (^^ns_alias));\n+static_assert (!is_alias_template (reflect_constant (3)));\n+static_assert (!is_alias_template (^^cls));\n+static_assert (!is_alias_template (^^cls::dm));\n+static_assert (!is_alias_template (^^cls::ref_dm));\n+static_assert (!is_alias_template (^^cls::static_dm));\n+static_assert (!is_alias_template (^^cls::mem_fun));\n+static_assert (!is_alias_template (^^cls::static_mem_fun));\n+static_assert (!is_alias_template (^^cls::type));\n+static_assert (!is_alias_template (^^cls_var));\n+static_assert (!is_alias_template (^^onion));\n+static_assert (!is_alias_template (^^anon));\n+static_assert (!is_alias_template (^^fun));\n+static_assert (!is_alias_template (^^alias));\n+static_assert (!is_alias_template (^^var));\n+static_assert (!is_alias_template (^^ref));\n+static_assert (!is_alias_template (^^rref));\n+static_assert (!is_alias_template (^^ptr));\n+static_assert (!is_alias_template (^^cls_tmpl));\n+static_assert (!is_alias_template (^^cls_tmpl<int>));\n+static_assert (!is_alias_template (^^incomplete_cls<int>));\n+static_assert (!is_alias_template (^^fun_tmpl));\n+static_assert (!is_alias_template (^^fun_tmpl<int>));\n+static_assert (!is_alias_template (^^conc));\n+static_assert (!is_alias_template (substitute (^^conc, { ^^int })));\n+static_assert (!is_alias_template (^^var_tmpl));\n+static_assert (!is_alias_template (^^var_tmpl<int>));\n+static_assert (is_alias_template (^^cls_tmpl_alias));\n+static_assert (!is_alias_template (^^cls_tmpl_alias<int>));\n+static_assert (!is_alias_template (^^Enum));\n+static_assert (!is_alias_template (^^Enum::A));\n+static_assert (!is_alias_template (^^Enum_class));\n+static_assert (!is_alias_template (^^Enum_class::A));\n+static_assert (!is_alias_template (^^decomp));\n+static_assert (!is_alias_template (^^decomp_ref));\n+static_assert (!is_alias_template (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_alias_template (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_alias_template (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!is_alias_template (^^T));\n+ static_assert (!is_alias_template (R));\n+ static_assert (!is_alias_template (R2));\n+ static_assert (is_alias_template (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^ns, ^^cls_tmpl_alias>();\n+ static_assert (!is_alias_template (^^p));\n+ static_assert (!is_alias_template (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_assignment1.C b/gcc/testsuite/g++.dg/reflect/is_assignment1.C\nnew file mode 100644\nindex 00000000000..a59877033f5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_assignment1.C\n@@ -0,0 +1,44 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_assignment.\n+\n+#include <meta>\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+ S &operator += (const S &);\n+ void bar ();\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (is_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &);\n+};\n+\n+struct U {\n+ U &operator = (U &&)\n+ {\n+ int a;\n+ static_assert (is_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+static_assert (!is_assignment (null_reflection));\n+static_assert (!is_assignment (^^int));\n+static_assert (!is_assignment (^^::));\n+static_assert (!is_assignment (^^foo));\n+static_assert (!is_assignment (^^S::bar));\n+static_assert (is_assignment (^^S::operator =));\n+static_assert (!is_assignment (^^S::operator +=));\n+static_assert (!is_assignment (^^T::operator *=));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_bit_field1.C b/gcc/testsuite/g++.dg/reflect/is_bit_field1.C\nnew file mode 100644\nindex 00000000000..091ac4d1c15\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_bit_field1.C\n@@ -0,0 +1,144 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_bit_field.\n+\n+#include <meta>\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 <int N>\n+ void foo ();\n+ template <int N>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_bit_field (null_reflection));\n+static_assert (!is_bit_field (^^::));\n+static_assert (!is_bit_field (^^ns));\n+static_assert (!is_bit_field (^^ns_alias));\n+static_assert (!is_bit_field (reflect_constant (3)));\n+static_assert (!is_bit_field (^^cls));\n+static_assert (!is_bit_field (^^cls::dm));\n+static_assert (!is_bit_field (^^cls::ref_dm));\n+static_assert (!is_bit_field (^^cls::static_dm));\n+static_assert (!is_bit_field (^^cls::mem_fun));\n+static_assert (!is_bit_field (^^cls::static_mem_fun));\n+static_assert (!is_bit_field (^^cls::type));\n+static_assert (!is_bit_field (^^cls::E));\n+static_assert (!is_bit_field (^^cls::B));\n+static_assert (!is_bit_field (^^cls::C));\n+static_assert (!is_bit_field (^^cls::D));\n+static_assert (!is_bit_field (^^cls::F));\n+static_assert (!is_bit_field (^^cls::F::G));\n+static_assert (!is_bit_field (^^cls::F::H));\n+static_assert (!is_bit_field (^^cls::S));\n+static_assert (!is_bit_field (^^cls::U));\n+static_assert (!is_bit_field (^^cls::foo));\n+static_assert (!is_bit_field (^^cls::foo <0>));\n+static_assert (!is_bit_field (^^cls::bar));\n+static_assert (!is_bit_field (^^cls::bar <42>));\n+static_assert (!is_bit_field (^^cls_var));\n+static_assert (!is_bit_field (^^onion));\n+static_assert (!is_bit_field (^^anon));\n+static_assert (!is_bit_field (^^fun));\n+static_assert (!is_bit_field (^^alias));\n+static_assert (!is_bit_field (^^var));\n+static_assert (!is_bit_field (^^ref));\n+static_assert (!is_bit_field (^^rref));\n+static_assert (!is_bit_field (^^ptr));\n+static_assert (!is_bit_field (^^cls_tmpl));\n+static_assert (!is_bit_field (^^cls_tmpl<int>));\n+static_assert (!is_bit_field (^^incomplete_cls<int>));\n+static_assert (!is_bit_field (^^fun_tmpl));\n+static_assert (!is_bit_field (^^fun_tmpl<int>));\n+static_assert (!is_bit_field (^^conc));\n+static_assert (!is_bit_field (substitute (^^conc, { ^^int })));\n+static_assert (!is_bit_field (^^var_tmpl));\n+static_assert (!is_bit_field (^^var_tmpl<int>));\n+static_assert (!is_bit_field (^^cls_tmpl_alias));\n+static_assert (!is_bit_field (^^cls_tmpl_alias<int>));\n+static_assert (!is_bit_field (^^Enum));\n+static_assert (!is_bit_field (^^Enum::A));\n+static_assert (!is_bit_field (^^Enum_class));\n+static_assert (!is_bit_field (^^Enum_class::A));\n+static_assert (!is_bit_field (^^decomp));\n+static_assert (!is_bit_field (^^decomp_ref));\n+static_assert (!is_bit_field (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_bit_field (dms));\n+constexpr auto dms2 = data_member_spec (^^int, { .bit_width = 6 });\n+static_assert (is_bit_field (dms2));\n+constexpr auto dms3 = data_member_spec (^^int, { .name = \"dms\", .bit_width = 15 });\n+static_assert (is_bit_field (dms3));\n+\n+constexpr auto ctx = access_context::current ();\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_bit_field (bases_of (^^Derived, ctx)[0]));\n+\n+struct S {\n+ int bf : 4;\n+ long long bf2 : 36;\n+ int : 4;\n+ int : 0;\n+};\n+static_assert (is_bit_field (^^S::bf));\n+static_assert (is_bit_field (^^S::bf2));\n+static_assert (is_bit_field (members_of (^^S, ctx)[2]));\n+static_assert (is_bit_field (members_of (^^S, ctx)[3]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_bit_field (^^x));\n+ static_assert (!is_bit_field (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_bit_field (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_bit_field (^^S));\n+ static_assert (!is_bit_field (^^E));\n+ static_assert (!is_bit_field (^^F));\n+ static_assert (!is_bit_field (^^G));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_class_member1.C b/gcc/testsuite/g++.dg/reflect/is_class_member1.C\nnew file mode 100644\nindex 00000000000..99c5267ce78\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_class_member1.C\n@@ -0,0 +1,128 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_class_member.\n+\n+#include <meta>\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 <int N>\n+ void foo ();\n+ template <int N>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_class_member (null_reflection));\n+static_assert (!is_class_member (^^::));\n+static_assert (!is_class_member (^^ns));\n+static_assert (!is_class_member (^^ns_alias));\n+static_assert (!is_class_member (reflect_constant (3)));\n+static_assert (!is_class_member (^^cls));\n+static_assert (is_class_member (^^cls::~cls));\n+static_assert (is_class_member (^^cls::dm));\n+static_assert (is_class_member (^^cls::ref_dm));\n+static_assert (is_class_member (^^cls::static_dm));\n+static_assert (is_class_member (^^cls::mem_fun));\n+static_assert (is_class_member (^^cls::static_mem_fun));\n+static_assert (is_class_member (^^cls::type));\n+static_assert (is_class_member (^^cls::E));\n+static_assert (is_class_member (^^cls::B));\n+static_assert (is_class_member (^^cls::C));\n+static_assert (is_class_member (^^cls::D));\n+static_assert (is_class_member (^^cls::F));\n+static_assert (!is_class_member (^^cls::F::G));\n+static_assert (!is_class_member (^^cls::F::H));\n+static_assert (is_class_member (^^cls::S));\n+static_assert (is_class_member (^^cls::U));\n+static_assert (is_class_member (^^cls::foo));\n+static_assert (is_class_member (^^cls::foo <0>));\n+static_assert (is_class_member (^^cls::bar));\n+static_assert (is_class_member (^^cls::bar <42>));\n+static_assert (!is_class_member (^^cls_var));\n+static_assert (!is_class_member (^^onion));\n+static_assert (is_class_member (^^anon));\n+static_assert (!is_class_member (^^fun));\n+static_assert (!is_class_member (^^alias));\n+static_assert (!is_class_member (^^var));\n+static_assert (!is_class_member (^^ref));\n+static_assert (!is_class_member (^^rref));\n+static_assert (!is_class_member (^^ptr));\n+static_assert (!is_class_member (^^cls_tmpl));\n+static_assert (!is_class_member (^^cls_tmpl<int>));\n+static_assert (!is_class_member (^^incomplete_cls<int>));\n+static_assert (!is_class_member (^^fun_tmpl));\n+static_assert (!is_class_member (^^fun_tmpl<int>));\n+static_assert (!is_class_member (^^conc));\n+static_assert (!is_class_member (substitute (^^conc, { ^^int })));\n+static_assert (!is_class_member (^^var_tmpl));\n+static_assert (!is_class_member (^^var_tmpl<int>));\n+static_assert (!is_class_member (^^cls_tmpl_alias));\n+static_assert (!is_class_member (^^cls_tmpl_alias<int>));\n+static_assert (!is_class_member (^^Enum));\n+static_assert (!is_class_member (^^Enum::A));\n+static_assert (!is_class_member (^^Enum_class));\n+static_assert (!is_class_member (^^Enum_class::A));\n+static_assert (!is_class_member (^^decomp));\n+static_assert (!is_class_member (^^decomp_ref));\n+static_assert (!is_class_member (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_class_member (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_class_member (bases_of (^^Derived, access_context::current ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_class_member (^^x));\n+ static_assert (!is_class_member (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_class_member (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_class_member (^^S));\n+ static_assert (!is_class_member (^^E));\n+ static_assert (!is_class_member (^^F));\n+ static_assert (!is_class_member (^^G));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_class_template1.C b/gcc/testsuite/g++.dg/reflect/is_class_template1.C\nnew file mode 100644\nindex 00000000000..3cc420d4165\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_class_template1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_class_template.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_class_template (null_reflection));\n+static_assert (!is_class_template (^^::));\n+static_assert (!is_class_template (^^ns));\n+static_assert (!is_class_template (^^ns_alias));\n+static_assert (!is_class_template (reflect_constant (3)));\n+static_assert (!is_class_template (^^cls));\n+static_assert (!is_class_template (^^cls::dm));\n+static_assert (!is_class_template (^^cls::ref_dm));\n+static_assert (!is_class_template (^^cls::static_dm));\n+static_assert (!is_class_template (^^cls::mem_fun));\n+static_assert (!is_class_template (^^cls::static_mem_fun));\n+static_assert (!is_class_template (^^cls::type));\n+static_assert (!is_class_template (^^cls_var));\n+static_assert (!is_class_template (^^onion));\n+static_assert (!is_class_template (^^anon));\n+static_assert (!is_class_template (^^fun));\n+static_assert (!is_class_template (^^alias));\n+static_assert (!is_class_template (^^var));\n+static_assert (!is_class_template (^^ref));\n+static_assert (!is_class_template (^^rref));\n+static_assert (!is_class_template (^^ptr));\n+static_assert (is_class_template (^^cls_tmpl));\n+static_assert (!is_class_template (^^cls_tmpl<int>));\n+static_assert (!is_class_template (^^incomplete_cls<int>));\n+static_assert (!is_class_template (^^fun_tmpl));\n+static_assert (!is_class_template (^^fun_tmpl<int>));\n+static_assert (!is_class_template (^^conc));\n+static_assert (!is_class_template (substitute (^^conc, { ^^int })));\n+static_assert (!is_class_template (^^var_tmpl));\n+static_assert (!is_class_template (^^var_tmpl<int>));\n+static_assert (!is_class_template (^^cls_tmpl_alias));\n+static_assert (!is_class_template (^^cls_tmpl_alias<int>));\n+static_assert (!is_class_template (^^Enum));\n+static_assert (!is_class_template (^^Enum::A));\n+static_assert (!is_class_template (^^Enum_class));\n+static_assert (!is_class_template (^^Enum_class::A));\n+static_assert (!is_class_template (^^decomp));\n+static_assert (!is_class_template (^^decomp_ref));\n+static_assert (!is_class_template (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_class_template (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_class_template (bases_of (^^Derived, access_context::unprivileged ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!is_class_template (^^T));\n+ static_assert (!is_class_template (R));\n+ static_assert (!is_class_template (R2));\n+ static_assert (is_class_template (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^ns, ^^cls_tmpl>();\n+ static_assert (!is_class_template (^^p));\n+ static_assert (!is_class_template (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_complete_type1.C b/gcc/testsuite/g++.dg/reflect/is_complete_type1.C\nnew file mode 100644\nindex 00000000000..6d89aea39d5\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_complete_type1.C\n@@ -0,0 +1,109 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_complete_type.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+using inc_arr = int[];\n+using com_arr = int[42];\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_complete_type (null_reflection));\n+static_assert (!is_complete_type (^^::));\n+static_assert (!is_complete_type (^^ns));\n+static_assert (!is_complete_type (^^ns_alias));\n+static_assert (!is_complete_type (reflect_constant (3)));\n+static_assert (is_complete_type (^^cls));\n+static_assert (!is_complete_type (^^cls::dm));\n+static_assert (!is_complete_type (^^cls::ref_dm));\n+static_assert (!is_complete_type (^^cls::static_dm));\n+static_assert (!is_complete_type (^^cls::mem_fun));\n+static_assert (!is_complete_type (^^cls::static_mem_fun));\n+static_assert (is_complete_type (^^cls::type));\n+static_assert (!is_complete_type (^^cls_var));\n+static_assert (is_complete_type (^^onion));\n+static_assert (!is_complete_type (^^anon));\n+static_assert (!is_complete_type (^^fun));\n+static_assert (is_complete_type (^^alias));\n+static_assert (!is_complete_type (^^var));\n+static_assert (!is_complete_type (^^ref));\n+static_assert (!is_complete_type (^^rref));\n+static_assert (!is_complete_type (^^ptr));\n+static_assert (!is_complete_type (^^cls_tmpl));\n+static_assert (is_complete_type (^^cls_tmpl<int>));\n+static_assert (!is_complete_type (^^incomplete_cls<int>));\n+static_assert (!is_complete_type (^^fun_tmpl));\n+static_assert (!is_complete_type (^^fun_tmpl<int>));\n+static_assert (!is_complete_type (^^conc));\n+static_assert (!is_complete_type (substitute (^^conc, { ^^int })));\n+static_assert (!is_complete_type (^^var_tmpl));\n+static_assert (!is_complete_type (^^var_tmpl<int>));\n+static_assert (!is_complete_type (^^cls_tmpl_alias));\n+static_assert (is_complete_type (^^cls_tmpl_alias<int>));\n+static_assert (is_complete_type (^^Enum));\n+static_assert (!is_complete_type (^^Enum::A));\n+static_assert (is_complete_type (^^Enum_class));\n+static_assert (!is_complete_type (^^Enum_class::A));\n+static_assert (!is_complete_type (^^decomp));\n+static_assert (!is_complete_type (^^decomp_ref));\n+static_assert (!is_complete_type (^^arr));\n+static_assert (!is_complete_type (^^inc_arr));\n+static_assert (is_complete_type (^^com_arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_complete_type (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_complete_type (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (is_complete_type (^^T));\n+ static_assert (!is_complete_type (R));\n+ static_assert (!is_complete_type (R2));\n+ static_assert (is_complete_type (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (!is_complete_type (^^p));\n+ static_assert (!is_complete_type (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_complete_type2.C b/gcc/testsuite/g++.dg/reflect/is_complete_type2.C\nnew file mode 100644\nindex 00000000000..f637a31088a\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_complete_type2.C\n@@ -0,0 +1,25 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_complete_type.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+struct S;\n+\n+namespace N\n+{\n+ consteval bool\n+ is_complete_type (info r) { return std::meta::is_complete_type (r); }\n+}\n+\n+static_assert (!is_complete_type (^^S));\n+static_assert (!N::is_complete_type (^^S));\n+\n+consteval {\n+ define_aggregate (^^S, {});\n+}\n+\n+static_assert (is_complete_type (^^S));\n+static_assert (N::is_complete_type (^^S));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_concept1.C b/gcc/testsuite/g++.dg/reflect/is_concept1.C\nnew file mode 100644\nindex 00000000000..240931c9f1f\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_concept1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_concept.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_concept (null_reflection));\n+static_assert (!is_concept (^^::));\n+static_assert (!is_concept (^^ns));\n+static_assert (!is_concept (^^ns_alias));\n+static_assert (!is_concept (reflect_constant (3)));\n+static_assert (!is_concept (^^cls));\n+static_assert (!is_concept (^^cls::dm));\n+static_assert (!is_concept (^^cls::ref_dm));\n+static_assert (!is_concept (^^cls::static_dm));\n+static_assert (!is_concept (^^cls::mem_fun));\n+static_assert (!is_concept (^^cls::static_mem_fun));\n+static_assert (!is_concept (^^cls::type));\n+static_assert (!is_concept (^^cls_var));\n+static_assert (!is_concept (^^onion));\n+static_assert (!is_concept (^^anon));\n+static_assert (!is_concept (^^fun));\n+static_assert (!is_concept (^^alias));\n+static_assert (!is_concept (^^var));\n+static_assert (!is_concept (^^ref));\n+static_assert (!is_concept (^^rref));\n+static_assert (!is_concept (^^ptr));\n+static_assert (!is_concept (^^cls_tmpl));\n+static_assert (!is_concept (^^cls_tmpl<int>));\n+static_assert (!is_concept (^^incomplete_cls<int>));\n+static_assert (!is_concept (^^fun_tmpl));\n+static_assert (!is_concept (^^fun_tmpl<int>));\n+static_assert (is_concept (^^conc));\n+static_assert (!is_concept (substitute (^^conc, { ^^int })));\n+static_assert (!is_concept (^^var_tmpl));\n+static_assert (!is_concept (^^var_tmpl<int>));\n+static_assert (!is_concept (^^cls_tmpl_alias));\n+static_assert (!is_concept (^^cls_tmpl_alias<int>));\n+static_assert (!is_concept (^^Enum));\n+static_assert (!is_concept (^^Enum::A));\n+static_assert (!is_concept (^^Enum_class));\n+static_assert (!is_concept (^^Enum_class::A));\n+static_assert (!is_concept (^^decomp));\n+static_assert (!is_concept (^^decomp_ref));\n+static_assert (!is_concept (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_concept (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_concept (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!is_concept (^^T));\n+ static_assert (!is_concept (R));\n+ static_assert (!is_concept (R2));\n+ static_assert (is_concept (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^ns, ^^conc>();\n+ static_assert (!is_concept (^^p));\n+ static_assert (!is_concept (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_const1.C b/gcc/testsuite/g++.dg/reflect/is_const1.C\nnew file mode 100644\nindex 00000000000..5be1f56729c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_const1.C\n@@ -0,0 +1,116 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_const.\n+\n+#include <meta>\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<auto> struct TCls {};\n+template<auto> void TFn();\n+template<auto> int TVar;\n+template<auto> 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_const (std::meta::reflect_constant (42)));\n+static_assert (!is_const (std::meta::reflect_object (arr[1])));\n+static_assert (!is_const (^^arr));\n+static_assert (!is_const (^^a3));\n+static_assert (!is_const (^^fn));\n+static_assert (!is_const (^^fn2));\n+static_assert (!is_const (^^Enum::A));\n+static_assert (!is_const (^^Alias));\n+static_assert (!is_const (^^S));\n+static_assert (!is_const (^^S::mem));\n+static_assert (!is_const (std::meta::members_of (^^S, ctx)[1]));\n+static_assert (!is_const (^^TCls));\n+static_assert (!is_const (^^TFn));\n+static_assert (!is_const (^^TVar));\n+static_assert (!is_const (^^Concept));\n+static_assert (!is_const (^^NSAlias));\n+static_assert (!is_const (^^NS));\n+static_assert (!is_const (std::meta::bases_of (^^S, ctx)[0]));\n+static_assert (!is_const (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_const (^^a));\n+ static_assert (is_const (^^b));\n+ static_assert (!is_const (^^c));\n+ static_assert (!is_const (^^d));\n+ static_assert (!is_const (^^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_const (std::meta::reflect_constant (42)));\n+static_assert (!is_const (std::meta::reflect_constant (42.0)));\n+static_assert (is_const (std::meta::reflect_constant (U { 42 })));\n+static_assert (!is_const (std::meta::reflect_object (arr[1])));\n+static_assert (!is_const (^^arr));\n+static_assert (!is_const (^^fn));\n+static_assert (!is_const (^^Enum::A));\n+static_assert (!is_const (^^A));\n+static_assert (!is_const (^^S::mem));\n+\n+const int ci = 42;\n+static_assert (is_const (^^ci));\n+using uci = const int;\n+static_assert (is_const (^^uci));\n+constexpr long cl = 42L;\n+static_assert (is_const (^^cl));\n+extern const volatile short cv = 2;\n+static_assert (is_const (^^cv));\n+struct V { const int a; static const int b; };\n+static_assert (is_const (^^V::a));\n+static_assert (is_const (^^V::b));\n+\n+const int arr2[] = {3, 4, 5};\n+const 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_const (^^arr2));\n+static_assert (is_const (^^arr3));\n+static_assert (!is_const (^^W::foo));\n+static_assert (is_const (^^W::bar));\n+static_assert (!is_const (^^int));\n+static_assert (is_const (^^const int));\n+static_assert (!is_const (^^volatile int));\n+static_assert (is_const (^^const volatile int));\n+static_assert (!is_const (^^int [2]));\n+static_assert (is_const (^^const int [2]));\n+static_assert (!is_const (^^volatile int [2]));\n+static_assert (is_const (^^const volatile int [2]));\n+static_assert (!is_const (^^int (int)));\n+static_assert (is_const (^^int (int) const));\n+static_assert (!is_const (^^int (int) volatile));\n+static_assert (is_const (^^int (int) const volatile));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_consteval_only1.C b/gcc/testsuite/g++.dg/reflect/is_consteval_only1.C\nnew file mode 100644\nindex 00000000000..268aaaa72dc\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_consteval_only1.C\n@@ -0,0 +1,83 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_consteval_only.\n+\n+#include <meta>\n+using namespace std::meta;\n+\n+struct A {\n+ info i;\n+};\n+struct B : A { };\n+struct C : virtual A { };\n+struct D : B { };\n+struct E { };\n+struct F : E {\n+ info i;\n+};\n+template<typename T>\n+struct G {\n+ T t;\n+ using size_type = int;\n+};\n+struct H {\n+ G<info>::size_type sz;\n+};\n+struct I {\n+ std::initializer_list<std::meta::info>::size_type sz;\n+};\n+template<typename T>\n+struct J : T { };\n+\n+template<typename T>\n+using U = J<T>;\n+\n+template<typename T>\n+struct K {\n+ J<T> j;\n+};\n+\n+template<typename T>\n+struct L {\n+ U<T> u;\n+};\n+\n+template<typename T>\n+struct M : J<T> { };\n+\n+template<typename>\n+struct N { };\n+\n+static_assert (is_consteval_only_type (^^A));\n+static_assert (is_consteval_only_type (^^B));\n+static_assert (is_consteval_only_type (^^C));\n+static_assert (is_consteval_only_type (^^D));\n+static_assert (!is_consteval_only_type (^^E));\n+static_assert (is_consteval_only_type (^^F));\n+static_assert (!is_consteval_only_type (^^G<int>));\n+static_assert (is_consteval_only_type (^^G<info>));\n+static_assert (!is_consteval_only_type (^^H));\n+static_assert (!is_consteval_only_type (^^I));\n+static_assert (!is_consteval_only_type (^^J<E>));\n+static_assert (is_consteval_only_type (^^J<A>));\n+static_assert (!is_consteval_only_type (^^U<E>));\n+static_assert (is_consteval_only_type (^^U<A>));\n+static_assert (!is_consteval_only_type (^^K<E>));\n+static_assert (is_consteval_only_type (^^K<A>));\n+static_assert (!is_consteval_only_type (^^L<E>));\n+static_assert (is_consteval_only_type (^^L<A>));\n+static_assert (!is_consteval_only_type (^^M<E>));\n+static_assert (is_consteval_only_type (^^M<A>));\n+static_assert (!is_consteval_only_type (^^N<E>));\n+static_assert (!is_consteval_only_type (^^N<A>));\n+\n+static_assert (is_consteval_only_type (^^std::meta::exception));\n+static_assert (is_consteval_only_type (^^std::meta::access_context));\n+static_assert (!is_consteval_only_type (^^std::meta::member_offset));\n+static_assert (is_consteval_only_type (^^std::meta::data_member_options));\n+static_assert (is_consteval_only_type (type_of (^^std::meta::data_member_options::name)));\n+\n+struct O;\n+static_assert (!is_consteval_only_type (^^O));\n+struct O { info i; };\n+static_assert (is_consteval_only_type (^^O));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_constructible_type1.C b/gcc/testsuite/g++.dg/reflect/is_constructible_type1.C\nnew file mode 100644\nindex 00000000000..0b9d3e04779\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_constructible_type1.C\n@@ -0,0 +1,674 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_constructible_type.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+class ClassType { };\n+class DerivedType : public ClassType { };\n+enum EnumType { e0 };\n+struct ThrowDefaultClass { ThrowDefaultClass () noexcept (false); };\n+struct ThrowCopyConsClass { ThrowCopyConsClass (const ThrowCopyConsClass &) noexcept (false); };\n+struct ThrowMoveConsClass { ThrowMoveConsClass (ThrowMoveConsClass &&) noexcept (false); };\n+struct NoexceptDefaultClass { NoexceptDefaultClass () noexcept (true); };\n+struct ExceptDefaultClass { ExceptDefaultClass () noexcept (false); };\n+struct NoexceptCopyConsClass { NoexceptCopyConsClass (const NoexceptCopyConsClass &) noexcept (true); };\n+struct ExceptCopyConsClass { ExceptCopyConsClass (const ExceptCopyConsClass &) noexcept (false); };\n+struct NoexceptMoveConsClass { NoexceptMoveConsClass (NoexceptMoveConsClass &&) noexcept (true); NoexceptMoveConsClass &operator= (NoexceptMoveConsClass &&) = default; };\n+struct ExceptMoveConsClass { ExceptMoveConsClass (ExceptMoveConsClass &&) noexcept (false); };\n+struct NoexceptCopyAssignClass { NoexceptCopyAssignClass &operator= (const NoexceptCopyAssignClass &) noexcept (true); };\n+struct ExceptCopyAssignClass { ExceptCopyAssignClass &operator= (const ExceptCopyAssignClass &) noexcept (false); };\n+struct NoexceptMoveAssignClass { NoexceptMoveAssignClass (NoexceptMoveAssignClass &&) = default; NoexceptMoveAssignClass &operator= (NoexceptMoveAssignClass &&) noexcept (true); };\n+struct ExceptMoveAssignClass { ExceptMoveAssignClass &operator= (ExceptMoveAssignClass &&) noexcept (false); };\n+struct DeletedCopyAssignClass { DeletedCopyAssignClass & operator= (const DeletedCopyAssignClass &) = delete; };\n+struct DeletedMoveAssignClass { DeletedMoveAssignClass &operator= (DeletedMoveAssignClass &&) = delete; };\n+struct NType { int i; int j; virtual ~NType (); };\n+struct TType { int i; private: int j; };\n+struct SLType { int i; int j; ~SLType (); };\n+struct PODType { int i; int j; };\n+struct Empty {};\n+struct B { int i; B () {} };\n+struct D : B {};\n+enum E { ee1 };\n+enum E2 { ee2 };\n+enum class SE { e1 };\n+enum class SE2 { e2 };\n+enum OpE : int;\n+enum class OpSE : bool;\n+union U { int i; Empty b; };\n+struct Abstract { virtual ~Abstract () = 0; };\n+struct AbstractDelDtor { ~AbstractDelDtor () = delete; virtual void foo () = 0; };\n+struct Ukn;\n+template <class To>\n+struct ImplicitTo { operator To (); };\n+template <class To>\n+struct DelImplicitTo { operator To () = delete; };\n+template <class To>\n+struct ExplicitTo { explicit operator To (); };\n+struct Ellipsis { Ellipsis (...) {} };\n+struct DelEllipsis { DelEllipsis (...) = delete; };\n+struct Any { template <class T> Any (T &&) {} };\n+struct nAny { template <class... T> nAny (T &&...) {} };\n+struct DelnAny { template <class... T> DelnAny (T &&...) = delete; };\n+template <class... Args>\n+struct FromArgs { FromArgs (Args...); };\n+struct DelDef { DelDef () = delete; };\n+struct DelCopy { DelCopy (const DelCopy &) = delete; };\n+struct DelDtor {\n+ DelDtor () = default;\n+ DelDtor (const DelDtor &) = default;\n+ DelDtor (DelDtor &&) = default;\n+ DelDtor (int);\n+ DelDtor (int, B, U);\n+ ~DelDtor () = delete;\n+};\n+struct Nontrivial {\n+ Nontrivial ();\n+ Nontrivial (const Nontrivial &);\n+ Nontrivial &operator= (const Nontrivial &);\n+ ~Nontrivial ();\n+};\n+union NontrivialUnion { int i; Nontrivial n; };\n+struct UnusualCopy { UnusualCopy (UnusualCopy &); };\n+\n+static_assert (is_constructible_type (^^int, { ^^int }));\n+static_assert (is_constructible_type (^^std::nullptr_t, { ^^std::nullptr_t }));\n+static_assert (is_constructible_type (^^E, { ^^E }));\n+static_assert (is_constructible_type (^^SE, { ^^SE }));\n+static_assert (is_constructible_type (^^OpE, { ^^OpE }));\n+static_assert (is_constructible_type (^^OpSE, { ^^OpSE }));\n+static_assert (is_constructible_type (^^Empty, { ^^Empty }));\n+static_assert (is_constructible_type (^^B, { ^^B }));\n+static_assert (is_constructible_type (^^U, { ^^U }));\n+static_assert (is_constructible_type (^^int B::*, { ^^int B::* }));\n+static_assert (is_constructible_type (^^Ellipsis, { ^^Ellipsis }));\n+static_assert (is_constructible_type (^^int *, { ^^int * }));\n+static_assert (is_constructible_type (^^void *, { ^^void * }));\n+static_assert (is_constructible_type (^^Any, { ^^Any }));\n+static_assert (is_constructible_type (^^nAny, { ^^nAny }));\n+static_assert (is_constructible_type (^^std::initializer_list <int>, { ^^std::initializer_list <int> }));\n+static_assert (is_constructible_type (^^DelDef, { ^^DelDef }));\n+static_assert (!is_constructible_type (^^void, { ^^void }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^Abstract }));\n+static_assert (!is_constructible_type (^^int [], { ^^int [] }));\n+static_assert (!is_constructible_type (^^int [1], { ^^int [1] }));\n+static_assert (!is_constructible_type (^^DelCopy, { ^^const DelCopy & }));\n+static_assert (!is_constructible_type (^^DelCopy, { ^^DelCopy && }));\n+static_assert (!is_constructible_type (^^DelCopy, { ^^DelCopy }));\n+static_assert (!is_constructible_type (^^DelDtor, { ^^void }));\n+static_assert (!is_constructible_type (^^DelDtor, { ^^int }));\n+static_assert (!is_constructible_type (^^DelDtor, { ^^DelDtor }));\n+static_assert (!is_constructible_type (^^DelDtor, { ^^DelDtor && }));\n+static_assert (!is_constructible_type (^^DelDtor, { ^^const DelDtor & }));\n+static_assert (is_constructible_type (^^DelEllipsis, { ^^const DelEllipsis & }));\n+static_assert (is_constructible_type (^^DelEllipsis, { ^^DelEllipsis && }));\n+static_assert (is_constructible_type (^^DelEllipsis, { ^^DelEllipsis }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^void }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^B }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^Empty }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^E }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^SE }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^OpE }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^void () }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^void () const }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^int [1] }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^int [] }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^int * }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^void * }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^int B::* }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^int D::* }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^Abstract }));\n+static_assert (!is_constructible_type (^^int, { ^^DelImplicitTo <int> }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^DelImplicitTo <std::nullptr_t> }));\n+static_assert (!is_constructible_type (^^int &, { ^^DelImplicitTo <const int &> }));\n+static_assert (!is_constructible_type (^^int, { ^^void }));\n+static_assert (!is_constructible_type (^^void, { ^^int }));\n+static_assert (is_constructible_type (^^void *, { ^^int * }));\n+static_assert (!is_constructible_type (^^int *, { ^^void * }));\n+static_assert (is_constructible_type (^^int *, { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^int * }));\n+static_assert (!is_constructible_type (^^Empty, { ^^E }));\n+static_assert (!is_constructible_type (^^Empty, { ^^SE }));\n+static_assert (!is_constructible_type (^^Empty, { ^^OpE }));\n+static_assert (!is_constructible_type (^^Empty, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^Empty, { ^^void }));\n+static_assert (!is_constructible_type (^^Empty, { ^^void * }));\n+static_assert (!is_constructible_type (^^Empty, { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^Empty, { ^^int [] }));\n+static_assert (!is_constructible_type (^^Empty, { ^^int [3] }));\n+static_assert (!is_constructible_type (^^Empty, { ^^int }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^int }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^Abstract }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^int [] }));\n+static_assert (is_constructible_type (^^B, { ^^D }));\n+static_assert (!is_constructible_type (^^int [], { ^^int [1] }));\n+static_assert (!is_constructible_type (^^int [1], { ^^int [] }));\n+static_assert (!is_constructible_type (^^int [], { ^^Empty }));\n+static_assert (!is_constructible_type (^^int [], { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^int [1], { ^^Abstract }));\n+static_assert (is_constructible_type (^^const int *, { ^^int * }));\n+static_assert (is_constructible_type (^^const void *, { ^^void * }));\n+static_assert (is_constructible_type (^^const void *, { ^^int * }));\n+static_assert (!is_constructible_type (^^int *, { ^^const void * }));\n+static_assert (is_constructible_type (^^int, { ^^E }));\n+static_assert (!is_constructible_type (^^E, { ^^int }));\n+static_assert (!is_constructible_type (^^E, { ^^E2 }));\n+static_assert (is_constructible_type (^^E, { ^^E }));\n+static_assert (is_constructible_type (^^bool, { ^^E }));\n+static_assert (!is_constructible_type (^^E, { ^^bool }));\n+static_assert (is_constructible_type (^^double, { ^^E }));\n+static_assert (!is_constructible_type (^^E, { ^^double }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^E }));\n+static_assert (!is_constructible_type (^^E, { ^^std::nullptr_t }));\n+static_assert (is_constructible_type (^^int, { ^^OpE }));\n+static_assert (!is_constructible_type (^^OpE, { ^^int }));\n+static_assert (!is_constructible_type (^^OpE, { ^^E2 }));\n+static_assert (is_constructible_type (^^OpE, { ^^OpE }));\n+static_assert (is_constructible_type (^^bool, { ^^OpE }));\n+static_assert (!is_constructible_type (^^OpE, { ^^bool }));\n+static_assert (is_constructible_type (^^double, { ^^OpE }));\n+static_assert (!is_constructible_type (^^OpE, { ^^double }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^OpE }));\n+static_assert (!is_constructible_type (^^OpE, { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^int, { ^^SE }));\n+static_assert (!is_constructible_type (^^SE, { ^^int }));\n+static_assert (!is_constructible_type (^^E, { ^^SE }));\n+static_assert (!is_constructible_type (^^SE, { ^^SE2 }));\n+static_assert (is_constructible_type (^^SE, { ^^SE }));\n+static_assert (!is_constructible_type (^^bool, { ^^SE }));\n+static_assert (!is_constructible_type (^^SE, { ^^bool }));\n+static_assert (!is_constructible_type (^^double, { ^^SE }));\n+static_assert (!is_constructible_type (^^SE, { ^^double }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^SE }));\n+static_assert (!is_constructible_type (^^SE, { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^int, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^int }));\n+static_assert (!is_constructible_type (^^OpE, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^SE2 }));\n+static_assert (is_constructible_type (^^OpSE, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^bool, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^bool }));\n+static_assert (!is_constructible_type (^^double, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^double }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^D *, { ^^B * }));\n+static_assert (!is_constructible_type (^^const volatile D *, { ^^B * }));\n+static_assert (!is_constructible_type (^^D *, { ^^const volatile B * }));\n+static_assert (!is_constructible_type (^^D *, { ^^B * const }));\n+static_assert (!is_constructible_type (^^const volatile D *, { ^^B * const }));\n+static_assert (!is_constructible_type (^^D *, { ^^const volatile B * const }));\n+static_assert (!is_constructible_type (^^D *, { ^^B * & }));\n+static_assert (!is_constructible_type (^^const volatile D *, { ^^B * & }));\n+static_assert (!is_constructible_type (^^D *, { ^^const volatile B * & }));\n+static_assert (!is_constructible_type (^^int B::*, { ^^int D::* }));\n+static_assert (!is_constructible_type (^^const volatile int B::*, { ^^int D::* }));\n+static_assert (!is_constructible_type (^^int B::*, { ^^const volatile int D::* }));\n+static_assert (!is_constructible_type (^^int B::*, { ^^int D::* const }));\n+static_assert (!is_constructible_type (^^const volatile int B::*, { ^^int D::* const }));\n+static_assert (!is_constructible_type (^^int B::*, { ^^const volatile int D::* const }));\n+static_assert (!is_constructible_type (^^int B::*, { ^^int D::* & }));\n+static_assert (!is_constructible_type (^^const volatile int B::*, { ^^int D::* & }));\n+static_assert (!is_constructible_type (^^int B::*, { ^^const volatile int D::* & }));\n+static_assert (!is_constructible_type (^^int B::*, { ^^int D::* const & }));\n+static_assert (!is_constructible_type (^^const volatile int B::*, { ^^int D::* const & }));\n+static_assert (!is_constructible_type (^^int B::*, { ^^const volatile int D::* const & }));\n+static_assert (!is_constructible_type (^^int &&, { ^^int & }));\n+static_assert (!is_constructible_type (^^const int &&, { ^^int & }));\n+static_assert (is_constructible_type (^^B &, { ^^D & }));\n+static_assert (is_constructible_type (^^B &&, { ^^D && }));\n+static_assert (is_constructible_type (^^const B &, { ^^D & }));\n+static_assert (is_constructible_type (^^const B &&, { ^^D && }));\n+static_assert (!is_constructible_type (^^B &, { ^^const D & }));\n+static_assert (!is_constructible_type (^^B &&, { ^^const D && }));\n+static_assert (!is_constructible_type (^^D &, { ^^B & }));\n+static_assert (is_constructible_type (^^D &&, { ^^B && }));\n+static_assert (!is_constructible_type (^^D &, { ^^const B & }));\n+static_assert (is_constructible_type (^^D &&, { ^^const B && }));\n+static_assert (is_constructible_type (^^const D &, { ^^B & }));\n+static_assert (is_constructible_type (^^const D &&, { ^^B && }));\n+static_assert (!is_constructible_type (^^B &&, { ^^B & }));\n+static_assert (!is_constructible_type (^^B &&, { ^^D & }));\n+static_assert (is_constructible_type (^^B &&, { ^^ImplicitTo <D &&> }));\n+static_assert (is_constructible_type (^^B &&, { ^^ImplicitTo <D &&> & }));\n+static_assert (is_constructible_type (^^int &&, { ^^double & }));\n+static_assert (is_constructible_type (^^const int &, { ^^ImplicitTo <int &> & }));\n+static_assert (is_constructible_type (^^const int &, { ^^ImplicitTo <int &> }));\n+static_assert (is_constructible_type (^^const int &, { ^^ExplicitTo <int &> & }));\n+static_assert (is_constructible_type (^^const int &, { ^^ExplicitTo <int &> }));\n+static_assert (!is_constructible_type (^^B &&, { ^^ExplicitTo <D &&> }));\n+static_assert (!is_constructible_type (^^B &&, { ^^ExplicitTo <D &&> & }));\n+static_assert (!is_constructible_type (^^B &, { ^^B && }));\n+static_assert (!is_constructible_type (^^D &, { ^^B && }));\n+static_assert (!is_constructible_type (^^B &, { ^^D && }));\n+static_assert (is_constructible_type (^^void (&) (), { ^^void (&) () }));\n+static_assert (is_constructible_type (^^void (&&) (), { ^^void (&&) () }));\n+static_assert (is_constructible_type (^^void (&&) (), { ^^void () }));\n+static_assert (!is_constructible_type (^^void, { }));\n+static_assert (!is_constructible_type (^^void, { ^^int }));\n+static_assert (!is_constructible_type (^^void, { ^^int, ^^double }));\n+static_assert (!is_constructible_type (^^int &, {}));\n+static_assert (!is_constructible_type (^^const int &, {}));\n+static_assert (!is_constructible_type (^^int &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const int &, { ^^int, ^^int }));\n+static_assert (is_constructible_type (^^void (&) (), { ^^void () }));\n+static_assert (is_constructible_type (^^void (&) (), { ^^void (&&) () }));\n+static_assert (is_constructible_type (^^int &, { ^^int & }));\n+static_assert (!is_constructible_type (^^int &, { ^^const int & }));\n+static_assert (!is_constructible_type (^^int &, { ^^int }));\n+static_assert (!is_constructible_type (^^int &, { ^^int && }));\n+static_assert (!is_constructible_type (^^int &, { ^^const int && }));\n+static_assert (is_constructible_type (^^const int &, { ^^int & }));\n+static_assert (is_constructible_type (^^const int &, { ^^int }));\n+static_assert (is_constructible_type (^^const int &, { ^^const int }));\n+static_assert (is_constructible_type (^^const int &, { ^^int && }));\n+static_assert (is_constructible_type (^^const int &, { ^^const int && }));\n+static_assert (is_constructible_type (^^volatile int &, { ^^int & }));\n+static_assert (!is_constructible_type (^^volatile int &, { ^^const int & }));\n+static_assert (!is_constructible_type (^^volatile int &, { ^^int }));\n+static_assert (!is_constructible_type (^^volatile int &, { ^^int && }));\n+static_assert (!is_constructible_type (^^volatile int &, { ^^const int && }));\n+static_assert (is_constructible_type (^^const volatile int &, { ^^int & }));\n+static_assert (!is_constructible_type (^^const volatile int &, { ^^int }));\n+static_assert (!is_constructible_type (^^const volatile int &, { ^^const int }));\n+static_assert (!is_constructible_type (^^const volatile int &, { ^^int && }));\n+static_assert (!is_constructible_type (^^const volatile int &, { ^^const int && }));\n+static_assert (is_constructible_type (^^int &&, { ^^int }));\n+static_assert (is_constructible_type (^^int &&, { ^^int && }));\n+static_assert (!is_constructible_type (^^int &&, { ^^const int && }));\n+static_assert (!is_constructible_type (^^int &&, { ^^int & }));\n+static_assert (!is_constructible_type (^^int &&, { ^^const int & }));\n+static_assert (is_constructible_type (^^int &&, { ^^double & }));\n+static_assert (is_constructible_type (^^const int &&, { ^^int }));\n+static_assert (is_constructible_type (^^const int &&, { ^^int && }));\n+static_assert (is_constructible_type (^^const int &&, { ^^const int }));\n+static_assert (is_constructible_type (^^const int &&, { ^^const int && }));\n+static_assert (!is_constructible_type (^^int &&, { ^^const int & }));\n+static_assert (!is_constructible_type (^^const int &&, { ^^int & }));\n+static_assert (!is_constructible_type (^^const int &&, { ^^const int & }));\n+static_assert (is_constructible_type (^^volatile int &&, { ^^int }));\n+static_assert (is_constructible_type (^^volatile int &&, { ^^int && }));\n+static_assert (!is_constructible_type (^^volatile int &&, { ^^const int && }));\n+static_assert (!is_constructible_type (^^volatile int &&, { ^^int & }));\n+static_assert (!is_constructible_type (^^volatile int &&, { ^^const int & }));\n+static_assert (is_constructible_type (^^volatile int &&, { ^^double & }));\n+static_assert (is_constructible_type (^^volatile const int &&, { ^^int }));\n+static_assert (is_constructible_type (^^const volatile int &&, { ^^int && }));\n+static_assert (is_constructible_type (^^const volatile int &&, { ^^const int }));\n+static_assert (is_constructible_type (^^const volatile int &&, { ^^const int && }));\n+static_assert (!is_constructible_type (^^volatile int &&, { ^^const int & }));\n+static_assert (!is_constructible_type (^^const volatile int &&, { ^^int & }));\n+static_assert (!is_constructible_type (^^const volatile int &&, { ^^const int & }));\n+static_assert (is_constructible_type (^^Empty &, { ^^Empty & }));\n+static_assert (!is_constructible_type (^^Empty &, { ^^const Empty & }));\n+static_assert (!is_constructible_type (^^Empty &, { ^^Empty }));\n+static_assert (!is_constructible_type (^^Empty &, { ^^Empty && }));\n+static_assert (!is_constructible_type (^^Empty &, { ^^const Empty && }));\n+static_assert (is_constructible_type (^^const Empty &, { ^^Empty & }));\n+static_assert (is_constructible_type (^^const Empty &, { ^^Empty }));\n+static_assert (is_constructible_type (^^const Empty &, { ^^const Empty }));\n+static_assert (is_constructible_type (^^const Empty &, { ^^Empty && }));\n+static_assert (is_constructible_type (^^const Empty &, { ^^const Empty && }));\n+static_assert (is_constructible_type (^^volatile Empty &, { ^^Empty & }));\n+static_assert (!is_constructible_type (^^volatile Empty &, { ^^const Empty & }));\n+static_assert (!is_constructible_type (^^volatile Empty &, { ^^Empty }));\n+static_assert (!is_constructible_type (^^volatile Empty &, { ^^Empty && }));\n+static_assert (!is_constructible_type (^^volatile Empty &, { ^^const Empty && }));\n+static_assert (is_constructible_type (^^const volatile Empty &, { ^^Empty & }));\n+static_assert (!is_constructible_type (^^const volatile Empty &, { ^^Empty }));\n+static_assert (!is_constructible_type (^^const volatile Empty &, { ^^const Empty }));\n+static_assert (!is_constructible_type (^^const volatile Empty &, { ^^Empty && }));\n+static_assert (!is_constructible_type (^^const volatile Empty &, { ^^const Empty && }));\n+static_assert (is_constructible_type (^^Empty &&, { ^^Empty }));\n+static_assert (is_constructible_type (^^Empty &&, { ^^Empty && }));\n+static_assert (!is_constructible_type (^^Empty &&, { ^^const Empty && }));\n+static_assert (!is_constructible_type (^^Empty &&, { ^^Empty & }));\n+static_assert (!is_constructible_type (^^Empty &&, { ^^const Empty & }));\n+static_assert (!is_constructible_type (^^Empty &&, { ^^double & }));\n+static_assert (!is_constructible_type (^^Empty &&, { ^^const double & }));\n+static_assert (is_constructible_type (^^const Empty &&, { ^^Empty }));\n+static_assert (is_constructible_type (^^const Empty &&, { ^^Empty && }));\n+static_assert (is_constructible_type (^^const Empty &&, { ^^const Empty }));\n+static_assert (is_constructible_type (^^const Empty &&, { ^^const Empty && }));\n+static_assert (!is_constructible_type (^^Empty &&, { ^^const Empty & }));\n+static_assert (!is_constructible_type (^^const Empty &&, { ^^Empty & }));\n+static_assert (!is_constructible_type (^^const Empty &&, { ^^const Empty & }));\n+static_assert (is_constructible_type (^^volatile Empty &&, { ^^Empty }));\n+static_assert (is_constructible_type (^^volatile Empty &&, { ^^Empty && }));\n+static_assert (!is_constructible_type (^^volatile Empty &&, { ^^const Empty && }));\n+static_assert (!is_constructible_type (^^volatile Empty &&, { ^^Empty & }));\n+static_assert (!is_constructible_type (^^volatile Empty &&, { ^^const Empty & }));\n+static_assert (!is_constructible_type (^^volatile Empty &&, { ^^double & }));\n+static_assert (!is_constructible_type (^^volatile Empty &&, { ^^const double & }));\n+static_assert (is_constructible_type (^^const volatile Empty &&, { ^^Empty }));\n+static_assert (is_constructible_type (^^const volatile Empty &&, { ^^Empty && }));\n+static_assert (is_constructible_type (^^const volatile Empty &&, { ^^const Empty }));\n+static_assert (is_constructible_type (^^const volatile Empty &&, { ^^const Empty && }));\n+static_assert (!is_constructible_type (^^volatile Empty &&, { ^^const Empty & }));\n+static_assert (!is_constructible_type (^^const volatile Empty &&, { ^^Empty & }));\n+static_assert (!is_constructible_type (^^const volatile Empty &&, { ^^const Empty & }));\n+static_assert (is_constructible_type (^^Ellipsis, { ^^int }));\n+static_assert (is_constructible_type (^^Ellipsis, { ^^Empty }));\n+static_assert (is_constructible_type (^^Ellipsis, { ^^std::nullptr_t }));\n+static_assert (is_constructible_type (^^Ellipsis, { ^^int [] }));\n+static_assert (is_constructible_type (^^Ellipsis, { ^^int [1] }));\n+static_assert (!is_constructible_type (^^Ellipsis, { ^^void }));\n+static_assert (is_constructible_type (^^int (&) [1], { ^^int (&) [1] }));\n+static_assert (is_constructible_type (^^const int (&) [1], { ^^int (&) [1] }));\n+static_assert (is_constructible_type (^^volatile int (&) [1], { ^^int (&) [1] }));\n+static_assert (is_constructible_type (^^const volatile int (&) [1], { ^^int (&) [1] }));\n+static_assert (!is_constructible_type (^^int (&) [1], { ^^const int (&) [1] }));\n+static_assert (!is_constructible_type (^^const int (&) [1], { ^^volatile int (&) [1] }));\n+static_assert (is_constructible_type (^^int (&) [], { ^^int (&) [] }));\n+static_assert (!is_constructible_type (^^int (&) [1], { ^^int (&) [2] }));\n+static_assert (!is_constructible_type (^^int (&) [1], { ^^int & }));\n+static_assert (!is_constructible_type (^^int &, { ^^int (&) [1] }));\n+static_assert (!is_constructible_type (^^U, { ^^Empty }));\n+static_assert (!is_constructible_type (^^void (), { ^^void () }));\n+static_assert (!is_constructible_type (^^void (), { ^^int }));\n+static_assert (!is_constructible_type (^^void (), { ^^Abstract }));\n+static_assert (!is_constructible_type (^^void (), { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^void (), { ^^Empty }));\n+static_assert (!is_constructible_type (^^void (), { ^^U }));\n+static_assert (!is_constructible_type (^^void (), { ^^E }));\n+static_assert (!is_constructible_type (^^void (), { ^^SE }));\n+static_assert (!is_constructible_type (^^void (), { ^^OpE }));\n+static_assert (!is_constructible_type (^^void (), { ^^OpSE }));\n+static_assert (!is_constructible_type (^^void (), { ^^int [] }));\n+static_assert (!is_constructible_type (^^void (), { ^^int [1] }));\n+static_assert (!is_constructible_type (^^void () const, { ^^void () volatile }));\n+static_assert (!is_constructible_type (^^void () const, { ^^int }));\n+static_assert (!is_constructible_type (^^void () const, { ^^Abstract }));\n+static_assert (!is_constructible_type (^^void () const, { ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^void () const, { ^^Empty }));\n+static_assert (!is_constructible_type (^^void () const, { ^^U }));\n+static_assert (!is_constructible_type (^^void () const, { ^^E }));\n+static_assert (!is_constructible_type (^^void () const, { ^^SE }));\n+static_assert (!is_constructible_type (^^void () const, { ^^OpE }));\n+static_assert (!is_constructible_type (^^void () const, { ^^OpSE }));\n+static_assert (!is_constructible_type (^^void () const, { ^^int [] }));\n+static_assert (!is_constructible_type (^^void () const, { ^^int [1] }));\n+static_assert (!is_constructible_type (^^void (int), { ^^void () }));\n+static_assert (!is_constructible_type (^^int, { ^^void () }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^void () }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^void () }));\n+static_assert (!is_constructible_type (^^Empty, { ^^void () }));\n+static_assert (!is_constructible_type (^^U, { ^^void () }));\n+static_assert (!is_constructible_type (^^E, { ^^void () }));\n+static_assert (!is_constructible_type (^^SE, { ^^void () }));\n+static_assert (!is_constructible_type (^^OpE, { ^^void () }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^void () }));\n+static_assert (!is_constructible_type (^^int [], { ^^void () }));\n+static_assert (!is_constructible_type (^^int [1], { ^^void () }));\n+static_assert (!is_constructible_type (^^void (int) const, { ^^void () const }));\n+static_assert (!is_constructible_type (^^int, { ^^void () const }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^void () const }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^void () const }));\n+static_assert (!is_constructible_type (^^Empty, { ^^void () const }));\n+static_assert (!is_constructible_type (^^U, { ^^void () const }));\n+static_assert (!is_constructible_type (^^E, { ^^void () const }));\n+static_assert (!is_constructible_type (^^SE, { ^^void () const }));\n+static_assert (!is_constructible_type (^^OpE, { ^^void () const }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^void () const }));\n+static_assert (!is_constructible_type (^^int [], { ^^void () const }));\n+static_assert (!is_constructible_type (^^int [1], { ^^void () const }));\n+static_assert (!is_constructible_type (^^void, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^void, { ^^Empty, ^^B }));\n+static_assert (!is_constructible_type (^^void, { ^^Empty, ^^Empty }));\n+static_assert (!is_constructible_type (^^void, { ^^U, ^^Empty }));\n+static_assert (!is_constructible_type (^^void, { ^^U, ^^U }));\n+static_assert (!is_constructible_type (^^void, { ^^std::nullptr_t, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^void, { ^^int [1], ^^int [1] }));\n+static_assert (!is_constructible_type (^^void, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^void, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^void, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^void, { ^^void (), ^^void () }));\n+static_assert (!is_constructible_type (^^void, { ^^void () const, ^^void () volatile }));\n+static_assert (!is_constructible_type (^^int, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const int, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^int, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const int, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^int, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const int, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^bool, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const bool, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const std::nullptr_t, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const std::nullptr_t, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^std::nullptr_t, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const std::nullptr_t, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^E, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const E, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^E, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const E, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^E, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const E, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^SE, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const SE, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^SE, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const SE, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^SE, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const SE, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^OpE, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const OpE, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^OpE, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const OpE, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^OpE, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const OpE, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const OpSE, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const OpSE, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const OpSE, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^Empty, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const Empty, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^Empty, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const Empty, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^Empty, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const Empty, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^U, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const U, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^U, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const U, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^U, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const U, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^B, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const B, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^B, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const B, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^B, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const B, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^Any, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const Any, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^Any, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const Any, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^Any, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const Any, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^nAny, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const nAny, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^nAny, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const nAny, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^FromArgs <>, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const FromArgs <>, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^FromArgs <>, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const FromArgs <>, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^FromArgs <>, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const FromArgs <>, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const Abstract, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const Abstract, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^Abstract, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const Abstract, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^AbstractDelDtor, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const AbstractDelDtor, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^AbstractDelDtor, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const AbstractDelDtor, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^AbstractDelDtor, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const AbstractDelDtor, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^int [1], { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const int [1], { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^int [1], { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const int [1], { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^int [1], { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^const int [1], { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^int &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^int &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^int &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^int &, { ^^int &, ^^int & }));\n+static_assert (!is_constructible_type (^^int &, { ^^void, ^^int & }));\n+static_assert (!is_constructible_type (^^int &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^std::nullptr_t &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^std::nullptr_t &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^std::nullptr_t &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^E &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^E &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^E &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^SE &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^SE &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^SE &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^OpE &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^OpE &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^OpE &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^OpSE &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^OpSE &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^OpSE &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^Empty &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^Empty &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^Empty &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^U &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^U &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^U &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^B &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^B &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^B &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^Any &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^Any &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^Any &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^nAny &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^nAny &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^FromArgs <> &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^FromArgs <> &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^FromArgs <> &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^Abstract &, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^Abstract &, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^Abstract &, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^int (&) [1], { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^int (&) [1], { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^int (&) [1], { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^void (), { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^void (), { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^void (), { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^void (), { ^^void (), ^^int }));\n+static_assert (!is_constructible_type (^^void (), { ^^void (), ^^void () }));\n+static_assert (!is_constructible_type (^^void () const, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^void () const, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^void () const, { ^^void, ^^void }));\n+static_assert (!is_constructible_type (^^void () const, { ^^void () volatile, ^^int }));\n+static_assert (!is_constructible_type (^^void () const, { ^^void () volatile const, ^^void () const }));\n+static_assert (!is_constructible_type (^^FromArgs <int>, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const FromArgs <int>, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^FromArgs <int>, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const FromArgs <int>, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^FromArgs <int, int>, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^const FromArgs <int, int>, { ^^void, ^^int }));\n+static_assert (!is_constructible_type (^^DelDtor, { ^^int, ^^B, ^^U }));\n+static_assert (!is_constructible_type (^^const DelDtor, { ^^int, ^^B, ^^U }));\n+static_assert (!is_constructible_type (^^DelDtor, { ^^int }));\n+static_assert (!is_constructible_type (^^const DelDtor, { ^^int }));\n+static_assert (!is_constructible_type (^^DelDtor, {}));\n+static_assert (!is_constructible_type (^^const DelDtor, {}));\n+static_assert (!is_constructible_type (^^DelDtor, { ^^void *, ^^void (&) () }));\n+static_assert (!is_constructible_type (^^const DelDtor, { ^^void *, ^^void (&) () }));\n+static_assert (!is_constructible_type (^^AbstractDelDtor, {}));\n+static_assert (!is_constructible_type (^^const AbstractDelDtor, {}));\n+static_assert (!is_constructible_type (^^DelEllipsis, {}));\n+static_assert (!is_constructible_type (^^const DelEllipsis, {}));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^double }));\n+static_assert (!is_constructible_type (^^const DelEllipsis, { ^^double }));\n+static_assert (!is_constructible_type (^^DelEllipsis, { ^^double, ^^int & }));\n+static_assert (!is_constructible_type (^^const DelEllipsis, { ^^double, ^^int & }));\n+static_assert (!is_constructible_type (^^DelnAny, {}));\n+static_assert (!is_constructible_type (^^const DelnAny, {}));\n+static_assert (!is_constructible_type (^^DelnAny, { ^^int }));\n+static_assert (!is_constructible_type (^^const DelnAny, { ^^int }));\n+static_assert (!is_constructible_type (^^DelnAny, { ^^int, ^^void * }));\n+static_assert (!is_constructible_type (^^const DelnAny, { ^^int, ^^void * }));\n+static_assert (!is_constructible_type (^^DelnAny, { ^^Empty, ^^B, ^^D }));\n+static_assert (!is_constructible_type (^^const DelnAny, { ^^Empty, ^^B, ^^D }));\n+static_assert (!is_constructible_type (^^NontrivialUnion, {}));\n+static_assert (!is_constructible_type (^^NontrivialUnion, { ^^const NontrivialUnion & }));\n+static_assert (!is_constructible_type (^^UnusualCopy, {}));\n+static_assert (!is_constructible_type (^^UnusualCopy, { ^^UnusualCopy }));\n+static_assert (!is_constructible_type (^^UnusualCopy, { ^^UnusualCopy && }));\n+static_assert (!is_constructible_type (^^UnusualCopy, { ^^const UnusualCopy & }));\n+static_assert (is_constructible_type (^^UnusualCopy, { ^^UnusualCopy & }));\n+static_assert (is_constructible_type (^^FromArgs <int, char>, { ^^int, ^^char }));\n+static_assert (is_constructible_type (^^const FromArgs <int, char>, { ^^int, ^^char }));\n+static_assert (is_constructible_type (^^FromArgs <int, char>, { ^^int, ^^int }));\n+static_assert (is_constructible_type (^^const FromArgs <int, char>, { ^^int, ^^int }));\n+static_assert (is_constructible_type (^^nAny, { ^^int, ^^int }));\n+static_assert (is_constructible_type (^^const nAny, { ^^int, ^^int }));\n+static_assert (is_constructible_type (^^FromArgs <int, char>, { ^^ImplicitTo <int>, ^^ImplicitTo <char> }));\n+static_assert (is_constructible_type (^^const FromArgs <int, char>, { ^^ImplicitTo <int>, ^^ImplicitTo <char> }));\n+static_assert (is_constructible_type (^^Ellipsis, { ^^int, ^^char }));\n+static_assert (is_constructible_type (^^const Ellipsis, { ^^int, ^^char }));\n+static_assert (is_constructible_type (^^Ellipsis, { ^^B, ^^U, ^^int & }));\n+static_assert (is_constructible_type (^^const Ellipsis, { ^^B, ^^U, ^^int & }));\n+static_assert (is_constructible_type (^^nAny, { ^^B, ^^U, ^^int & }));\n+static_assert (is_constructible_type (^^const nAny, { ^^B, ^^U, ^^int & }));\n+static_assert (is_constructible_type (^^FromArgs <std::initializer_list <int>, std::initializer_list <B>>, { ^^std::initializer_list <int>, ^^std::initializer_list <B> }));\n+static_assert (is_constructible_type (^^const FromArgs <std::initializer_list <int>, std::initializer_list <B>>, { ^^std::initializer_list <int>, ^^std::initializer_list <B> }));\n+static_assert (is_constructible_type (^^FromArgs <std::initializer_list <int>, std::initializer_list <B>>, { ^^std::initializer_list <int> &, ^^std::initializer_list <B> & }));\n+static_assert (!is_constructible_type (^^FromArgs <std::initializer_list <int> &, std::initializer_list <B> &>, { ^^std::initializer_list <int>, ^^std::initializer_list <B> }));\n+static_assert (!is_constructible_type (^^FromArgs <std::initializer_list <int>>, { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const FromArgs <std::initializer_list <int>>, { ^^int, ^^int }));\n+static_assert (is_constructible_type (^^B [2], { ^^B, ^^B }));\n+static_assert (is_constructible_type (^^const B [2], { ^^B, ^^B }));\n+static_assert (is_constructible_type (^^U [2], { ^^U, ^^U }));\n+static_assert (is_constructible_type (^^const U [2], { ^^U, ^^U }));\n+static_assert (!is_constructible_type (^^E, { ^^E, ^^E }));\n+static_assert (!is_constructible_type (^^const E, { ^^E, ^^E }));\n+static_assert (!is_constructible_type (^^SE, { ^^SE, ^^SE }));\n+static_assert (!is_constructible_type (^^const SE, { ^^SE, ^^SE }));\n+static_assert (!is_constructible_type (^^E, { ^^B, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^const E, { ^^B, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^SE, { ^^B, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^const SE, { ^^B, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^E, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^const E, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^SE, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^const SE, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^OpE, { ^^OpE, ^^OpE }));\n+static_assert (!is_constructible_type (^^const OpE, { ^^OpE, ^^OpE }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^OpSE, ^^OpSE }));\n+static_assert (!is_constructible_type (^^const OpSE, { ^^OpSE, ^^OpSE }));\n+static_assert (!is_constructible_type (^^OpE, { ^^B, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^const OpE, { ^^B, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^B, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^const OpSE, { ^^B, ^^std::nullptr_t }));\n+static_assert (!is_constructible_type (^^OpE, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^const OpE, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^OpSE, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^const OpSE, { ^^int [], ^^int [] }));\n+static_assert (!is_constructible_type (^^int [], { ^^int, ^^int }));\n+static_assert (!is_constructible_type (^^const int [], { ^^int, ^^int }));\n+static_assert (is_constructible_type (^^int &, { ^^ImplicitTo <int &> }));\n+static_assert (is_constructible_type (^^const int &, { ^^ImplicitTo <int &&> }));\n+static_assert (is_constructible_type (^^int &&, { ^^ImplicitTo <int &&> }));\n+static_assert (is_constructible_type (^^const int &, { ^^ImplicitTo <int> }));\n+static_assert (!is_constructible_type (^^const int &, { ^^ExplicitTo <int> }));\n+static_assert (!is_constructible_type (^^int &&, { ^^ExplicitTo <int> }));\n+static_assert (is_constructible_type (^^int &, { ^^ExplicitTo <int &> }));\n+static_assert (is_constructible_type (^^int &&, { ^^ExplicitTo <int &&> }));\n+static_assert (!is_constructible_type (^^const int &, { ^^ExplicitTo <int &&> }));\n+static_assert (!is_constructible_type (^^const int &, { ^^ExplicitTo <double &&> }));\n+static_assert (!is_constructible_type (^^int &&, { ^^ExplicitTo <double &&> }));\n+static_assert (is_constructible_type (^^void (&&) (), { ^^void (&) () }));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_constructible_type2.C b/gcc/testsuite/g++.dg/reflect/is_constructible_type2.C\nnew file mode 100644\nindex 00000000000..f309730e987\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_constructible_type2.C\n@@ -0,0 +1,137 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_constructible_type.\n+\n+#include <array>\n+#include <list>\n+#include <meta>\n+#include <ranges>\n+#include <span>\n+#include <vector>\n+\n+using namespace std::meta;\n+\n+template <class... Args>\n+struct FromArgs { FromArgs (Args...); };\n+\n+static_assert (!is_constructible_type (^^FromArgs <int &, long &, const double &>, {}));\n+static_assert (is_constructible_type (^^FromArgs <int &, long &, const double &>, { ^^int &, ^^long &, ^^const double & }));\n+constexpr info arr1[6] = { ^^double, ^^int &, ^^unsigned long long &, ^^int *, ^^short &, ^^char & };\n+static_assert (is_constructible_type (^^FromArgs <double, int &, unsigned long long &, int *, short &, char &>, arr1));\n+constexpr std::span <const info> sp1 (arr1);\n+static_assert (is_constructible_type (^^FromArgs <double, int &, unsigned long long &, int *, short &, char &>, sp1));\n+static_assert (is_constructible_type (^^FromArgs <int &, unsigned long long &, int *>, sp1.subspan (1, 3)));\n+static_assert (is_constructible_type (^^FromArgs <double, int &, unsigned long long &, int *, short &>, sp1.first (5)));\n+static_assert (is_constructible_type (^^FromArgs <int *, unsigned long long &, int &>, sp1.subspan (1, 3) | std::views::reverse));\n+static_assert (is_constructible_type (^^FromArgs <short &, int *, unsigned long long &, int &, double>, sp1.first (5) | std::views::reverse));\n+static_assert (!is_constructible_type (^^FromArgs <double, int &, unsigned long long &, int *, short &>, sp1.first (5) | std::views::reverse));\n+\n+consteval bool\n+foo ()\n+{\n+ auto a = std::vector <info> { ^^int &, ^^long &, ^^long long & };\n+ if (!is_constructible_type (^^FromArgs <int &, long &, long long &>, a))\n+ return false;\n+ auto b = std::vector <info> { ^^short &, ^^double &, ^^float &, ^^char & };\n+ if (!is_constructible_type (^^FromArgs <short &, double &, float &, char &>, b))\n+ return false;\n+ auto c = std::array { ^^long &, ^^short &, ^^char &, ^^int };\n+ if (!is_constructible_type (^^FromArgs <long &, short &, char &, int>, c))\n+ return false;\n+ if (!is_constructible_type (^^FromArgs <long long &, long &, int &>, a | std::views::reverse))\n+ return false;\n+ if (!is_constructible_type (^^FromArgs <char &, float &, double &, short &>, b | std::views::reverse))\n+ return false;\n+ if (!is_constructible_type (^^FromArgs <int, char &, short &, long &>, c | std::views::reverse))\n+ return false;\n+ return true;\n+}\n+static_assert (foo ());\n+\n+struct G\n+{\n+ consteval const info *begin () const { return &arr1[0]; }\n+ consteval const info *end () const { return &arr1[4]; }\n+};\n+static_assert (is_constructible_type (^^FromArgs <double, int &, unsigned long long &, int *>, G {}));\n+\n+struct H\n+{\n+ consteval const info *begin () const { return &arr1[1]; }\n+ consteval const info *end () const { return &arr1[4]; }\n+};\n+static_assert (is_constructible_type (^^FromArgs <int &, unsigned long long &, int *>, H {}));\n+\n+struct I\n+{\n+ using difference_type = std::ptrdiff_t;\n+ using value_type = info;\n+ consteval info operator * () const {\n+ if (p == 0) return arr1[2];\n+ else if (p == 1) return arr1[0];\n+ else if (p == 2) return arr1[1];\n+ else return arr1[3];\n+ }\n+ constexpr I &operator ++ () { ++p; return *this; }\n+ constexpr void operator ++ (int) { ++*this; }\n+ constexpr bool operator == (const I &x) const { return p == x.p; }\n+ int p;\n+};\n+\n+struct J\n+{\n+ constexpr I begin () const { return I { 0 }; }\n+ constexpr I end () const { return I { 4 }; }\n+};\n+static_assert (is_constructible_type (^^FromArgs <unsigned long long &, double, int &, int *>, J {}));\n+\n+struct K\n+{\n+ constexpr K () : q (new int) {}\n+ constexpr K (const K &) : q (new int) {}\n+ constexpr K &operator = (const K &) { return *this; }\n+ constexpr ~K () { delete q; }\n+ int *q;\n+};\n+\n+template <typename T, T E>\n+struct L\n+{\n+ using difference_type = std::ptrdiff_t;\n+ using value_type = T;\n+ constexpr T &operator * () const { return *p; }\n+ constexpr L (T *x) : p (x), q (new int) {}\n+ constexpr L (const L &x) : p (x.p), q (new int) {}\n+ constexpr L &operator = (const L &x) { p = x.p; return *this; }\n+ constexpr ~L () { delete q; }\n+ constexpr L &operator ++ () { ++p; return *this; }\n+ constexpr void operator ++ (int) { ++*this; }\n+ constexpr bool operator == (const L &x) const { return p == x.p; }\n+ constexpr bool operator == (const K &) const { return *p == E; }\n+ T *p;\n+ int *q;\n+};\n+\n+template <typename T, T E>\n+struct M\n+{\n+ constexpr M (T *x) : p (x), q (new int) {}\n+ constexpr M (const M &x) : p (x.p), q (new int) {}\n+ constexpr M &operator = (const M &x) { p = x.p; return *this; }\n+ constexpr ~M () { delete q; }\n+ constexpr L <T, E> begin () const { return L <T, E> (p); }\n+ constexpr K end () const { return K (); }\n+ T *p;\n+ int *q;\n+};\n+\n+consteval bool\n+bar ()\n+{\n+ info a[] = { ^^int &, ^^short &, ^^long &, ^^unsigned &, ^^char &, ^^void, ^^int };\n+ auto b = M <info, ^^void> (&a[0]);\n+ if (!is_constructible_type (^^FromArgs <int &, short &, long &, unsigned &, char &>, b))\n+ return false;\n+ return true;\n+}\n+static_assert (bar ());\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_constructor_template1.C b/gcc/testsuite/g++.dg/reflect/is_constructor_template1.C\nnew file mode 100644\nindex 00000000000..1ca6cb5c7df\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_constructor_template1.C\n@@ -0,0 +1,56 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_constructor_template.\n+\n+#include <meta>\n+#include <ranges>\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 <typename T>\n+ S &operator-(const S&);\n+\n+ operator int();\n+\n+ void fn();\n+};\n+\n+struct T {\n+ template <typename U>\n+ T(int, const U &);\n+};\n+\n+bool operator&&(const S&, const S&);\n+\n+template <typename T>\n+bool operator||(const S&, const T&);\n+\n+int operator\"\"_a(const char *);\n+\n+template<char...>\n+int operator\"\"_b();\n+\n+constexpr auto constructor_template\n+ = (members_of (^^T, access_context::current ()) | std::views::filter (is_template)).front ();\n+\n+static_assert (!is_constructor_template (null_reflection));\n+static_assert (!is_constructor_template (^^int));\n+static_assert (!is_constructor_template (^^::));\n+static_assert (!is_constructor_template (^^foo));\n+static_assert (!is_constructor_template (^^S::operator+));\n+static_assert (!is_constructor_template (^^operator&&));\n+static_assert (!is_constructor_template (^^operator||));\n+static_assert (!is_constructor_template (^^operator||<int>));\n+static_assert (!is_constructor_template (^^S::operator-));\n+static_assert (!is_constructor_template (^^S::operator-<int>));\n+static_assert (!is_constructor_template (^^S::operator int));\n+static_assert (is_constructor_template (constructor_template));\n+static_assert (!is_constructor_template (^^S::fn));\n+static_assert (!is_constructor_template (^^operator\"\"_a));\n+static_assert (!is_constructor_template (^^operator\"\"_b));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_constuctor1.C b/gcc/testsuite/g++.dg/reflect/is_constuctor1.C\nnew file mode 100644\nindex 00000000000..121285c567c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_constuctor1.C\n@@ -0,0 +1,101 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_constructor.\n+\n+#include <meta>\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_constructor (parent_of (^^a)));\n+ }\n+ S (int)\n+ {\n+ int a;\n+ static_assert (is_constructor (parent_of (^^a)));\n+ }\n+ S (const S &)\n+ {\n+ int a;\n+ static_assert (is_constructor (parent_of (^^a)));\n+ }\n+ S (S &&)\n+ {\n+ int a;\n+ static_assert (is_constructor (parent_of (^^a)));\n+ }\n+ S &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ S &operator += (const S &)\n+ {\n+ int a;\n+ static_assert (!is_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ void bar ()\n+ {\n+ int a;\n+ static_assert (!is_constructor (parent_of (^^a)));\n+ }\n+ ~S ()\n+ {\n+ int a;\n+ static_assert (!is_constructor (parent_of (^^a)));\n+ }\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &)\n+ {\n+ int a;\n+ static_assert (!is_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct U {\n+ template <typename T>\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_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_constructor (parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (!is_constructor (null_reflection));\n+static_assert (!is_constructor (^^int));\n+static_assert (!is_constructor (^^::));\n+static_assert (!is_constructor (^^foo));\n+static_assert (!is_constructor (^^S::bar));\n+static_assert (!is_constructor (^^S::operator =));\n+static_assert (!is_constructor (^^S::operator +=));\n+static_assert (!is_constructor (^^T::operator *=));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_conversion_function1.C b/gcc/testsuite/g++.dg/reflect/is_conversion_function1.C\nnew file mode 100644\nindex 00000000000..ef2a8b8be80\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_conversion_function1.C\n@@ -0,0 +1,56 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_conversion_function.\n+\n+#include <meta>\n+#include <ranges>\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 <typename T>\n+ S &operator-(const S&);\n+\n+ operator int();\n+\n+ void fn();\n+};\n+\n+struct T {\n+ template <typename T>\n+ operator T();\n+};\n+\n+bool operator&&(const S&, const S&);\n+\n+template <typename T>\n+bool operator||(const S&, const T&);\n+\n+int operator\"\"_a(const char *);\n+\n+template<char...>\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_conversion_function (null_reflection));\n+static_assert (!is_conversion_function (^^int));\n+static_assert (!is_conversion_function (^^::));\n+static_assert (!is_conversion_function (^^foo));\n+static_assert (!is_conversion_function (^^S::operator+));\n+static_assert (!is_conversion_function (^^operator&&));\n+static_assert (!is_conversion_function (^^operator||));\n+static_assert (!is_conversion_function (^^operator||<int>));\n+static_assert (!is_conversion_function (^^S::operator-));\n+static_assert (!is_conversion_function (^^S::operator-<int>));\n+static_assert (is_conversion_function (^^S::operator int));\n+static_assert (!is_conversion_function (conversion_template));\n+static_assert (!is_conversion_function (^^S::fn));\n+static_assert (!is_conversion_function (^^operator\"\"_a));\n+static_assert (!is_conversion_function (^^operator\"\"_b));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_conversion_function_template1.C b/gcc/testsuite/g++.dg/reflect/is_conversion_function_template1.C\nnew file mode 100644\nindex 00000000000..fa0daa151cc\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_conversion_function_template1.C\n@@ -0,0 +1,54 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_conversion_function_template.\n+\n+#include <meta>\n+#include <ranges>\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 <typename T>\n+ S &operator-(const S&);\n+\n+ operator int();\n+\n+ void fn();\n+};\n+\n+struct T {\n+ template <typename T>\n+ operator T ();\n+};\n+\n+bool operator&&(const S&, const S&);\n+\n+template <typename T>\n+bool operator||(const S&, const T&);\n+\n+int operator\"\"_a(const char *);\n+\n+template<char...>\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_conversion_function_template (null_reflection));\n+static_assert (!is_conversion_function_template (^^int));\n+static_assert (!is_conversion_function_template (^^::));\n+static_assert (!is_conversion_function_template (^^foo));\n+static_assert (!is_conversion_function_template (^^S::operator+));\n+static_assert (!is_conversion_function_template (^^operator&&));\n+static_assert (!is_conversion_function_template (^^operator||));\n+static_assert (!is_conversion_function_template (^^S::operator-));\n+static_assert (!is_conversion_function_template (^^S::operator int));\n+static_assert (is_conversion_function_template (conversion_template));\n+static_assert (!is_conversion_function_template (^^S::fn));\n+static_assert (!is_conversion_function_template (^^operator\"\"_a));\n+static_assert (!is_conversion_function_template (^^operator\"\"_b));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_copy_assignment1.C b/gcc/testsuite/g++.dg/reflect/is_copy_assignment1.C\nnew file mode 100644\nindex 00000000000..761ec410372\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_copy_assignment1.C\n@@ -0,0 +1,101 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_copy_assignment.\n+\n+#include <meta>\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_copy_assignment (parent_of (^^a)));\n+ }\n+ S (int)\n+ {\n+ int a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ }\n+ S (const S &)\n+ {\n+ int a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ }\n+ S (S &&)\n+ {\n+ int a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ }\n+ S &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (is_copy_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+ S &operator += (const S &)\n+ {\n+ int a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+ void bar ()\n+ {\n+ int a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ }\n+ ~S ()\n+ {\n+ int a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ }\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &)\n+ {\n+ int a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct U {\n+ template <typename T>\n+ U (T &)\n+ {\n+ T a;\n+ static_assert (!is_copy_assignment (parent_of (^^a)));\n+ }\n+ U &operator = (U &&)\n+ {\n+ int a;\n+ static_assert (!is_copy_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_copy_assignment (parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (!is_copy_assignment (null_reflection));\n+static_assert (!is_copy_assignment (^^int));\n+static_assert (!is_copy_assignment (^^::));\n+static_assert (!is_copy_assignment (^^foo));\n+static_assert (!is_copy_assignment (^^S::bar));\n+static_assert (is_copy_assignment (^^S::operator =));\n+static_assert (!is_copy_assignment (^^S::operator +=));\n+static_assert (!is_copy_assignment (^^T::operator *=));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_copy_constructor1.C b/gcc/testsuite/g++.dg/reflect/is_copy_constructor1.C\nnew file mode 100644\nindex 00000000000..1e90f0e0f0b\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_copy_constructor1.C\n@@ -0,0 +1,101 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_copy_constructor.\n+\n+#include <meta>\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_copy_constructor (parent_of (^^a)));\n+ }\n+ S (int)\n+ {\n+ int a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ }\n+ S (const S &)\n+ {\n+ int a;\n+ static_assert (is_copy_constructor (parent_of (^^a)));\n+ }\n+ S (S &&)\n+ {\n+ int a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ }\n+ S &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ S &operator += (const S &)\n+ {\n+ int a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ void bar ()\n+ {\n+ int a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ }\n+ ~S ()\n+ {\n+ int a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ }\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &)\n+ {\n+ int a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct U {\n+ template <typename T>\n+ U (T &)\n+ {\n+ T a;\n+ static_assert (!is_copy_constructor (parent_of (^^a)));\n+ }\n+ U &operator = (U &&)\n+ {\n+ int a;\n+ static_assert (!is_copy_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_copy_constructor (parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (!is_copy_constructor (null_reflection));\n+static_assert (!is_copy_constructor (^^int));\n+static_assert (!is_copy_constructor (^^::));\n+static_assert (!is_copy_constructor (^^foo));\n+static_assert (!is_copy_constructor (^^S::bar));\n+static_assert (!is_copy_constructor (^^S::operator =));\n+static_assert (!is_copy_constructor (^^S::operator +=));\n+static_assert (!is_copy_constructor (^^T::operator *=));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_data_member_spec1.C b/gcc/testsuite/g++.dg/reflect/is_data_member_spec1.C\nnew file mode 100644\nindex 00000000000..60cc31cdc33\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_data_member_spec1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_data_member_spec.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_data_member_spec (null_reflection));\n+static_assert (!is_data_member_spec (^^::));\n+static_assert (!is_data_member_spec (^^ns));\n+static_assert (!is_data_member_spec (^^ns_alias));\n+static_assert (!is_data_member_spec (reflect_constant (3)));\n+static_assert (!is_data_member_spec (^^cls));\n+static_assert (!is_data_member_spec (^^cls::dm));\n+static_assert (!is_data_member_spec (^^cls::ref_dm));\n+static_assert (!is_data_member_spec (^^cls::static_dm));\n+static_assert (!is_data_member_spec (^^cls::mem_fun));\n+static_assert (!is_data_member_spec (^^cls::static_mem_fun));\n+static_assert (!is_data_member_spec (^^cls::type));\n+static_assert (!is_data_member_spec (^^cls_var));\n+static_assert (!is_data_member_spec (^^onion));\n+static_assert (!is_data_member_spec (^^anon));\n+static_assert (!is_data_member_spec (^^fun));\n+static_assert (!is_data_member_spec (^^alias));\n+static_assert (!is_data_member_spec (^^var));\n+static_assert (!is_data_member_spec (^^ref));\n+static_assert (!is_data_member_spec (^^rref));\n+static_assert (!is_data_member_spec (^^ptr));\n+static_assert (!is_data_member_spec (^^cls_tmpl));\n+static_assert (!is_data_member_spec (^^cls_tmpl<int>));\n+static_assert (!is_data_member_spec (^^incomplete_cls<int>));\n+static_assert (!is_data_member_spec (^^fun_tmpl));\n+static_assert (!is_data_member_spec (^^fun_tmpl<int>));\n+static_assert (!is_data_member_spec (^^conc));\n+static_assert (!is_data_member_spec (substitute (^^conc, { ^^int })));\n+static_assert (!is_data_member_spec (^^var_tmpl));\n+static_assert (!is_data_member_spec (^^var_tmpl<int>));\n+static_assert (!is_data_member_spec (^^cls_tmpl_alias));\n+static_assert (!is_data_member_spec (^^cls_tmpl_alias<int>));\n+static_assert (!is_data_member_spec (^^Enum));\n+static_assert (!is_data_member_spec (^^Enum::A));\n+static_assert (!is_data_member_spec (^^Enum_class));\n+static_assert (!is_data_member_spec (^^Enum_class::A));\n+static_assert (!is_data_member_spec (^^decomp));\n+static_assert (!is_data_member_spec (^^decomp_ref));\n+static_assert (!is_data_member_spec (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (is_data_member_spec (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_data_member_spec (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!is_data_member_spec (^^T));\n+ static_assert (!is_data_member_spec (R));\n+ static_assert (!is_data_member_spec (R2));\n+ static_assert (!is_data_member_spec (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^ns, ^^cls>();\n+ static_assert (!is_data_member_spec (^^p));\n+ static_assert (!is_data_member_spec (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_default_constructor1.C b/gcc/testsuite/g++.dg/reflect/is_default_constructor1.C\nnew file mode 100644\nindex 00000000000..72e376ec6fe\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_default_constructor1.C\n@@ -0,0 +1,101 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_default_constructor.\n+\n+#include <meta>\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_default_constructor (parent_of (^^a)));\n+ }\n+ S (int)\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ }\n+ S (const S &)\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ }\n+ S (S &&)\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ }\n+ S &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ S &operator += (const S &)\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ void bar ()\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ }\n+ ~S ()\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ }\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &)\n+ {\n+ int a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct U {\n+ template <typename T>\n+ U (T &)\n+ {\n+ T a;\n+ static_assert (!is_default_constructor (parent_of (^^a)));\n+ }\n+ U &operator = (U &&)\n+ {\n+ int a;\n+ static_assert (!is_default_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_default_constructor (parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (!is_default_constructor (null_reflection));\n+static_assert (!is_default_constructor (^^int));\n+static_assert (!is_default_constructor (^^::));\n+static_assert (!is_default_constructor (^^foo));\n+static_assert (!is_default_constructor (^^S::bar));\n+static_assert (!is_default_constructor (^^S::operator =));\n+static_assert (!is_default_constructor (^^S::operator +=));\n+static_assert (!is_default_constructor (^^T::operator *=));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_defaulted1.C b/gcc/testsuite/g++.dg/reflect/is_defaulted1.C\nnew file mode 100644\nindex 00000000000..5ce5ee182d4\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_defaulted1.C\n@@ -0,0 +1,169 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_defaulted.\n+\n+#include <meta>\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 <int N>\n+ void foo ();\n+ template <int N>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_defaulted (null_reflection));\n+static_assert (!is_defaulted (^^::));\n+static_assert (!is_defaulted (^^ns));\n+static_assert (!is_defaulted (^^ns_alias));\n+static_assert (!is_defaulted (reflect_constant (3)));\n+static_assert (!is_defaulted (^^cls));\n+static_assert (!is_defaulted (^^cls::dm));\n+static_assert (!is_defaulted (^^cls::ref_dm));\n+static_assert (!is_defaulted (^^cls::static_dm));\n+static_assert (!is_defaulted (^^cls::mem_fun));\n+static_assert (!is_defaulted (^^cls::static_mem_fun));\n+static_assert (!is_defaulted (^^cls::type));\n+static_assert (!is_defaulted (^^cls::E));\n+static_assert (!is_defaulted (^^cls::B));\n+static_assert (!is_defaulted (^^cls::C));\n+static_assert (!is_defaulted (^^cls::D));\n+static_assert (!is_defaulted (^^cls::F));\n+static_assert (!is_defaulted (^^cls::F::G));\n+static_assert (!is_defaulted (^^cls::F::H));\n+static_assert (!is_defaulted (^^cls::S));\n+static_assert (!is_defaulted (^^cls::U));\n+static_assert (!is_defaulted (^^cls::foo));\n+static_assert (!is_defaulted (^^cls::foo <0>));\n+static_assert (!is_defaulted (^^cls::bar));\n+static_assert (!is_defaulted (^^cls::bar <42>));\n+static_assert (!is_defaulted (^^cls_var));\n+static_assert (!is_defaulted (^^onion));\n+static_assert (!is_defaulted (^^anon));\n+static_assert (!is_defaulted (^^fun));\n+static_assert (!is_defaulted (^^alias));\n+static_assert (!is_defaulted (^^var));\n+static_assert (!is_defaulted (^^ref));\n+static_assert (!is_defaulted (^^rref));\n+static_assert (!is_defaulted (^^ptr));\n+static_assert (!is_defaulted (^^cls_tmpl));\n+static_assert (!is_defaulted (^^cls_tmpl<int>));\n+static_assert (!is_defaulted (^^incomplete_cls<int>));\n+static_assert (!is_defaulted (^^fun_tmpl));\n+static_assert (!is_defaulted (^^fun_tmpl<int>));\n+static_assert (!is_defaulted (^^conc));\n+static_assert (!is_defaulted (substitute (^^conc, { ^^int })));\n+static_assert (!is_defaulted (^^var_tmpl));\n+static_assert (!is_defaulted (^^var_tmpl<int>));\n+static_assert (!is_defaulted (^^cls_tmpl_alias));\n+static_assert (!is_defaulted (^^cls_tmpl_alias<int>));\n+static_assert (!is_defaulted (^^Enum));\n+static_assert (!is_defaulted (^^Enum::A));\n+static_assert (!is_defaulted (^^Enum_class));\n+static_assert (!is_defaulted (^^Enum_class::A));\n+static_assert (!is_defaulted (^^decomp));\n+static_assert (!is_defaulted (^^decomp_ref));\n+static_assert (!is_defaulted (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_defaulted (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_defaulted (bases_of (^^Derived, access_context::current ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_defaulted (^^x));\n+ static_assert (!is_defaulted (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_defaulted (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_defaulted (^^S));\n+ static_assert (!is_defaulted (^^E));\n+ static_assert (!is_defaulted (^^F));\n+ static_assert (!is_defaulted (^^G));\n+}\n+\n+void bar (int, long) = delete;\n+void baz (int) = delete (\"foobar\");\n+static_assert (!is_defaulted (^^bar));\n+static_assert (!is_defaulted (^^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 <int N>\n+ void bar ();\n+};\n+\n+struct V\n+{\n+ V (const V &);\n+};\n+\n+static_assert (is_defaulted (^^S::operator <=>));\n+static_assert (is_defaulted (^^S::operator <=>));\n+static_assert (is_defaulted (^^S::operator =));\n+static_assert (!is_defaulted (^^S::foo));\n+static_assert (!is_defaulted (^^S::bar));\n+static_assert (!is_defaulted (^^S::bar <42>));\n+static_assert (is_defaulted (^^V::operator =));\n+\n+struct W\n+{\n+ ~W () = default;\n+ int w;\n+};\n+static_assert (is_defaulted (^^W::~W));\n+\n+struct X\n+{\n+ int x;\n+};\n+static_assert (is_defaulted (^^X::~X));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_defaulted2.C b/gcc/testsuite/g++.dg/reflect/is_defaulted2.C\nnew file mode 100644\nindex 00000000000..7aa45e73c67\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_defaulted2.C\n@@ -0,0 +1,64 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_deleted.\n+\n+#include <meta>\n+#include <vector>\n+\n+using namespace std::meta;\n+\n+template<typename F>\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_defaulted (select_mem (^^ExplicitDef, is_default_constructor)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_copy_constructor)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_move_constructor)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_copy_assignment)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_move_assignment)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_destructor)));\n+\n+struct ImplicitDef\n+{\n+};\n+\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_default_constructor)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_copy_constructor)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_move_constructor)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_copy_assignment)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_move_assignment)));\n+static_assert (is_defaulted (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_defaulted (^^ExplicitRelOps::operator==));\n+static_assert (is_defaulted (^^ExplicitRelOps::operator<=>));\n+\n+struct ImplicitRelOps\n+{\n+ // operator== is implicitly declared\n+ auto operator<=>(const ImplicitRelOps&) const = default;\n+};\n+static_assert (is_defaulted (^^ImplicitRelOps::operator==));\n+static_assert (is_defaulted (^^ImplicitRelOps::operator<=>));\n+\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_deleted1.C b/gcc/testsuite/g++.dg/reflect/is_deleted1.C\nnew file mode 100644\nindex 00000000000..c75a043b77d\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_deleted1.C\n@@ -0,0 +1,154 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_deleted.\n+\n+#include <meta>\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 <int N>\n+ void foo ();\n+ template <int N>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_deleted (null_reflection));\n+static_assert (!is_deleted (^^::));\n+static_assert (!is_deleted (^^ns));\n+static_assert (!is_deleted (^^ns_alias));\n+static_assert (!is_deleted (reflect_constant (3)));\n+static_assert (!is_deleted (^^cls));\n+static_assert (!is_deleted (^^cls::dm));\n+static_assert (!is_deleted (^^cls::ref_dm));\n+static_assert (!is_deleted (^^cls::static_dm));\n+static_assert (!is_deleted (^^cls::mem_fun));\n+static_assert (!is_deleted (^^cls::static_mem_fun));\n+static_assert (!is_deleted (^^cls::type));\n+static_assert (!is_deleted (^^cls::E));\n+static_assert (!is_deleted (^^cls::B));\n+static_assert (!is_deleted (^^cls::C));\n+static_assert (!is_deleted (^^cls::D));\n+static_assert (!is_deleted (^^cls::F));\n+static_assert (!is_deleted (^^cls::F::G));\n+static_assert (!is_deleted (^^cls::F::H));\n+static_assert (!is_deleted (^^cls::S));\n+static_assert (!is_deleted (^^cls::U));\n+static_assert (!is_deleted (^^cls::foo));\n+static_assert (!is_deleted (^^cls::foo <0>));\n+static_assert (!is_deleted (^^cls::bar));\n+static_assert (!is_deleted (^^cls::bar <42>));\n+static_assert (!is_deleted (^^cls_var));\n+static_assert (!is_deleted (^^onion));\n+static_assert (!is_deleted (^^anon));\n+static_assert (!is_deleted (^^fun));\n+static_assert (!is_deleted (^^alias));\n+static_assert (!is_deleted (^^var));\n+static_assert (!is_deleted (^^ref));\n+static_assert (!is_deleted (^^rref));\n+static_assert (!is_deleted (^^ptr));\n+static_assert (!is_deleted (^^cls_tmpl));\n+static_assert (!is_deleted (^^cls_tmpl<int>));\n+static_assert (!is_deleted (^^incomplete_cls<int>));\n+static_assert (!is_deleted (^^fun_tmpl));\n+static_assert (!is_deleted (^^fun_tmpl<int>));\n+static_assert (!is_deleted (^^conc));\n+static_assert (!is_deleted (substitute (^^conc, { ^^int })));\n+static_assert (!is_deleted (^^var_tmpl));\n+static_assert (!is_deleted (^^var_tmpl<int>));\n+static_assert (!is_deleted (^^cls_tmpl_alias));\n+static_assert (!is_deleted (^^cls_tmpl_alias<int>));\n+static_assert (!is_deleted (^^Enum));\n+static_assert (!is_deleted (^^Enum::A));\n+static_assert (!is_deleted (^^Enum_class));\n+static_assert (!is_deleted (^^Enum_class::A));\n+static_assert (!is_deleted (^^decomp));\n+static_assert (!is_deleted (^^decomp_ref));\n+static_assert (!is_deleted (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = u8\"dms\" });\n+static_assert (!is_deleted (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_deleted (bases_of (^^Derived, access_context::unprivileged ())[0]));\n+\n+void\n+foo (int x)\n+{\n+ static_assert (!is_deleted (^^x));\n+ static_assert (!is_deleted (parameters_of (^^foo)[0]));\n+ int v;\n+ static_assert (!is_deleted (^^v));\n+ struct S {};\n+ enum E { F, G };\n+ static_assert (!is_deleted (^^S));\n+ static_assert (!is_deleted (^^E));\n+ static_assert (!is_deleted (^^F));\n+ static_assert (!is_deleted (^^G));\n+}\n+\n+void bar (int, long) = delete;\n+void baz (int) = delete (\"foobar\");\n+static_assert (is_deleted (^^bar));\n+static_assert (is_deleted (^^baz));\n+\n+struct S\n+{\n+ S (const int &x) : s (x) {}\n+ auto operator <=> (const S &) const = default;\n+ const int &s;\n+ void foo () = delete;\n+ template <int N>\n+ void bar () = delete;\n+};\n+S s1 = 42;\n+S s2 = 43;\n+auto s3 = s1 <=> s2; // { dg-error \"use of deleted function\" }\n+static_assert (is_deleted (^^S::operator <=>));\n+static_assert (is_deleted (^^S::foo));\n+static_assert (!is_deleted (^^S::bar));\n+\n+struct W\n+{\n+ ~W () = delete;\n+};\n+static_assert (is_deleted (^^W::~W));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_deleted2.C b/gcc/testsuite/g++.dg/reflect/is_deleted2.C\nnew file mode 100644\nindex 00000000000..acba2d8ee3f\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_deleted2.C\n@@ -0,0 +1,90 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_deleted.\n+\n+#include <meta>\n+#include <vector>\n+\n+using namespace std::meta;\n+\n+struct Del {\n+ Del() = delete;\n+ Del(Del&&) = delete;\n+ ~Del() = delete;\n+};\n+\n+template<typename F>\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+ Del d;\n+};\n+\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_default_constructor)));\n+static_assert (is_deleted (select_mem (^^ExplicitDef, is_default_constructor)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_copy_constructor)));\n+static_assert (is_deleted (select_mem (^^ExplicitDef, is_copy_constructor)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_move_constructor)));\n+static_assert (is_deleted (select_mem (^^ExplicitDef, is_move_constructor)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_copy_assignment)));\n+static_assert (is_deleted (select_mem (^^ExplicitDef, is_copy_assignment)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_move_assignment)));\n+static_assert (is_deleted (select_mem (^^ExplicitDef, is_move_assignment)));\n+static_assert (is_defaulted (select_mem (^^ExplicitDef, is_destructor)));\n+static_assert (is_deleted (select_mem (^^ExplicitDef, is_destructor)));\n+\n+struct ImplicitDef\n+{\n+ Del d;\n+};\n+\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_default_constructor)));\n+static_assert (is_deleted (select_mem (^^ImplicitDef, is_default_constructor)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_copy_constructor)));\n+static_assert (is_deleted (select_mem (^^ImplicitDef, is_copy_constructor)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_move_constructor)));\n+static_assert (is_deleted (select_mem (^^ImplicitDef, is_move_constructor)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_copy_assignment)));\n+static_assert (is_deleted (select_mem (^^ImplicitDef, is_copy_assignment)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_move_assignment)));\n+static_assert (is_deleted (select_mem (^^ImplicitDef, is_move_assignment)));\n+static_assert (is_defaulted (select_mem (^^ImplicitDef, is_destructor)));\n+static_assert (is_deleted (select_mem (^^ImplicitDef, is_destructor)));\n+\n+template<typename T>\n+concept check_rel_ops = requires(T t) {\n+ t <=> t;\n+ t == t;\n+};\n+\n+struct RelOpsDel\n+{\n+ int& x;\n+\n+ // deleted because of reference member\n+ auto operator<=>(const RelOpsDel&) const = default;\n+};\n+static_assert (is_deleted (^^RelOpsDel::operator<=>));\n+static_assert (!check_rel_ops<RelOpsDel>);\n+\n+static_assert (is_defaulted (^^RelOpsDel::operator==));\n+// FIXME still fails even after forcing an use\n+// static_assert (is_deleted (^^RelOpsDel::operator==));\n+static_assert (is_defaulted (^^RelOpsDel::operator<=>));\n+static_assert (is_deleted (^^RelOpsDel::operator<=>));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_destructor1.C b/gcc/testsuite/g++.dg/reflect/is_destructor1.C\nnew file mode 100644\nindex 00000000000..f431b5c971d\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_destructor1.C\n@@ -0,0 +1,124 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_destructor.\n+\n+#include <meta>\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_destructor (parent_of (^^a)));\n+ }\n+ S (int)\n+ {\n+ int a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ }\n+ S (const S &)\n+ {\n+ int a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ }\n+ S (S &&)\n+ {\n+ int a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ }\n+ S &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ S &operator += (const S &)\n+ {\n+ int a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ void bar ()\n+ {\n+ int a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ }\n+ ~S ()\n+ {\n+ int a;\n+ static_assert (is_destructor (parent_of (^^a)));\n+ }\n+};\n+\n+struct T {\n+ T &operator = (const S &)\n+ {\n+ int a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ return *this;\n+ }\n+ T &operator *= (const S &)\n+ {\n+ int a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ return *this;\n+ }\n+};\n+\n+struct U {\n+ template <typename T>\n+ U (T &)\n+ {\n+ T a;\n+ static_assert (!is_destructor (parent_of (^^a)));\n+ }\n+ U &operator = (U &&)\n+ {\n+ int a;\n+ static_assert (!is_destructor (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_destructor (parent_of (^^a)));\n+ }\n+};\n+\n+static_assert (!is_destructor (null_reflection));\n+static_assert (!is_destructor (^^int));\n+static_assert (!is_destructor (^^::));\n+static_assert (!is_destructor (^^foo));\n+static_assert (!is_destructor (^^S::bar));\n+static_assert (!is_destructor (^^S::operator =));\n+static_assert (!is_destructor (^^S::operator +=));\n+static_assert (!is_destructor (^^T::operator *=));\n+\n+struct W {};\n+static_assert (is_destructor (^^W::~W));\n+\n+struct X \n+{\n+ ~X () = default;\n+};\n+static_assert (is_destructor (^^X::~X));\n+\n+struct Y\n+{\n+ ~Y () = delete;\n+};\n+static_assert (is_destructor (^^Y::~Y));\n+\n+struct Z\n+{\n+ ~Z () {}\n+};\n+static_assert (is_destructor (^^Z::~Z));\n+\n+\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_enumerable_type1.C b/gcc/testsuite/g++.dg/reflect/is_enumerable_type1.C\nnew file mode 100644\nindex 00000000000..4af92bceb5f\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_enumerable_type1.C\n@@ -0,0 +1,106 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_enumerable_type.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\n+void foo ();\n+\n+static_assert (!is_enumerable_type (null_reflection));\n+static_assert (!is_enumerable_type (^^int));\n+static_assert (!is_enumerable_type (^^::));\n+static_assert (!is_enumerable_type (^^foo));\n+\n+class S;\n+enum class E;\n+typedef E TE;\n+static_assert (!is_enumerable_type (^^S));\n+static_assert (!is_enumerable_type (^^E));\n+static_assert (!is_enumerable_type (^^TE));\n+\n+template<typename> struct cls_tmpl {};\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+static_assert (!is_enumerable_type (^^cls_tmpl));\n+static_assert (is_enumerable_type (^^cls_tmpl<int>));\n+static_assert (!is_enumerable_type (^^cls_tmpl_alias));\n+static_assert (is_enumerable_type (^^cls_tmpl_alias<int>));\n+\n+class S {\n+ void foo ()\n+ {\n+ static_assert (is_enumerable_type (^^S));\n+ }\n+ static_assert (!is_enumerable_type (^^S));\n+};\n+static_assert (is_enumerable_type (^^S));\n+\n+enum class E {\n+ A = (is_enumerable_type (^^E) || is_enumerable_type (^^TE)) ? 1 : 2\n+};\n+static_assert (is_enumerable_type (^^E));\n+static_assert (static_cast <int> (E::A) == 2);\n+static_assert (is_enumerable_type (^^TE));\n+\n+enum F : int;\n+using TF = F;\n+static_assert (!is_enumerable_type (^^F));\n+static_assert (!is_enumerable_type (^^TF));\n+enum F : int {\n+ B = (is_enumerable_type (^^F) || is_enumerable_type (^^TF)) ? 3 : 4\n+};\n+static_assert (is_enumerable_type (^^F));\n+static_assert (B == 4);\n+static_assert (is_enumerable_type (^^TF));\n+\n+enum G {\n+ C = is_enumerable_type (^^G) ? 5 : 6\n+};\n+static_assert (is_enumerable_type (^^G));\n+static_assert (C == 6);\n+\n+enum H : int;\n+typedef H TH;\n+static_assert (!is_enumerable_type (^^H));\n+static_assert (!is_enumerable_type (^^TH));\n+\n+enum H : int {};\n+static_assert (is_enumerable_type (^^H));\n+static_assert (is_enumerable_type (^^TH));\n+\n+enum I : short;\n+using TI = I;\n+static_assert (!is_enumerable_type (^^I));\n+static_assert (!is_enumerable_type (^^TI));\n+enum I : short {};\n+static_assert (is_enumerable_type (^^I));\n+static_assert (is_enumerable_type (^^TI));\n+\n+template <typename T>\n+void\n+qux ()\n+{\n+ enum J : T;\n+ using K = J;\n+ // FIXME: No idea if this is supposed to be false or true.\n+ // We certainly during instantiation don't differentiate between\n+ // forward enum declarations and later definitions.\n+ // static_assert (!is_enumerable_type (^^J));\n+ // static_assert (!is_enumerable_type (^^K));\n+ enum J : T {\n+ D = (is_enumerable_type (^^J) || is_enumerable_type (^^K))\n+\t? sizeof (T) * 2 : sizeof (T)\n+ };\n+ static_assert (is_enumerable_type (^^J));\n+ static_assert (D == sizeof (T));\n+ static_assert (is_enumerable_type (^^K));\n+}\n+\n+void\n+corge ()\n+{\n+ qux <int> ();\n+ qux <unsigned char> ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_enumerator1.C b/gcc/testsuite/g++.dg/reflect/is_enumerator1.C\nnew file mode 100644\nindex 00000000000..538e2e465b8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_enumerator1.C\n@@ -0,0 +1,107 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_enumerator.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_enumerator (null_reflection));\n+static_assert (!is_enumerator (^^::));\n+static_assert (!is_enumerator (^^ns));\n+static_assert (!is_enumerator (^^ns_alias));\n+static_assert (!is_enumerator (reflect_constant (3)));\n+static_assert (!is_enumerator (^^cls));\n+static_assert (!is_enumerator (^^cls::dm));\n+static_assert (!is_enumerator (^^cls::ref_dm));\n+static_assert (!is_enumerator (^^cls::static_dm));\n+static_assert (!is_enumerator (^^cls::mem_fun));\n+static_assert (!is_enumerator (^^cls::static_mem_fun));\n+static_assert (!is_enumerator (^^cls::type));\n+static_assert (!is_enumerator (^^cls_var));\n+static_assert (!is_enumerator (^^onion));\n+static_assert (!is_enumerator (^^anon));\n+static_assert (!is_enumerator (^^fun));\n+static_assert (!is_enumerator (^^alias));\n+static_assert (!is_enumerator (^^var));\n+static_assert (!is_enumerator (^^ref));\n+static_assert (!is_enumerator (^^rref));\n+static_assert (!is_enumerator (^^ptr));\n+static_assert (!is_enumerator (^^cls_tmpl));\n+static_assert (!is_enumerator (^^cls_tmpl<int>));\n+static_assert (!is_enumerator (^^incomplete_cls<int>));\n+static_assert (!is_enumerator (^^fun_tmpl));\n+static_assert (!is_enumerator (^^fun_tmpl<int>));\n+static_assert (!is_enumerator (^^conc));\n+static_assert (!is_enumerator (substitute (^^conc, { ^^int })));\n+static_assert (!is_enumerator (^^var_tmpl));\n+static_assert (!is_enumerator (^^var_tmpl<int>));\n+static_assert (!is_enumerator (^^cls_tmpl_alias));\n+static_assert (!is_enumerator (^^cls_tmpl_alias<int>));\n+static_assert (!is_enumerator (^^Enum));\n+static_assert (is_enumerator (^^Enum::A));\n+static_assert (!is_enumerator (^^Enum_class));\n+static_assert (is_enumerator (^^Enum_class::A));\n+static_assert (!is_enumerator (^^decomp));\n+static_assert (!is_enumerator (^^decomp_ref));\n+static_assert (!is_enumerator (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_enumerator (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_enumerator (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!is_enumerator (^^T));\n+ static_assert (!is_enumerator (R));\n+ static_assert (is_enumerator (R2));\n+ static_assert (is_enumerator (R3));\n+}\n+\n+void\n+g (int p, cls c, Enum e, Enum_class ec)\n+{\n+ f<int, ^^var, ^^Enum::A, ^^Enum_class::A>();\n+ static_assert (!is_enumerator (^^p));\n+ static_assert (!is_enumerator (^^c));\n+ static_assert (!is_enumerator (^^e));\n+ static_assert (!is_enumerator (^^ec));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_explicit1.C b/gcc/testsuite/g++.dg/reflect/is_explicit1.C\nnew file mode 100644\nindex 00000000000..3afcc5b0b3e\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_explicit1.C\n@@ -0,0 +1,72 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_explicit.\n+\n+#include <meta>\n+\n+class Test {\n+public:\n+ explicit Test(int) \n+ {\n+ int a;\n+ static_assert (std::meta::is_explicit (std::meta::parent_of (^^a)));\n+ }\n+\n+ Test(double) \n+ {\n+ int a;\n+ static_assert (!std::meta::is_explicit (std::meta::parent_of (^^a)));\n+ }\n+\n+ explicit operator bool();\n+\n+ operator int();\n+\n+ template<typename T>\n+ explicit operator double();\n+ \n+ void member_function();\n+\n+ virtual void virtual_function();\n+\n+ template <typename T>\n+ void template_function(T param);\n+};\n+\n+void function();\n+\n+static_assert (std::meta::is_explicit (^^Test::Test)); // { dg-error \"cannot take the reflection of an overload set\" }\n+static_assert (!std::meta::is_explicit (^^Test::~Test));\n+\n+static_assert (std::meta::is_explicit (^^Test::operator bool));\n+static_assert (!std::meta::is_explicit (^^Test::operator int));\n+static_assert (!std::meta::is_explicit (^^Test::operator double));\n+\n+static_assert (!std::meta::is_explicit (^^Test::member_function));\n+static_assert (!std::meta::is_explicit (^^Test::virtual_function));\n+static_assert (!std::meta::is_explicit (^^Test::template_function));\n+static_assert (!std::meta::is_explicit (^^Test::template_function<int>));\n+\n+static_assert (!std::meta::is_explicit (^^function));\n+static_assert (!std::meta::is_explicit (^^Test));\n+static_assert (!std::meta::is_explicit (^^::));\n+\n+class Base {\n+public:\n+ explicit operator int();\n+};\n+\n+class Derived : public Base {\n+public:\n+ explicit operator double();\n+\n+ operator bool();\n+};\n+\n+static_assert (std::meta::is_explicit (^^Derived::operator int));\n+static_assert (std::meta::is_explicit (^^Derived::operator double));\n+static_assert (!std::meta::is_explicit (^^Derived::operator bool));\n+\n+class EmptyClass {};\n+static_assert (!std::meta::is_explicit (^^EmptyClass::EmptyClass)); // { dg-error \"cannot take the reflection of an overload set\" }\n+\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_explicit2.C b/gcc/testsuite/g++.dg/reflect/is_explicit2.C\nnew file mode 100644\nindex 00000000000..97f8297d394\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_explicit2.C\n@@ -0,0 +1,47 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_explicit.\n+\n+#include <meta>\n+using namespace std::meta;\n+\n+template<typename Fn>\n+consteval info select(info clazz, Fn f)\n+{\n+ for (auto x : members_of(clazz, access_context::unchecked()))\n+ if (f(x))\n+ return x;\n+}\n+\n+struct Implicit {\n+ template<typename T>\n+ Implicit(T&& t);\n+\n+ template<typename T>\n+ operator T();\n+};\n+\n+static_assert (!is_explicit (select(^^Implicit, is_constructor_template)));\n+static_assert (!is_explicit (select(^^Implicit, is_conversion_function_template)));\n+\n+struct Explicit {\n+ template<typename T>\n+ explicit Explicit(T&& t);\n+\n+ template<typename T>\n+ explicit operator T();\n+};\n+\n+static_assert (!is_explicit (select(^^Explicit, is_constructor_template)));\n+static_assert (!is_explicit (select(^^Explicit, is_conversion_function_template)));\n+\n+struct CondExplicit {\n+ template<typename T>\n+ explicit(sizeof(T) > 4) CondExplicit(T&& t);\n+\n+ template<typename T>\n+ explicit(sizeof(T) > 4) operator T();\n+};\n+\n+static_assert (!is_explicit (select(^^CondExplicit, is_constructor_template)));\n+static_assert (!is_explicit (select(^^CondExplicit, is_conversion_function_template)));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_explicit_object_parameter1.C b/gcc/testsuite/g++.dg/reflect/is_explicit_object_parameter1.C\nnew file mode 100644\nindex 00000000000..38e7e075e3d\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_explicit_object_parameter1.C\n@@ -0,0 +1,165 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_explicit_object_parameter.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_explicit_object_parameter (null_reflection));\n+static_assert (!is_explicit_object_parameter (^^::));\n+static_assert (!is_explicit_object_parameter (^^ns));\n+static_assert (!is_explicit_object_parameter (^^ns_alias));\n+static_assert (!is_explicit_object_parameter (reflect_constant (3)));\n+static_assert (!is_explicit_object_parameter (^^cls));\n+static_assert (!is_explicit_object_parameter (^^cls::dm));\n+static_assert (!is_explicit_object_parameter (^^cls::ref_dm));\n+static_assert (!is_explicit_object_parameter (^^cls::static_dm));\n+static_assert (!is_explicit_object_parameter (^^cls::mem_fun));\n+static_assert (!is_explicit_object_parameter (^^cls::static_mem_fun));\n+static_assert (!is_explicit_object_parameter (^^cls::type));\n+static_assert (!is_explicit_object_parameter (^^cls_var));\n+static_assert (!is_explicit_object_parameter (^^onion));\n+static_assert (!is_explicit_object_parameter (^^anon));\n+static_assert (!is_explicit_object_parameter (^^fun));\n+static_assert (!is_explicit_object_parameter (^^alias));\n+static_assert (!is_explicit_object_parameter (^^var));\n+static_assert (!is_explicit_object_parameter (^^ref));\n+static_assert (!is_explicit_object_parameter (^^rref));\n+static_assert (!is_explicit_object_parameter (^^ptr));\n+static_assert (!is_explicit_object_parameter (^^cls_tmpl));\n+static_assert (!is_explicit_object_parameter (^^cls_tmpl<int>));\n+static_assert (!is_explicit_object_parameter (^^incomplete_cls<int>));\n+static_assert (!is_explicit_object_parameter (^^fun_tmpl));\n+static_assert (!is_explicit_object_parameter (^^fun_tmpl<int>));\n+static_assert (!is_explicit_object_parameter (^^conc));\n+static_assert (!is_explicit_object_parameter (substitute (^^conc, { ^^int })));\n+static_assert (!is_explicit_object_parameter (^^var_tmpl));\n+static_assert (!is_explicit_object_parameter (^^var_tmpl<int>));\n+static_assert (!is_explicit_object_parameter (^^cls_tmpl_alias));\n+static_assert (!is_explicit_object_parameter (^^cls_tmpl_alias<int>));\n+static_assert (!is_explicit_object_parameter (^^Enum));\n+static_assert (!is_explicit_object_parameter (^^Enum::A));\n+static_assert (!is_explicit_object_parameter (^^Enum_class));\n+static_assert (!is_explicit_object_parameter (^^Enum_class::A));\n+static_assert (!is_explicit_object_parameter (^^decomp));\n+static_assert (!is_explicit_object_parameter (^^decomp_ref));\n+static_assert (!is_explicit_object_parameter (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_explicit_object_parameter (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_explicit_object_parameter (bases_of (^^Derived, access_context::unchecked ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!is_explicit_object_parameter (^^T));\n+ static_assert (!is_explicit_object_parameter (R));\n+ static_assert (!is_explicit_object_parameter (R2));\n+ static_assert (!is_explicit_object_parameter (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^p, ^^c> ();\n+ static_assert (!is_explicit_object_parameter (^^p));\n+ static_assert (!is_explicit_object_parameter (^^c));\n+}\n+\n+struct S {\n+ template<typename T, info R, info R2, info R3>\n+ static void\n+ f ()\n+ {\n+ static_assert (!is_explicit_object_parameter (^^T));\n+ static_assert (!is_explicit_object_parameter (R));\n+ static_assert (is_explicit_object_parameter (R2));\n+ static_assert (!is_explicit_object_parameter (R3));\n+ }\n+\n+ void\n+ g (this const S &a, int b)\n+ {\n+ f<int, ^^var, parameters_of (^^S::g)[0], parameters_of (^^S::g)[1]> ();\n+ static_assert (is_explicit_object_parameter (parameters_of (^^S::g)[0]));\n+ static_assert (!is_explicit_object_parameter (parameters_of (^^S::g)[1]));\n+ static_assert (!is_explicit_object_parameter (variable_of (parameters_of (^^S::g)[0])));\n+ static_assert (!is_explicit_object_parameter (variable_of (parameters_of (^^S::g)[1])));\n+ static_assert (!is_explicit_object_parameter (^^a));\n+ static_assert (!is_explicit_object_parameter (^^b));\n+ }\n+\n+ template<int N>\n+ void\n+ h (this S *a, long b)\n+ {\n+ static_assert (is_explicit_object_parameter (parameters_of (^^S::h <N>)[0]));\n+ static_assert (!is_explicit_object_parameter (parameters_of (^^S::h <N>)[0]));\n+ static_assert (!is_explicit_object_parameter (variable_of (parameters_of (^^S::h <N>)[0])));\n+ static_assert (!is_explicit_object_parameter (variable_of (parameters_of (^^S::h <N>)[0])));\n+ static_assert (!is_explicit_object_parameter (^^a));\n+ static_assert (!is_explicit_object_parameter (^^b));\n+ }\n+\n+ void\n+ i (const S &a, int b)\n+ {\n+ ::f<int, ^^var, parameters_of (^^S::i)[0], parameters_of (^^S::i)[1]> ();\n+ static_assert (!is_explicit_object_parameter (parameters_of (^^S::i)[0]));\n+ static_assert (!is_explicit_object_parameter (parameters_of (^^S::i)[1]));\n+ static_assert (!is_explicit_object_parameter (variable_of (parameters_of (^^S::i)[0])));\n+ static_assert (!is_explicit_object_parameter (variable_of (parameters_of (^^S::i)[1])));\n+ static_assert (!is_explicit_object_parameter (^^a));\n+ static_assert (!is_explicit_object_parameter (^^b));\n+ }\n+\n+ template<typename T>\n+ void\n+ j (const S *, int b)\n+ {\n+ ::f<int, ^^var, parameters_of (^^S::j <T>)[0], parameters_of (^^S::j <T>)[1]> ();\n+ static_assert (!is_explicit_object_parameter (parameters_of (^^S::j <T>)[0]));\n+ static_assert (!is_explicit_object_parameter (parameters_of (^^S::j <T>)[1]));\n+ static_assert (!is_explicit_object_parameter (variable_of (parameters_of (^^S::j <T>)[0])));\n+ static_assert (!is_explicit_object_parameter (variable_of (parameters_of (^^S::j <T>)[1])));\n+ static_assert (!is_explicit_object_parameter (^^b));\n+ }\n+};\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_final1.C b/gcc/testsuite/g++.dg/reflect/is_final1.C\nnew file mode 100644\nindex 00000000000..ed10c71b40c\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_final1.C\n@@ -0,0 +1,56 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_final.\n+\n+#include <meta>\n+\n+struct A {\n+ virtual void foo();\n+\n+ virtual void bar() final;\n+\n+ virtual ~A() = default;\n+};\n+\n+struct B final : A {\n+ void foo() override;\n+\n+ ~B() final = default;\n+};\n+\n+struct C : A {\n+ void foo() final;\n+};\n+\n+struct D final : A {\n+ static_assert (is_final (^^D));\n+};\n+\n+static_assert (!std::meta::is_final (^^A));\n+static_assert (std::meta::is_final (^^B));\n+static_assert (!std::meta::is_final (^^C));\n+\n+static_assert (!std::meta::is_final (^^A::foo));\n+static_assert (!std::meta::is_final (^^B::foo));\n+static_assert (std::meta::is_final (^^C::foo));\n+\n+static_assert (std::meta::is_final (^^A::bar));\n+static_assert (std::meta::is_final (^^B::bar));\n+static_assert (std::meta::is_final (^^C::bar));\n+\n+static_assert (!std::meta::is_final (^^A::~A));\n+static_assert (std::meta::is_final (^^B::~B));\n+static_assert (!std::meta::is_final (^^C::~C));\n+\n+A a;\n+B b;\n+C c;\n+\n+static_assert (!std::meta::is_final (^^::));\n+static_assert (!std::meta::is_final (^^a));\n+static_assert (!std::meta::is_final (^^b));\n+static_assert (!std::meta::is_final (^^c));\n+\n+static_assert (!std::meta::is_final (std::meta::type_of (^^a)));\n+static_assert (std::meta::is_final (std::meta::type_of (^^b)));\n+static_assert (!std::meta::is_final (std::meta::type_of (^^c)));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_function1.C b/gcc/testsuite/g++.dg/reflect/is_function1.C\nnew file mode 100644\nindex 00000000000..ff635b8097f\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_function1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_function.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_function (null_reflection));\n+static_assert (!is_function (^^::));\n+static_assert (!is_function (^^ns));\n+static_assert (!is_function (^^ns_alias));\n+static_assert (!is_function (reflect_constant (3)));\n+static_assert (!is_function (^^cls));\n+static_assert (!is_function (^^cls::dm));\n+static_assert (!is_function (^^cls::ref_dm));\n+static_assert (!is_function (^^cls::static_dm));\n+static_assert (is_function (^^cls::mem_fun));\n+static_assert (is_function (^^cls::static_mem_fun));\n+static_assert (!is_function (^^cls::type));\n+static_assert (!is_function (^^cls_var));\n+static_assert (!is_function (^^onion));\n+static_assert (!is_function (^^anon));\n+static_assert (is_function (^^fun));\n+static_assert (!is_function (^^alias));\n+static_assert (!is_function (^^var));\n+static_assert (!is_function (^^ref));\n+static_assert (!is_function (^^rref));\n+static_assert (!is_function (^^ptr));\n+static_assert (!is_function (^^cls_tmpl));\n+static_assert (!is_function (^^cls_tmpl<int>));\n+static_assert (!is_function (^^incomplete_cls<int>));\n+static_assert (!is_function (^^fun_tmpl));\n+static_assert (is_function (^^fun_tmpl<int>));\n+static_assert (!is_function (^^conc));\n+static_assert (!is_function (substitute (^^conc, { ^^int })));\n+static_assert (!is_function (^^var_tmpl));\n+static_assert (!is_function (^^var_tmpl<int>));\n+static_assert (!is_function (^^cls_tmpl_alias));\n+static_assert (!is_function (^^cls_tmpl_alias<int>));\n+static_assert (!is_function (^^Enum));\n+static_assert (!is_function (^^Enum::A));\n+static_assert (!is_function (^^Enum_class));\n+static_assert (!is_function (^^Enum_class::A));\n+static_assert (!is_function (^^decomp));\n+static_assert (!is_function (^^decomp_ref));\n+static_assert (!is_function (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_function (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_function (bases_of (^^Derived, access_context::unprivileged ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!is_function (^^T));\n+ static_assert (!is_function (R));\n+ static_assert (!is_function (R2));\n+ static_assert (is_function (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^ns, ^^fun>();\n+ static_assert (!is_function (^^p));\n+ static_assert (!is_function (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_function2.C b/gcc/testsuite/g++.dg/reflect/is_function2.C\nnew file mode 100644\nindex 00000000000..8bb0769a6ae\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_function2.C\n@@ -0,0 +1,44 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_function.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+struct S {\n+ template<typename T>\n+ void ovl (T) { }\n+\n+ template<typename T>\n+ void static_ovl (T) { }\n+};\n+\n+static_assert (!is_function (^^S::ovl));\n+static_assert (is_function (^^S::ovl<int>));\n+static_assert (!is_function (^^S::static_ovl));\n+static_assert (is_function (^^S::static_ovl<int>));\n+\n+static_assert (!is_function (^^void()));\n+\n+template<info R1, info R2>\n+void\n+f ()\n+{\n+ static_assert (!is_function (R1));\n+ static_assert (is_function (R2));\n+}\n+\n+template<typename T>\n+void\n+g ()\n+{\n+ f<^^S::ovl, ^^S::ovl<T>>();\n+ f<^^S::static_ovl, ^^S::static_ovl<T>>();\n+}\n+\n+void\n+h ()\n+{\n+ g<int>();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_function3.C b/gcc/testsuite/g++.dg/reflect/is_function3.C\nnew file mode 100644\nindex 00000000000..1613e1bf4a2\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_function3.C\n@@ -0,0 +1,15 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_function.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+struct S {\n+ S();\n+ ~S();\n+};\n+\n+static_assert (is_function (^^S::S)); // { dg-error \"cannot take the reflection of an overload set\" }\n+static_assert (is_function (^^S::~S));\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_function_parameter1.C b/gcc/testsuite/g++.dg/reflect/is_function_parameter1.C\nnew file mode 100644\nindex 00000000000..c5116c44b98\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_function_parameter1.C\n@@ -0,0 +1,105 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_function_parameter.\n+\n+#include <meta>\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<typename> struct incomplete_cls;\n+template<typename> struct cls_tmpl {};\n+template<typename> void fun_tmpl ();\n+template<typename> concept conc = requires { true; };\n+template<typename> int var_tmpl;\n+template<typename T> using cls_tmpl_alias = cls_tmpl<T>;\n+\n+int arr[] = { 42 };\n+auto [ decomp ] = arr;\n+auto &[ decomp_ref ] = arr;\n+\n+static_assert (!is_function_parameter (null_reflection));\n+static_assert (!is_function_parameter (^^::));\n+static_assert (!is_function_parameter (^^ns));\n+static_assert (!is_function_parameter (^^ns_alias));\n+static_assert (!is_function_parameter (reflect_constant (3)));\n+static_assert (!is_function_parameter (^^cls));\n+static_assert (!is_function_parameter (^^cls::dm));\n+static_assert (!is_function_parameter (^^cls::ref_dm));\n+static_assert (!is_function_parameter (^^cls::static_dm));\n+static_assert (!is_function_parameter (^^cls::mem_fun));\n+static_assert (!is_function_parameter (^^cls::static_mem_fun));\n+static_assert (!is_function_parameter (^^cls::type));\n+static_assert (!is_function_parameter (^^cls_var));\n+static_assert (!is_function_parameter (^^onion));\n+static_assert (!is_function_parameter (^^anon));\n+static_assert (!is_function_parameter (^^fun));\n+static_assert (!is_function_parameter (^^alias));\n+static_assert (!is_function_parameter (^^var));\n+static_assert (!is_function_parameter (^^ref));\n+static_assert (!is_function_parameter (^^rref));\n+static_assert (!is_function_parameter (^^ptr));\n+static_assert (!is_function_parameter (^^cls_tmpl));\n+static_assert (!is_function_parameter (^^cls_tmpl<int>));\n+static_assert (!is_function_parameter (^^incomplete_cls<int>));\n+static_assert (!is_function_parameter (^^fun_tmpl));\n+static_assert (!is_function_parameter (^^fun_tmpl<int>));\n+static_assert (!is_function_parameter (^^conc));\n+static_assert (!is_function_parameter (substitute (^^conc, { ^^int })));\n+static_assert (!is_function_parameter (^^var_tmpl));\n+static_assert (!is_function_parameter (^^var_tmpl<int>));\n+static_assert (!is_function_parameter (^^cls_tmpl_alias));\n+static_assert (!is_function_parameter (^^cls_tmpl_alias<int>));\n+static_assert (!is_function_parameter (^^Enum));\n+static_assert (!is_function_parameter (^^Enum::A));\n+static_assert (!is_function_parameter (^^Enum_class));\n+static_assert (!is_function_parameter (^^Enum_class::A));\n+static_assert (!is_function_parameter (^^decomp));\n+static_assert (!is_function_parameter (^^decomp_ref));\n+static_assert (!is_function_parameter (^^arr));\n+\n+constexpr auto dms = data_member_spec (^^int, { .name = \"dms\" });\n+static_assert (!is_function_parameter (dms));\n+\n+struct Base {};\n+struct Derived : Base {};\n+static_assert (!is_function_parameter (bases_of (^^Derived, access_context::current ())[0]));\n+\n+template<typename T, info R, info R2, info R3>\n+void\n+f ()\n+{\n+ static_assert (!is_function_parameter (^^T));\n+ static_assert (!is_function_parameter (R));\n+ static_assert (!is_function_parameter (R2));\n+ static_assert (!is_function_parameter (R3));\n+}\n+\n+void\n+g (int p, cls c)\n+{\n+ f<int, ^^var, ^^p, ^^c>();\n+ static_assert (!is_function_parameter (^^p));\n+ static_assert (!is_function_parameter (^^c));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/is_function_parameter2.C b/gcc/testsuite/g++.dg/reflect/is_function_parameter2.C\nnew file mode 100644\nindex 00000000000..e627df1f041\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/is_function_parameter2.C\n@@ -0,0 +1,13 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_function_parameter.\n+\n+#include <meta>\n+\n+using namespace std::meta;\n+\n+void fn (int a, bool &b, std::string *, ...);\n+\n+static_assert (is_function_parameter (parameters_of(^^fn)[0]));\n+static_assert (is_function_parameter (parameters_of(^^fn)[1]));\n+static_assert (is_function_parameter (parameters_of(^^fn)[2]));\n", "prefixes": [ "6/9", "v2" ] }