{"id":2175273,"url":"http://patchwork.ozlabs.org/api/1.0/patches/2175273/?format=json","project":{"id":17,"url":"http://patchwork.ozlabs.org/api/1.0/projects/17/?format=json","name":"GNU Compiler Collection","link_name":"gcc","list_id":"gcc-patches.gcc.gnu.org","list_email":"gcc-patches@gcc.gnu.org","web_url":null,"scm_url":null,"webscm_url":null},"msgid":"","date":"2025-12-17T16:49:46","name":"[9/9,v2] c++: C++26 Reflection [PR120775]","commit_ref":null,"pull_url":null,"state":"new","archived":false,"hash":"10eb7a1e17ed0c65e05d6182639a10b6ea39fc46","submitter":{"id":14370,"url":"http://patchwork.ozlabs.org/api/1.0/people/14370/?format=json","name":"Marek Polacek","email":"polacek@redhat.com"},"delegate":null,"mbox":"http://patchwork.ozlabs.org/project/gcc/patch/aULfKrrC9DALd5En@redhat.com/mbox/","series":[{"id":485726,"url":"http://patchwork.ozlabs.org/api/1.0/series/485726/?format=json","date":"2025-12-17T16:42:41","name":"c++: C++26 Reflection [PR120775]","version":2,"mbox":"http://patchwork.ozlabs.org/series/485726/mbox/"}],"check":"pending","checks":"http://patchwork.ozlabs.org/api/patches/2175273/checks/","tags":{},"headers":{"Return-Path":"","X-Original-To":["incoming@patchwork.ozlabs.org","gcc-patches@gcc.gnu.org"],"Delivered-To":["patchwork-incoming@legolas.ozlabs.org","gcc-patches@gcc.gnu.org"],"Authentication-Results":["legolas.ozlabs.org;\n\tdkim=pass (1024-bit key;\n unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256\n header.s=mimecast20190719 header.b=IT1f7Bw8;\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=IT1f7Bw8","sourceware.org; dmarc=pass (p=quarantine dis=none)\n header.from=redhat.com","sourceware.org; spf=pass smtp.mailfrom=redhat.com","server2.sourceware.org;\n arc=none smtp.remote-ip=170.10.129.124"],"Received":["from vm01.sourceware.org (vm01.sourceware.org [38.145.34.32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4dWg014XV8z1y0P\n\tfor ; Thu, 18 Dec 2025 03:55:13 +1100 (AEDT)","from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 755CE4BA2E33\n\tfor ; Wed, 17 Dec 2025 16:55:11 +0000 (GMT)","from us-smtp-delivery-124.mimecast.com\n (us-smtp-delivery-124.mimecast.com [170.10.129.124])\n by sourceware.org (Postfix) with ESMTP id 69A154BA2E27\n for ; Wed, 17 Dec 2025 16:49:55 +0000 (GMT)","from mail-qk1-f199.google.com (mail-qk1-f199.google.com\n [209.85.222.199]) by relay.mimecast.com with ESMTP with STARTTLS\n (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id\n us-mta-501-3WCXBOPbPderLZAoozD80A-1; Wed, 17 Dec 2025 11:49:53 -0500","by mail-qk1-f199.google.com with SMTP id\n af79cd13be357-8b2e235d4d2so2382764785a.3\n for ; Wed, 17 Dec 2025 08:49:53 -0800 (PST)","from redhat.com ([2603:7000:9500:10::1db4])\n by smtp.gmail.com with ESMTPSA id\n 6a1803df08f44-889a8609e59sm98734386d6.51.2025.12.17.08.49.47\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Wed, 17 Dec 2025 08:49:48 -0800 (PST)"],"DKIM-Filter":["OpenDKIM Filter v2.11.0 sourceware.org 755CE4BA2E33","OpenDKIM Filter v2.11.0 sourceware.org 69A154BA2E27"],"DMARC-Filter":"OpenDMARC Filter v1.4.2 sourceware.org 69A154BA2E27","ARC-Filter":"OpenARC Filter v1.0.0 sourceware.org 69A154BA2E27","ARC-Seal":"i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1765990195; cv=none;\n b=EI1B5fgjd5GoZn+AoEK7x9lcqKzARVuEvPVGm5h4ZquKNZfRwHqkPGO+u0AnKaWS83TBgYMohRPfmDhtLE0oZIFvG0yAROGmnj4ojETgHiH7fcITGz13IeMuF7vAQbz0UR/R+ikRhviVAgIMpNTqQp7ywW9dHU5ImvqDwjM69lQ=","ARC-Message-Signature":"i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1765990195; c=relaxed/simple;\n bh=6bXI0QdOywJHyH9vZ2APzG/jmnsTvgHqBhEyU3APZQs=;\n h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version;\n b=XJFf6WunLDv45YgNY8aOM7voZQMXFCtJ8s/6DINl+jHtr45LZuZRFDBmTXAJlKQTmACX7N9UF3R0fESQMysx9ijd71jTR8WqfTcSVetSXiOD12Zg3MHcBXgKak8i3anDO7R6qWRj/WwmHEFGmXRodrPzbxdR8j1BsMLwKMwhoO8=","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=1765990195;\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=kJrl34wNnqEakfQYrKN8yTV2lgm4PNTyrrAZ68W8KtQ=;\n b=IT1f7Bw8aUd9+oVH4N7mINu5Tn2yIEkqpzqv+BGGS8iWhxBiGHT+y4+2iFZxMwkK3kXByW\n O11EvRkoN5wGquwp1iiHi6E9iJ6e3IwzZilJ/70Kguc4tROwCkM445AkMB4WuDgq6kEysz\n XiPkiQUBsKqDB8Ddn4xaoJKE2uvfJTA=","X-MC-Unique":"3WCXBOPbPderLZAoozD80A-1","X-Mimecast-MFC-AGG-ID":"3WCXBOPbPderLZAoozD80A_1765990193","X-Google-DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20230601; t=1765990192; x=1766594992;\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=kJrl34wNnqEakfQYrKN8yTV2lgm4PNTyrrAZ68W8KtQ=;\n b=Ik9GQhIqgGZO6CdoZhKA+6pTJA4BnoYX5pwSozGN03I1gST6LZSKyIv+lwcxsZJerH\n CndtZLj8lnF7OBPGIaHObrSJYDyGb2mj5h6A8BrmdpZ+dMeq0enKHlwexXSgTGd2HvSI\n Q+86K+i++cxX6JBSTg+1G6Uewd0NsU2iYOOlRKCeUxZMdrv1vVEE0YSlrP3IStKUFspw\n dGZrv4GYKKybSXgvUYkrSkWcafIee9/GMqSMWH1UqsT1uKgi/BottdBw4fEkjHq7vhYn\n f7urM75yOLIoJPWLzGMSCyRttAcf1u1nL4vtaHyxxxgypbXN4ZYbgO1Incyr7QZFg74d\n nfCg==","X-Gm-Message-State":"AOJu0YwWmoaLBR0NWCnetd6OgxLZzsPGH30JOePfQ3mt+g2uSks/znA+\n ypbncaP5KGyvtsAr18W0/SkH6Z4UKdDlg+86P8iey5SBJOFkspjbuiNpfHMbGERXVTMxwBBODKK\n K1ajH9JWbX49qfY3yASMPt4wVgxDb0ZRuBOBzLXEXMSED4Dl/4hNaJFNZcVntf9PIyiSpYpYXPw\n p/PDJV6jr02yra3RLHenqZTtulwWgpECD2i3WV8M4oZg==","X-Gm-Gg":"AY/fxX555R1IKalB8mLJhBxdzVkUOZRPZjPmpTzaN+G917xMfVb9cIWQcnxwd/p3clP\n GbQsa9BaFPJDXfwMVaFrfu+/+I3KuTs4oJiWpz+FXZrCd2McOMV4/801DBXWaHHFAX57mPJ0fJb\n BtdUawZ4qjSwZHHh13uTlZDOMNhMHyKs8C/ClpCdzx8o9vdZLus8c12sg3cttRBAovJFc6OeNMZ\n sqhfOaRGLSkieKIMWpPipt5EvrhlZgoD9tL3xe/nXGkd1aLHTzDck0wl5CDppUy70ecSbmLmOGS\n pRWZDrzTICqexWIXDYmaGOtNUI/Wr+Vr1KCYh7WZVZhw6iXa5znnYlllrZZR8VXe8A==","X-Received":["by 2002:a05:620a:46a7:b0:893:b99:7120 with SMTP id\n af79cd13be357-8bb3a38f6abmr2642274885a.80.1765990190385;\n Wed, 17 Dec 2025 08:49:50 -0800 (PST)","by 2002:a05:620a:46a7:b0:893:b99:7120 with SMTP id\n af79cd13be357-8bb3a38f6abmr2642263585a.80.1765990188868;\n Wed, 17 Dec 2025 08:49:48 -0800 (PST)"],"X-Google-Smtp-Source":"\n AGHT+IHrIWmE2JBD2wKOYLiNK+b3Y5X5gp8l07imphct2PGQfi4lFoms3FhBuK0J32sKo3gyfxaY9Q==","Date":"Wed, 17 Dec 2025 11:49:46 -0500","From":"Marek Polacek ","To":"GCC Patches , Jason Merrill ,\n Jakub Jelinek , Jonathan Wakely ","Subject":"[PATCH 9/9 v2] c++: C++26 Reflection [PR120775]","Message-ID":"","References":"","MIME-Version":"1.0","In-Reply-To":"","User-Agent":"Mutt/2.2.14 (2025-02-20)","X-Mimecast-Spam-Score":"0","X-Mimecast-MFC-PROC-ID":"cW3xSKHD6WKuoHfjNWSZUKBSKCKoRROuh7DrorFB9X8_1765990193","X-Mimecast-Originator":"redhat.com","Content-Type":"text/plain; charset=us-ascii","Content-Disposition":"inline","X-BeenThere":"gcc-patches@gcc.gnu.org","X-Mailman-Version":"2.1.30","Precedence":"list","List-Id":"Gcc-patches mailing list ","List-Unsubscribe":",\n ","List-Archive":"","List-Post":"","List-Help":"","List-Subscribe":",\n ","Errors-To":"gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org"},"content":"Testsuite bits part #5.\n\n-- >8 --","diff":"diff --git a/gcc/testsuite/g++.dg/reflect/type_trait11.C b/gcc/testsuite/g++.dg/reflect/type_trait11.C\nnew file mode 100644\nindex 00000000000..977afbcf125\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait11.C\n@@ -0,0 +1,447 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], type properties.\n+\n+#include \n+#include \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 LType { int i; constexpr LType (int j) : i(j) {} };\n+struct HasTemplateCCtor { HasTemplateCCtor (const HasTemplateCCtor &) = default; template HasTemplateCCtor (T &&); };\n+struct MoveOnly { MoveOnly (MoveOnly &&) = default; };\n+struct MoveOnly2 { MoveOnly2 (MoveOnly2 &&) = delete; };\n+class PolymorphicClass { virtual void rotate (int); };\n+struct CopyConsOnlyType {\n+ CopyConsOnlyType (int) { }\n+ CopyConsOnlyType (CopyConsOnlyType &&) = delete;\n+ CopyConsOnlyType (const CopyConsOnlyType &) = default;\n+ CopyConsOnlyType &operator= (const CopyConsOnlyType &) = delete;\n+ CopyConsOnlyType &operator= (CopyConsOnlyType &&) = delete;\n+};\n+struct MoveConsOnlyType {\n+ MoveConsOnlyType (int) { }\n+ MoveConsOnlyType (const MoveConsOnlyType &) = delete;\n+ MoveConsOnlyType (MoveConsOnlyType &&) = default;\n+ MoveConsOnlyType &operator= (const MoveConsOnlyType &) = delete;\n+ MoveConsOnlyType &operator= (MoveConsOnlyType &&) = delete;\n+};\n+struct NoexceptExplicitClass {\n+ NoexceptExplicitClass (double &) noexcept (true);\n+ explicit NoexceptExplicitClass (int &) noexcept (true);\n+ NoexceptExplicitClass (double &, int &, double &) noexcept (true);\n+};\n+struct ExceptExplicitClass {\n+ ExceptExplicitClass (double &) noexcept (false);\n+ explicit ExceptExplicitClass (int &) noexcept (false);\n+ ExceptExplicitClass (double &, int &, double &) noexcept (false);\n+};\n+struct NothrowExplicitClass {\n+ NothrowExplicitClass (double &) throw ();\n+ explicit NothrowExplicitClass (int &) throw ();\n+ NothrowExplicitClass (double &, int &, double &) throw ();\n+};\n+\n+namespace N1\n+{\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 \n+ struct ImplicitTo { operator To (); };\n+ template \n+ struct DelImplicitTo { operator To () = delete; };\n+ template \n+ struct ExplicitTo { explicit operator To (); };\n+ struct Ellipsis { Ellipsis (...) {} };\n+ struct DelEllipsis { DelEllipsis (...) = delete; };\n+ struct Any { template Any (T &&) {} };\n+ struct nAny { template nAny (T &&...) {} };\n+ struct DelnAny { template DelnAny (T &&...) = delete; };\n+ template \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+struct X { X () = default; X (int) noexcept {} X (double) {} };\n+struct Y { int i; X x; };\n+struct Z : Y { };\n+\n+static_assert (is_trivially_constructible_type (^^int, {}));\n+static_assert (is_trivially_constructible_type (^^int, { ^^int }));\n+static_assert (is_trivially_constructible_type (^^int, { ^^int & }));\n+static_assert (is_trivially_constructible_type (^^int, { ^^int && }));\n+static_assert (is_trivially_constructible_type (^^int, { ^^const int & }));\n+static_assert (!is_trivially_constructible_type (^^int, { ^^void * }));\n+static_assert (!is_trivially_constructible_type (^^int, { ^^int * }));\n+static_assert (!is_trivially_constructible_type (^^int, { ^^const int * }));\n+static_assert (!is_trivially_constructible_type (^^int *, { ^^void * }));\n+static_assert (!is_trivially_constructible_type (^^int *, { ^^const int * }));\n+static_assert (!is_trivially_constructible_type (^^int &, { ^^const int }));\n+static_assert (is_trivially_constructible_type (^^const int &, { ^^int }));\n+static_assert (is_trivially_constructible_type (^^const int &, { ^^int & }));\n+static_assert (is_trivially_constructible_type (^^const int *, { ^^int * }));\n+static_assert (!is_trivially_constructible_type (^^PolymorphicClass, {}));\n+static_assert (!is_trivially_constructible_type (^^PolymorphicClass, { ^^PolymorphicClass }));\n+static_assert (!is_trivially_constructible_type (^^PolymorphicClass, { ^^PolymorphicClass & }));\n+static_assert (!is_trivially_constructible_type (^^PolymorphicClass, { ^^PolymorphicClass && }));\n+static_assert (!is_trivially_constructible_type (^^PolymorphicClass, { ^^const PolymorphicClass & }));\n+static_assert (is_trivially_constructible_type (^^TType, {}));\n+static_assert (is_trivially_constructible_type (^^TType, { ^^TType }));\n+static_assert (is_trivially_constructible_type (^^TType, { ^^TType & }));\n+static_assert (is_trivially_constructible_type (^^TType, { ^^TType && }));\n+static_assert (is_trivially_constructible_type (^^TType, { ^^const TType & }));\n+static_assert (!is_trivially_constructible_type (^^TType, { ^^int, ^^int }));\n+static_assert (is_trivially_constructible_type (^^PODType, {}));\n+static_assert (is_trivially_constructible_type (^^PODType, { ^^PODType }));\n+static_assert (is_trivially_constructible_type (^^PODType, { ^^PODType & }));\n+static_assert (is_trivially_constructible_type (^^PODType, { ^^PODType && }));\n+static_assert (is_trivially_constructible_type (^^PODType, { ^^const PODType & }));\n+static_assert (is_trivially_constructible_type (^^PODType, { ^^int, ^^int }));\n+static_assert (!is_trivially_constructible_type (^^NType, {}));\n+static_assert (!is_trivially_constructible_type (^^SLType, {}));\n+static_assert (!is_trivially_constructible_type (^^LType, {}));\n+static_assert (!is_trivially_constructible_type (^^LType, { ^^int }));\n+static_assert (!is_trivially_constructible_type (^^N1::DelDef, {}));\n+static_assert (!is_trivially_constructible_type (^^N1::Abstract, {}));\n+static_assert (!is_trivially_constructible_type (^^N1::Ellipsis, {}));\n+static_assert (!is_trivially_constructible_type (^^N1::DelEllipsis, {}));\n+static_assert (!is_trivially_constructible_type (^^N1::Any, {}));\n+static_assert (!is_trivially_constructible_type (^^N1::DelCopy, {}));\n+static_assert (!is_trivially_constructible_type (^^N1::DelCopy, { ^^const N1::DelCopy & }));\n+static_assert (!is_trivially_constructible_type (^^N1::DelDtor, {}));\n+static_assert (!is_trivially_constructible_type (^^N1::Nontrivial, {}));\n+static_assert (!is_trivially_constructible_type (^^N1::UnusualCopy, {}));\n+static_assert (!is_trivially_constructible_type (^^CopyConsOnlyType, {}));\n+static_assert (!is_trivially_constructible_type (^^CopyConsOnlyType, { ^^CopyConsOnlyType }));\n+static_assert (is_trivially_constructible_type (^^CopyConsOnlyType, { ^^CopyConsOnlyType & }));\n+static_assert (!is_trivially_constructible_type (^^CopyConsOnlyType, { ^^CopyConsOnlyType && }));\n+static_assert (is_trivially_constructible_type (^^CopyConsOnlyType, { ^^const CopyConsOnlyType & }));\n+static_assert (!is_trivially_constructible_type (^^MoveConsOnlyType, {}));\n+static_assert (is_trivially_constructible_type (^^MoveConsOnlyType, { ^^MoveConsOnlyType }));\n+static_assert (!is_trivially_constructible_type (^^MoveConsOnlyType, { ^^MoveConsOnlyType & }));\n+static_assert (is_trivially_constructible_type (^^MoveConsOnlyType, { ^^MoveConsOnlyType && }));\n+static_assert (!is_trivially_constructible_type (^^MoveConsOnlyType, { ^^const MoveConsOnlyType & }));\n+static_assert (is_trivially_constructible_type (^^ClassType, { ^^DerivedType }));\n+static_assert (is_trivially_constructible_type (^^ClassType, { ^^DerivedType & }));\n+static_assert (is_trivially_constructible_type (^^ClassType, { ^^DerivedType && }));\n+static_assert (is_trivially_constructible_type (^^ClassType, { ^^const DerivedType & }));\n+static_assert (!is_trivially_constructible_type (^^HasTemplateCCtor, {}));\n+static_assert (!is_trivially_constructible_type (^^HasTemplateCCtor, { ^^HasTemplateCCtor }));\n+static_assert (is_trivially_constructible_type (^^HasTemplateCCtor, { ^^const HasTemplateCCtor & }));\n+static_assert (!is_trivially_constructible_type (^^MoveOnly, {}));\n+static_assert (is_trivially_constructible_type (^^MoveOnly, { ^^MoveOnly }));\n+static_assert (!is_trivially_constructible_type (^^MoveOnly, { ^^MoveOnly & }));\n+static_assert (is_trivially_constructible_type (^^MoveOnly, { ^^MoveOnly && }));\n+static_assert (!is_trivially_constructible_type (^^MoveOnly, { ^^const MoveOnly & }));\n+static_assert (!is_trivially_constructible_type (^^MoveOnly2, {}));\n+static_assert (!is_trivially_constructible_type (^^int [], {}));\n+\n+static_assert (is_nothrow_constructible_type (^^NoexceptExplicitClass, { ^^double & }));\n+static_assert (is_nothrow_constructible_type (^^NoexceptExplicitClass, { ^^int & }));\n+static_assert (is_nothrow_constructible_type (^^NoexceptExplicitClass, { ^^double &, ^^int &, ^^double & }));\n+static_assert (is_nothrow_constructible_type (^^NothrowExplicitClass, { ^^double & }));\n+static_assert (is_nothrow_constructible_type (^^NothrowExplicitClass, { ^^int & }));\n+static_assert (is_nothrow_constructible_type (^^NothrowExplicitClass, { ^^double &, ^^int &, ^^double & }));\n+static_assert (is_nothrow_constructible_type (^^int [1], {}));\n+static_assert (!is_nothrow_constructible_type (^^NoexceptExplicitClass, { ^^void * }));\n+static_assert (!is_nothrow_constructible_type (^^NoexceptExplicitClass, {}));\n+static_assert (!is_nothrow_constructible_type (^^NoexceptExplicitClass, { ^^int, ^^double }));\n+static_assert (!is_nothrow_constructible_type (^^NothrowExplicitClass, { ^^void * }));\n+static_assert (!is_nothrow_constructible_type (^^NothrowExplicitClass, {}));\n+static_assert (!is_nothrow_constructible_type (^^NothrowExplicitClass, { ^^int, ^^double }));\n+static_assert (!is_nothrow_constructible_type (^^ExceptExplicitClass, { ^^double & }));\n+static_assert (!is_nothrow_constructible_type (^^ExceptExplicitClass, { ^^int & }));\n+static_assert (!is_nothrow_constructible_type (^^ExceptExplicitClass, { ^^double &, ^^int &, ^^double & }));\n+static_assert (!is_nothrow_constructible_type (^^int [], {}));\n+static_assert (is_nothrow_constructible_type (^^int [1], {}));\n+static_assert (is_nothrow_constructible_type (^^int [1], { ^^int }));\n+static_assert (is_nothrow_constructible_type (^^int [2], { ^^int }));\n+static_assert (is_nothrow_constructible_type (^^int [2], { ^^int, ^^int }));\n+static_assert (!is_nothrow_constructible_type (^^int [1], { ^^int, ^^int }));\n+static_assert (!is_nothrow_constructible_type (^^int [], {}));\n+static_assert (!is_nothrow_constructible_type (^^int [], { ^^int }));\n+static_assert (!is_nothrow_constructible_type (^^int [], { ^^int, ^^int }));\n+static_assert (is_nothrow_constructible_type (^^X [2], {}));\n+static_assert (is_nothrow_constructible_type (^^X [1], { ^^X }));\n+static_assert (is_nothrow_constructible_type (^^X [1], { ^^int }));\n+static_assert (!is_nothrow_constructible_type (^^X [1], { ^^double }));\n+static_assert (!is_nothrow_constructible_type (^^X [2], { ^^int, ^^double }));\n+static_assert (is_nothrow_constructible_type (^^Y, {}));\n+static_assert (is_nothrow_constructible_type (^^Y, { ^^Y }));\n+static_assert (is_nothrow_constructible_type (^^Y, { ^^int }));\n+static_assert (!is_nothrow_constructible_type (^^Y, { ^^X }));\n+static_assert (is_nothrow_constructible_type (^^Y, { ^^int, ^^X }));\n+static_assert (is_nothrow_constructible_type (^^Y, { ^^int, ^^int }));\n+static_assert (!is_nothrow_constructible_type (^^Y, { ^^int, ^^double }));\n+static_assert (is_nothrow_constructible_type (^^Z, {}));\n+static_assert (is_nothrow_constructible_type (^^Z, { ^^Z }));\n+static_assert (is_nothrow_constructible_type (^^Z, { ^^Y }));\n+static_assert (!is_nothrow_constructible_type (^^Z, { ^^int }));\n+static_assert (!is_nothrow_constructible_type (^^Z, { ^^int, ^^X }));\n+static_assert (!is_nothrow_constructible_type (^^Z, { ^^int, ^^int }));\n+static_assert (!is_nothrow_constructible_type (^^Z, { ^^Y, ^^double }));\n+static_assert (!is_nothrow_constructible_type (^^Z, { ^^int, ^^double }));\n+static_assert (!is_nothrow_constructible_type (^^Z, { ^^X }));\n+\n+using func_type_v0 = void (*) ();\n+using func_type_i0 = int (*) ();\n+using func_type_l0 = int &(*) ();\n+using func_type_ii = int (*) (int);\n+using func_type_il = int (*) (int &);\n+using func_type_ir = int (*) (int &&);\n+struct W { };\n+\n+using mem_type_i = int W::*;\n+using memfun_type_i = int (W::*) ();\n+using memfun_type_iic = int &(W::*) (int &) const;\n+struct F {\n+ int &operator () ();\n+ long &operator () () const;\n+ short &operator () (int) &&;\n+ char &operator () (int) const &;\n+private:\n+ void operator () (int, int);\n+};\n+using CF = const F;\n+struct T { T (int) { } };\n+struct NT { NT (int) noexcept { } };\n+struct Ex { explicit Ex (int) noexcept { } };\n+using func_type = void (*) ();\n+using func_type_nt = void (*) () noexcept;\n+using mem_type = int W::*;\n+using memfun_type = int (W::*) ();\n+using memfun_type_nt = int (W::*) () noexcept;\n+struct F2 {\n+ int &operator () ();\n+ long &operator () () const noexcept;\n+ short &operator () (int) &&;\n+ char &operator () (int) const & noexcept;\n+private:\n+ void operator () (int, int) noexcept;\n+};\n+using CF2 = const F2;\n+struct FW { W operator () () const noexcept { return {}; } };\n+struct V { explicit V (W) noexcept; V (...); };\n+\n+static_assert (is_invocable_type (^^func_type_v0, {}));\n+static_assert (!is_invocable_type (^^func_type_v0, { ^^int }));\n+static_assert (is_invocable_type (^^func_type_i0, {}));\n+static_assert (!is_invocable_type (^^func_type_i0, { ^^int }));\n+static_assert (is_invocable_type (^^func_type_l0, {}));\n+static_assert (!is_invocable_type (^^func_type_l0 (int), {}));\n+static_assert (!is_invocable_type (^^func_type_ii, {}));\n+static_assert (is_invocable_type (^^func_type_ii, { ^^int }));\n+static_assert (!is_invocable_type (^^func_type_il, {}));\n+static_assert (!is_invocable_type (^^func_type_il, { ^^int }));\n+static_assert (is_invocable_type (^^func_type_il, { ^^int & }));\n+static_assert (!is_invocable_type (^^func_type_ir, {}));\n+static_assert (is_invocable_type (^^func_type_ir, { ^^int }));\n+static_assert (!is_invocable_type (^^func_type_ir, { ^^int & }));\n+static_assert (!is_invocable_type (^^mem_type_i, {}));\n+static_assert (!is_invocable_type (^^mem_type_i, { ^^int }));\n+static_assert (!is_invocable_type (^^mem_type_i, { ^^int & }));\n+static_assert (is_invocable_type (^^mem_type_i, { ^^W & }));\n+static_assert (!is_invocable_type (^^memfun_type_i, {}));\n+static_assert (!is_invocable_type (^^memfun_type_i, { ^^int }));\n+static_assert (!is_invocable_type (^^memfun_type_i, { ^^int & }));\n+static_assert (is_invocable_type (^^memfun_type_i, { ^^W & }));\n+static_assert (is_invocable_type (^^memfun_type_i, { ^^W * }));\n+static_assert (!is_invocable_type (^^memfun_type_i, { ^^const W & }));\n+static_assert (!is_invocable_type (^^memfun_type_i, { ^^W &, ^^int }));\n+static_assert (!is_invocable_type (^^memfun_type_iic, {}));\n+static_assert (!is_invocable_type (^^memfun_type_iic, { ^^int }));\n+static_assert (!is_invocable_type (^^memfun_type_iic, { ^^int & }));\n+static_assert (!is_invocable_type (^^memfun_type_iic, { ^^W &, ^^int }));\n+static_assert (!is_invocable_type (^^memfun_type_iic, { ^^const W &, ^^int }));\n+static_assert (!is_invocable_type (^^memfun_type_iic, { ^^const W &, ^^int &, ^^int }));\n+static_assert (is_invocable_type (^^memfun_type_iic, { ^^const W &, ^^int & }));\n+static_assert (is_invocable_type (^^memfun_type_iic, { ^^const W *, ^^int & }));\n+static_assert (!is_invocable_type (^^F, { ^^int, ^^int }));\n+\n+static_assert (!is_nothrow_invocable_type (^^func_type, {}));\n+static_assert (is_nothrow_invocable_type (^^func_type_nt, {}));\n+static_assert (!is_nothrow_invocable_type (^^mem_type, {}));\n+static_assert (!is_nothrow_invocable_type (^^mem_type, { ^^int }));\n+static_assert (!is_nothrow_invocable_type (^^mem_type, { ^^int & }));\n+static_assert (is_nothrow_invocable_type (^^mem_type, { ^^W & }));\n+static_assert (!is_nothrow_invocable_type (^^memfun_type, {}));\n+static_assert (!is_nothrow_invocable_type (^^memfun_type, { ^^int }));\n+static_assert (!is_nothrow_invocable_type (^^memfun_type, { ^^int & }));\n+static_assert (!is_nothrow_invocable_type (^^memfun_type, { ^^W & }));\n+static_assert (!is_nothrow_invocable_type (^^memfun_type, { ^^W * }));\n+static_assert (!is_nothrow_invocable_type (^^memfun_type_nt, {}));\n+static_assert (!is_nothrow_invocable_type (^^memfun_type_nt, { ^^int }));\n+static_assert (!is_nothrow_invocable_type (^^memfun_type_nt, { ^^int & }));\n+static_assert (is_nothrow_invocable_type (^^memfun_type_nt, { ^^W & }));\n+static_assert (is_nothrow_invocable_type (^^memfun_type_nt, { ^^W * }));\n+static_assert (!is_nothrow_invocable_type (^^F2, {}));\n+static_assert (is_nothrow_invocable_type (^^CF2, {}));\n+static_assert (!is_nothrow_invocable_type (^^F2, { ^^int }));\n+static_assert (is_nothrow_invocable_type (^^F2 &, { ^^int }));\n+static_assert (is_nothrow_invocable_type (^^CF2, { ^^int }));\n+static_assert (is_nothrow_invocable_type (^^CF2 &, { ^^int }));\n+static_assert (!is_nothrow_invocable_type (^^F2, { ^^int, ^^int }));\n+static_assert (is_nothrow_invocable_type (^^FW, {}));\n+\n+static_assert (is_invocable_r_type (^^void, ^^func_type_v0, {}));\n+static_assert (!is_invocable_r_type (^^void *, ^^func_type_v0, {}));\n+static_assert (!is_invocable_r_type (^^int, ^^func_type_v0, {}));\n+static_assert (!is_invocable_r_type (^^void, ^^func_type_v0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^void *, ^^func_type_v0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int, ^^func_type_v0, { ^^int }));\n+static_assert (is_invocable_r_type (^^void, ^^func_type_i0, {}));\n+static_assert (is_invocable_r_type (^^int, ^^func_type_i0, {}));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_i0, {}));\n+static_assert (is_invocable_r_type (^^long, ^^func_type_i0, {}));\n+static_assert (!is_invocable_r_type (^^void, ^^func_type_i0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int, ^^func_type_i0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_i0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^long, ^^func_type_i0, { ^^int }));\n+static_assert (is_invocable_r_type (^^void, ^^func_type_l0, {}));\n+static_assert (is_invocable_r_type (^^int, ^^func_type_l0, {}));\n+static_assert (is_invocable_r_type (^^int &, ^^func_type_l0, {}));\n+static_assert (!is_invocable_r_type (^^int &&, ^^func_type_l0, {}));\n+static_assert (is_invocable_r_type (^^long, ^^func_type_l0, {}));\n+static_assert (!is_invocable_r_type (^^long &, ^^func_type_l0, {}));\n+static_assert (!is_invocable_r_type (^^void, ^^func_type_l0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int, ^^func_type_l0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_l0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^long, ^^func_type_l0, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int, ^^func_type_ii, {}));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_ii, {}));\n+static_assert (!is_invocable_r_type (^^long, ^^func_type_ii, {}));\n+static_assert (is_invocable_r_type (^^int, ^^func_type_ii, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_ii, { ^^int }));\n+static_assert (is_invocable_r_type (^^long, ^^func_type_ii, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int, ^^func_type_il, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_il, { ^^int }));\n+static_assert (!is_invocable_r_type (^^long, ^^func_type_il, { ^^int }));\n+static_assert (is_invocable_r_type (^^int, ^^func_type_il, { ^^int & }));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_il, { ^^int & }));\n+static_assert (is_invocable_r_type (^^long, ^^func_type_il, { ^^int & }));\n+static_assert (is_invocable_r_type (^^int, ^^func_type_ir, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_ir, { ^^int }));\n+static_assert (is_invocable_r_type (^^long, ^^func_type_ir, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int, ^^func_type_ir, { ^^int & }));\n+static_assert (!is_invocable_r_type (^^int &, ^^func_type_ir, { ^^int & }));\n+static_assert (!is_invocable_r_type (^^long, ^^func_type_ir, { ^^int & }));\n+static_assert (!is_invocable_r_type (^^int, ^^mem_type_i, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int &, ^^mem_type_i, { ^^int }));\n+static_assert (!is_invocable_r_type (^^long, ^^mem_type_i, { ^^int }));\n+static_assert (!is_invocable_r_type (^^int, ^^mem_type_i, { ^^int & }));\n+static_assert (!is_invocable_r_type (^^int &, ^^mem_type_i, { ^^int & }));\n+static_assert (!is_invocable_r_type (^^long, ^^mem_type_i, { ^^int & }));\n+static_assert (is_invocable_r_type (^^int, ^^mem_type_i, { ^^W & }));\n+static_assert (is_invocable_r_type (^^int &, ^^mem_type_i, { ^^W & }));\n+static_assert (is_invocable_r_type (^^long, ^^mem_type_i, { ^^W & }));\n+static_assert (is_invocable_r_type (^^int, ^^memfun_type_i, { ^^W & }));\n+static_assert (!is_invocable_r_type (^^int &, ^^memfun_type_i, { ^^W & }));\n+static_assert (is_invocable_r_type (^^long, ^^memfun_type_i, { ^^W & }));\n+static_assert (!is_invocable_r_type (^^int, ^^memfun_type_i, { ^^const W & }));\n+static_assert (is_invocable_r_type (^^int, ^^memfun_type_iic, { ^^const W &, ^^int & }));\n+static_assert (is_invocable_r_type (^^int &, ^^memfun_type_iic, { ^^const W &, ^^int & }));\n+static_assert (is_invocable_r_type (^^long, ^^memfun_type_iic, { ^^const W &, ^^int & }));\n+static_assert (!is_invocable_r_type (^^long &, ^^memfun_type_iic, { ^^const W &, ^^int & }));\n+static_assert (is_invocable_r_type (^^int &, ^^F, {}));\n+static_assert (is_invocable_r_type (^^int &, ^^F &, {}));\n+static_assert (is_invocable_r_type (^^long &, ^^CF, {}));\n+static_assert (is_invocable_r_type (^^long &, ^^CF &, {}));\n+static_assert (is_invocable_r_type (^^short &, ^^F, { ^^int }));\n+static_assert (is_invocable_r_type (^^char &, ^^F &, { ^^int }));\n+static_assert (is_invocable_r_type (^^char &, ^^CF, { ^^int }));\n+static_assert (is_invocable_r_type (^^char &, ^^CF &, { ^^int }));\n+\n+static_assert (is_nothrow_invocable_r_type (^^int, ^^mem_type, { ^^W & }));\n+static_assert (is_nothrow_invocable_r_type (^^int &, ^^mem_type, { ^^W & }));\n+static_assert (is_nothrow_invocable_r_type (^^long, ^^mem_type, { ^^W & }));\n+static_assert (!is_nothrow_invocable_r_type (^^long &, ^^mem_type, { ^^W & }));\n+static_assert (is_nothrow_invocable_r_type (^^int &, ^^mem_type, { ^^W * }));\n+static_assert (!is_nothrow_invocable_r_type (^^T, ^^mem_type, { ^^W & }));\n+static_assert (is_nothrow_invocable_r_type (^^NT, ^^mem_type, { ^^W & }));\n+static_assert (!is_nothrow_invocable_r_type (^^Ex, ^^mem_type, { ^^W & }));\n+static_assert (!is_nothrow_invocable_r_type (^^T, ^^memfun_type, { ^^W & }));\n+static_assert (!is_nothrow_invocable_r_type (^^NT, ^^memfun_type, { ^^W & }));\n+static_assert (!is_nothrow_invocable_r_type (^^Ex, ^^memfun_type, { ^^W & }));\n+static_assert (!is_nothrow_invocable_r_type (^^T, ^^memfun_type_nt, { ^^W & }));\n+static_assert (is_nothrow_invocable_r_type (^^NT, ^^memfun_type_nt, { ^^W & }));\n+static_assert (!is_nothrow_invocable_r_type (^^Ex, ^^memfun_type_nt, { ^^W & }));\n+static_assert (!is_nothrow_invocable_r_type (^^int &, ^^F2, {}));\n+static_assert (is_nothrow_invocable_r_type (^^long &, ^^CF2, {}));\n+static_assert (!is_nothrow_invocable_r_type (^^T, ^^F2, {}));\n+static_assert (!is_nothrow_invocable_r_type (^^NT, ^^F2, {}));\n+static_assert (!is_nothrow_invocable_r_type (^^Ex, ^^F2, {}));\n+static_assert (!is_nothrow_invocable_r_type (^^void, ^^F2, {}));\n+static_assert (!is_nothrow_invocable_r_type (^^T, ^^CF2, {}));\n+static_assert (is_nothrow_invocable_r_type (^^NT, ^^CF2, {}));\n+static_assert (!is_nothrow_invocable_r_type (^^Ex, ^^CF2, {}));\n+static_assert (is_nothrow_invocable_r_type (^^void, ^^CF2, {}));\n+static_assert (!is_nothrow_invocable_r_type (^^short &, ^^F2, { ^^int }));\n+static_assert (is_nothrow_invocable_r_type (^^char &, ^^F2 &, { ^^int }));\n+static_assert (!is_nothrow_invocable_r_type (^^T, ^^F2 &, { ^^int }));\n+static_assert (is_nothrow_invocable_r_type (^^NT, ^^F2 &, { ^^int }));\n+static_assert (!is_nothrow_invocable_r_type (^^Ex, ^^F2 &, { ^^int }));\n+static_assert (is_nothrow_invocable_r_type (^^char &, ^^CF2, { ^^int }));\n+static_assert (is_nothrow_invocable_r_type (^^char &, ^^CF2 &, { ^^int }));\n+static_assert (is_nothrow_invocable_r_type (^^void, ^^CF2 &, { ^^int }));\n+static_assert (!is_nothrow_invocable_r_type (^^T, ^^CF2 &, { ^^int }));\n+static_assert (is_nothrow_invocable_r_type (^^NT, ^^CF2 &, { ^^int }));\n+static_assert (!is_nothrow_invocable_r_type (^^Ex, ^^CF2 &, { ^^int }));\n+static_assert (is_nothrow_invocable_r_type (^^void, ^^CF2 &, { ^^int }));\n+static_assert (!is_nothrow_invocable_r_type (^^void, ^^F2, { ^^int, ^^int }));\n+static_assert (!is_nothrow_invocable_r_type (^^V, ^^FW, {}));\n+\n+static_assert (invoke_result (^^std::copyable_function , {}) == ^^void);\n+static_assert (invoke_result (^^std::copyable_function , {}) == ^^int);\n+static_assert (invoke_result (^^std::copyable_function , {}) == ^^int &);\n+static_assert (invoke_result (^^std::copyable_function , { ^^long, ^^int }) == ^^void);\n+static_assert (invoke_result (^^std::copyable_function , { ^^double, ^^unsigned }) == ^^int);\n+static_assert (invoke_result (^^std::copyable_function , { ^^int & }) == ^^int &);\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait12.C b/gcc/testsuite/g++.dg/reflect/type_trait12.C\nnew file mode 100644\nindex 00000000000..372d7408f29\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait12.C\n@@ -0,0 +1,137 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// { dg-add-options float16 }\n+// { dg-add-options float32 }\n+// { dg-add-options float64 }\n+// { dg-add-options float128 }\n+// Test reflection type traits [meta.reflection.traits], type properties.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+struct A { int a, b, c; };\n+class B { static int a; private: static int b; public: int c; };\n+struct C { C () {} int a, b, c; };\n+struct D { explicit D (int) {} int a, b, c; };\n+struct E : public A { int d, e, f; };\n+struct F : public C { using C::C; int d, e, f; };\n+class G { int a, b; };\n+struct H { private: int a, b; };\n+struct I { protected: int a, b; };\n+struct J { int a, b; void foo (); };\n+struct K { int a, b; virtual void foo (); };\n+struct L : virtual public A { int d, e; };\n+struct M : protected A { int d, e; };\n+struct N : private A { int d, e; };\n+struct O { O () = delete; int a, b, c; };\n+struct P { P () = default; int a, b, c; };\n+struct Q { Q (); Q (const Q &); int a, b, c; };\n+struct R { R (); R (const R &); R (R &&) = default; int a, b, c; };\n+struct S { S (); ~S (); int a, b, c; };\n+struct T { T (); ~T () = default; int a, b, c; };\n+struct U { U (); U (const U &) = default; int a, b, c; };\n+struct V { V () = default; V (const V &); int a, b, c; };\n+enum W { W1 };\n+enum class X : int { X1 };\n+struct Y { int g; int foo (int); };\n+struct Z;\n+struct AA { Q a; Q b; };\n+struct AB { Q a; Q b; ~AB () = default; };\n+struct AC { Q a; Q b; ~AC () {} };\n+struct AD : public Q {};\n+struct AE : public Q { ~AE () = default; };\n+struct AF : public Q { ~AF () {} };\n+\n+static_assert (!is_implicit_lifetime_type (^^void));\n+static_assert (!is_implicit_lifetime_type (^^const void));\n+static_assert (!is_implicit_lifetime_type (^^volatile void));\n+static_assert (is_implicit_lifetime_type (^^char));\n+static_assert (is_implicit_lifetime_type (^^signed char));\n+static_assert (is_implicit_lifetime_type (^^const unsigned char));\n+static_assert (is_implicit_lifetime_type (^^short));\n+static_assert (is_implicit_lifetime_type (^^volatile unsigned short));\n+static_assert (is_implicit_lifetime_type (^^int));\n+static_assert (is_implicit_lifetime_type (^^unsigned int));\n+static_assert (is_implicit_lifetime_type (^^const volatile long));\n+static_assert (is_implicit_lifetime_type (^^unsigned long));\n+static_assert (is_implicit_lifetime_type (^^long long));\n+static_assert (is_implicit_lifetime_type (^^unsigned long long));\n+#ifdef __SIZEOF_INT128__\n+__extension__ static_assert (is_implicit_lifetime_type (^^__int128));\n+__extension__ static_assert (is_implicit_lifetime_type (^^unsigned __int128));\n+#endif\n+static_assert (is_implicit_lifetime_type (^^float));\n+static_assert (is_implicit_lifetime_type (^^double));\n+static_assert (is_implicit_lifetime_type (^^long double volatile));\n+#ifdef __STDCPP_FLOAT16_T__\n+static_assert (is_implicit_lifetime_type (^^_Float16));\n+#endif\n+#ifdef __STDCPP_FLOAT32_T__\n+static_assert (is_implicit_lifetime_type (^^_Float32));\n+#endif\n+#ifdef __STDCPP_FLOAT64_T__\n+static_assert (is_implicit_lifetime_type (^^const _Float64));\n+#endif\n+#ifdef __STDCPP_FLOAT128_T__\n+static_assert (is_implicit_lifetime_type (^^_Float128));\n+#endif\n+#ifdef __STDCPP_BFLOAT16_T__\n+static_assert (is_implicit_lifetime_type (^^decltype(0.bf16)));\n+#endif\n+static_assert (is_implicit_lifetime_type (^^W));\n+static_assert (is_implicit_lifetime_type (^^const volatile X));\n+static_assert (is_implicit_lifetime_type (^^int *));\n+static_assert (is_implicit_lifetime_type (^^int (*) (int)));\n+static_assert (is_implicit_lifetime_type (^^int (Y::*)));\n+static_assert (is_implicit_lifetime_type (^^int (Y::*) (int)));\n+static_assert (!is_implicit_lifetime_type (^^int &));\n+static_assert (!is_implicit_lifetime_type (^^char &&));\n+static_assert (is_implicit_lifetime_type (^^int []));\n+__extension__ static_assert (!is_implicit_lifetime_type (^^int [0]));\n+static_assert (is_implicit_lifetime_type (^^int [1]));\n+static_assert (is_implicit_lifetime_type (^^const Y [42]));\n+static_assert (!is_implicit_lifetime_type (^^int ()));\n+static_assert (!is_implicit_lifetime_type (^^int () &));\n+static_assert (!is_implicit_lifetime_type (^^int () const));\n+static_assert (!is_implicit_lifetime_type (^^int (&) ()));\n+static_assert (is_implicit_lifetime_type (^^Z []));\n+static_assert (is_implicit_lifetime_type (^^Z [5]));\n+static_assert (is_implicit_lifetime_type (^^A));\n+static_assert (is_implicit_lifetime_type (^^B));\n+static_assert (is_implicit_lifetime_type (^^C));\n+static_assert (is_implicit_lifetime_type (^^D));\n+static_assert (is_implicit_lifetime_type (^^E));\n+static_assert (is_implicit_lifetime_type (^^F));\n+static_assert (is_implicit_lifetime_type (^^G));\n+static_assert (is_implicit_lifetime_type (^^H));\n+static_assert (is_implicit_lifetime_type (^^I));\n+static_assert (is_implicit_lifetime_type (^^J));\n+static_assert (!is_implicit_lifetime_type (^^K));\n+static_assert (!is_implicit_lifetime_type (^^L));\n+static_assert (is_implicit_lifetime_type (^^M));\n+static_assert (is_implicit_lifetime_type (^^N));\n+static_assert (is_implicit_lifetime_type (^^O));\n+static_assert (is_implicit_lifetime_type (^^P));\n+static_assert (!is_implicit_lifetime_type (^^Q));\n+static_assert (is_implicit_lifetime_type (^^R));\n+static_assert (!is_implicit_lifetime_type (^^S));\n+static_assert (is_implicit_lifetime_type (^^S [3]));\n+static_assert (is_implicit_lifetime_type (^^T));\n+static_assert (is_implicit_lifetime_type (^^U));\n+static_assert (is_implicit_lifetime_type (^^V));\n+static_assert (is_implicit_lifetime_type (^^_Complex double));\n+static_assert (is_implicit_lifetime_type (^^int [[gnu::vector_size (4 * sizeof (int))]]));\n+static_assert (is_implicit_lifetime_type (^^AA));\n+static_assert (is_implicit_lifetime_type (^^AB));\n+static_assert (!is_implicit_lifetime_type (^^AC));\n+static_assert (is_implicit_lifetime_type (^^AD));\n+static_assert (is_implicit_lifetime_type (^^AE));\n+static_assert (!is_implicit_lifetime_type (^^AF));\n+\n+void\n+foo (int n)\n+{\n+ __extension__ static_assert (is_implicit_lifetime_type (^^char [n]));\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait13.C b/gcc/testsuite/g++.dg/reflect/type_trait13.C\nnew file mode 100644\nindex 00000000000..cd9f956cc81\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait13.C\n@@ -0,0 +1,425 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], type properties.\n+\n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+class ClassType { };\n+enum EnumType { e0 };\n+struct ThrowCopyConsClass { ThrowCopyConsClass (const ThrowCopyConsClass &) noexcept (false); };\n+struct DeletedCopyAssignClass { DeletedCopyAssignClass & operator= (const DeletedCopyAssignClass &) = delete; };\n+struct DeletedMoveAssignClass { DeletedMoveAssignClass &operator= (DeletedMoveAssignClass &&) = delete; };\n+struct PODType { int i; int j; };\n+union UnionType { };\n+\n+namespace N1\n+{\n+ struct Empty {};\n+ enum class SE { e1 };\n+ struct Abstract { virtual ~Abstract () = 0; };\n+ struct Any { template Any (T &&) {} };\n+ struct nAny { template nAny (T &&...) {} };\n+ struct DelCopy { DelCopy (const DelCopy &) = delete; };\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+}\n+\n+namespace funny1 {\n+ struct F {};\n+ void swap (F &, F &) = delete;\n+ void swap (F (&) [5], F (&) [5]);\n+ struct F2 { friend void swap (F2 &, F2 &) = delete; };\n+ struct F3 { friend void swap (F3 &, F3) {} };\n+ struct DummyCmp { template bool operator () (const T &, const T &) const { return false; } };\n+}\n+\n+namespace funny2 {\n+ struct T0 {};\n+ void swap (T0, T0);\n+ struct T1 {};\n+ struct T2 {};\n+ void swap (T1, T2);\n+ void swap (T2, T1);\n+ struct BoolLike {};\n+ void swap (BoolLike, bool &);\n+ void swap (bool &, BoolLike);\n+ struct F0 {};\n+ void swap (F0, F0) = delete;\n+ struct F1 {};\n+ void swap (F0, F1) = delete;\n+ void swap (F1, F0) = delete;\n+ struct F2 {};\n+ struct F3 {};\n+ void swap (F2, F3);\n+ void swap (F3, F2) = delete;\n+ struct F4 { friend void swap (F4, F4) = delete; };\n+}\n+\n+namespace funny3 {\n+ struct F {};\n+ void swap (F &, F &) = delete;\n+ void swap (F (&) [5], F (&) [5]) noexcept;\n+ void swap (F (&) [6], F (&) [6]);\n+ struct A {};\n+ void swap (A &, A &) noexcept (false);\n+}\n+namespace std {\n+ template <>\n+ void swap (funny3::A &, funny3::A &) noexcept {}\n+ template <>\n+ void swap (funny3::A (&) [3], funny3::A (&) [3]) noexcept (false) {}\n+}\n+namespace ns1 {\n+ struct SwapThrow {};\n+ void swap (SwapThrow &, SwapThrow &);\n+ void swap (SwapThrow (&) [3], SwapThrow (&) [3]) noexcept;\n+}\n+namespace ns2 {\n+ struct SwapThrow {\n+ SwapThrow () noexcept = default;\n+ SwapThrow (const SwapThrow &) noexcept (false);\n+ SwapThrow &operator = (const SwapThrow &) noexcept (false);\n+ };\n+}\n+namespace ns3 {\n+ struct SwapNoThrow {\n+ SwapNoThrow () noexcept = default;\n+ SwapNoThrow (const SwapNoThrow &) noexcept (false);\n+ SwapNoThrow &operator = (const SwapNoThrow &) noexcept (false);\n+ };\n+ void swap (SwapNoThrow &, SwapNoThrow &) noexcept;\n+}\n+namespace ns4 {\n+ struct SwapNoThrow {};\n+}\n+namespace ns5 {\n+ struct SwapThrow {\n+ SwapThrow () noexcept = default;\n+ SwapThrow (SwapThrow &&) noexcept;\n+ SwapThrow & operator = (const SwapThrow &) noexcept (false);\n+ };\n+}\n+namespace comps {\n+ struct CompareNoThrowCopyable {\n+ template \n+ bool operator () (const T &, const T &) const { return false; }\n+ };\n+ struct CompareNonCopyable {\n+ CompareNonCopyable () = default;\n+ CompareNonCopyable (const CompareNonCopyable &) = delete;\n+ CompareNonCopyable &operator= (const CompareNonCopyable &) noexcept;\n+ template \n+ bool operator () (const T &, const T &) const { return false; }\n+ };\n+ struct CompareThrowCopyable {\n+ CompareThrowCopyable () = default;\n+ CompareThrowCopyable (const CompareThrowCopyable &) noexcept (false);\n+ CompareThrowCopyable &operator = (const CompareThrowCopyable &);\n+ template \n+ bool operator () (const T &, const T &) const { return false; }\n+ };\n+}\n+\n+namespace funny4 {\n+ struct T0 {};\n+ void swap (T0, T0) noexcept;\n+ struct T1 { friend void swap (T1, T1) noexcept; };\n+ struct T2 {};\n+ struct T3 {};\n+ void swap (T2, T3) noexcept;\n+ void swap (T3, T2) noexcept;\n+ struct T4 { operator T0 () const noexcept; };\n+ struct F0 {};\n+ void swap (F0, F0) = delete;\n+ struct F1 {};\n+ void swap (F1, F1);\n+ struct F2 {};\n+ void swap (F0, F2) noexcept;\n+ void swap (F2, F0);\n+ struct F3 { friend void swap (F3, F3) = delete; };\n+ struct F4 { friend void swap (F4, F4); };\n+ struct F5 { operator T0 () const; };\n+ struct BoolLike {};\n+ void swap (BoolLike, bool &) noexcept;\n+ void swap (bool &, BoolLike) noexcept;\n+ struct BoolLikeErr {};\n+ void swap (BoolLikeErr, bool &);\n+ void swap (bool &, BoolLikeErr) noexcept;\n+}\n+\n+static_assert (is_swappable_type (^^int));\n+static_assert (is_swappable_type (^^bool));\n+static_assert (is_swappable_type (^^decltype (nullptr)));\n+static_assert (is_swappable_type (^^int &));\n+static_assert (is_swappable_type (^^int &&));\n+static_assert (is_swappable_type (^^int [1]));\n+static_assert (is_swappable_type (^^int [1][2]));\n+static_assert (is_swappable_type (^^int [1][2][3]));\n+static_assert (is_swappable_type (^^int (&) [1]));\n+static_assert (is_swappable_type (^^funny1::F [5]));\n+static_assert (is_swappable_type (^^funny1::F3));\n+static_assert (is_swappable_type (^^funny1::F3 [1]));\n+static_assert (is_swappable_type (^^funny1::F3 [1][2]));\n+static_assert (is_swappable_type (^^funny1::F3 [1][2][3]));\n+static_assert (is_swappable_type (^^ThrowCopyConsClass));\n+static_assert (is_swappable_type (^^EnumType));\n+static_assert (is_swappable_type (^^PODType));\n+static_assert (is_swappable_type (^^UnionType));\n+static_assert (is_swappable_type (^^N1::SE));\n+static_assert (is_swappable_type (^^N1::Empty));\n+static_assert (is_swappable_type (^^void *));\n+static_assert (is_swappable_type (^^int const *));\n+static_assert (is_swappable_type (^^ClassType *));\n+static_assert (is_swappable_type (^^int ClassType::*));\n+static_assert (is_swappable_type (^^void (ClassType::*) ()));\n+static_assert (is_swappable_type (^^N1::Nontrivial));\n+static_assert (is_swappable_type (^^N1::Any));\n+static_assert (is_swappable_type (^^N1::nAny));\n+static_assert (is_swappable_type (^^std::pair ));\n+static_assert (is_swappable_type (^^std::pair [1]));\n+static_assert (is_swappable_type (^^std::pair [1][2]));\n+static_assert (is_swappable_type (^^std::pair [1][2][3]));\n+static_assert (is_swappable_type (^^std::pair ));\n+static_assert (is_swappable_type (^^std::tuple ));\n+static_assert (is_swappable_type (^^std::tuple [1]));\n+static_assert (is_swappable_type (^^std::tuple [1][2]));\n+static_assert (is_swappable_type (^^std::tuple [1][2][3]));\n+static_assert (is_swappable_type (^^std::tuple <>));\n+static_assert (is_swappable_type (^^std::tuple <> [1]));\n+static_assert (is_swappable_type (^^std::tuple <> [1][2]));\n+static_assert (is_swappable_type (^^std::tuple <> [1][2][3]));\n+static_assert (is_swappable_type (^^std::tuple ));\n+static_assert (is_swappable_type (^^std::array ));\n+static_assert (is_swappable_type (^^std::array [1]));\n+static_assert (is_swappable_type (^^std::array [1][2]));\n+static_assert (is_swappable_type (^^std::array [1][2][3]));\n+static_assert (is_swappable_type (^^std::array ));\n+static_assert (is_swappable_type (^^std::array ));\n+static_assert (is_swappable_type (^^std::array ));\n+static_assert (is_swappable_type (^^std::queue ));\n+static_assert (is_swappable_type (^^std::queue [1]));\n+static_assert (is_swappable_type (^^std::queue [1][2]));\n+static_assert (is_swappable_type (^^std::queue [1][2][3]));\n+static_assert (is_swappable_type (^^std::queue ));\n+//static_assert (is_swappable_type (^^std::priority_queue ));\n+//static_assert (is_swappable_type (^^std::priority_queue [1]));\n+//static_assert (is_swappable_type (^^std::priority_queue [1][2]));\n+//static_assert (is_swappable_type (^^std::priority_queue [1][2][3]));\n+//static_assert (is_swappable_type (^^std::priority_queue , funny1::DummyCmp>));\n+static_assert (is_swappable_type (^^std::stack ));\n+static_assert (is_swappable_type (^^std::stack [1]));\n+static_assert (is_swappable_type (^^std::stack [1][2]));\n+static_assert (is_swappable_type (^^std::stack [1][2][3]));\n+static_assert (is_swappable_type (^^std::stack ));\n+static_assert (!is_swappable_type (^^void));\n+static_assert (!is_swappable_type (^^const void));\n+static_assert (!is_swappable_type (^^void ()));\n+static_assert (!is_swappable_type (^^void () const));\n+static_assert (!is_swappable_type (^^void () volatile));\n+static_assert (!is_swappable_type (^^void () const volatile));\n+static_assert (!is_swappable_type (^^const int));\n+static_assert (!is_swappable_type (^^const bool));\n+static_assert (!is_swappable_type (^^int []));\n+static_assert (!is_swappable_type (^^const int []));\n+static_assert (!is_swappable_type (^^int [][1]));\n+static_assert (!is_swappable_type (^^const int [1]));\n+static_assert (!is_swappable_type (^^const int [1][2]));\n+static_assert (!is_swappable_type (^^const int [1][2][3]));\n+static_assert (!is_swappable_type (^^N1::DelCopy));\n+static_assert (!is_swappable_type (^^N1::Abstract));\n+static_assert (!is_swappable_type (^^N1::NontrivialUnion));\n+static_assert (!is_swappable_type (^^funny1::F));\n+static_assert (!is_swappable_type (^^funny1::F [1]));\n+static_assert (!is_swappable_type (^^funny1::F [1][2]));\n+static_assert (!is_swappable_type (^^funny1::F [1][2][3]));\n+static_assert (!is_swappable_type (^^funny1::F [4]));\n+static_assert (!is_swappable_type (^^N1::DelCopy));\n+static_assert (!is_swappable_type (^^DeletedCopyAssignClass));\n+static_assert (!is_swappable_type (^^DeletedMoveAssignClass));\n+static_assert (!is_swappable_type (^^funny1::F2));\n+static_assert (!is_swappable_type (^^funny1::F2 [1]));\n+static_assert (!is_swappable_type (^^funny1::F2 [1][2]));\n+static_assert (!is_swappable_type (^^funny1::F2 [1][2][3]));\n+static_assert (!is_swappable_type (^^funny1::F2 [4]));\n+static_assert (!is_swappable_type (^^funny1::F2 [5]));\n+\n+static_assert (is_swappable_with_type (^^int &, ^^int &));\n+static_assert (is_swappable_with_type (^^funny2::T0, ^^funny2::T0));\n+static_assert (is_swappable_with_type (^^funny2::T0, ^^const funny2::T0));\n+static_assert (is_swappable_with_type (^^funny2::T1, ^^funny2::T2));\n+static_assert (is_swappable_with_type (^^funny2::T2, ^^funny2::T1));\n+static_assert (is_swappable_with_type (^^funny2::BoolLike, ^^bool &));\n+static_assert (is_swappable_with_type (^^const funny2::BoolLike, ^^bool &));\n+static_assert (!is_swappable_with_type (^^int, ^^int));\n+static_assert (!is_swappable_with_type (^^int &, ^^unsigned &));\n+static_assert (!is_swappable_with_type (^^const int &, ^^const int &));\n+static_assert (!is_swappable_with_type (^^funny2::F0, ^^funny2::F0));\n+static_assert (!is_swappable_with_type (^^funny2::F0, ^^const funny2::F0));\n+static_assert (!is_swappable_with_type (^^funny2::T0, ^^funny2::T1));\n+static_assert (!is_swappable_with_type (^^funny2::F0, ^^funny2::F1));\n+static_assert (!is_swappable_with_type (^^funny2::F0, ^^const funny2::F1));\n+static_assert (!is_swappable_with_type (^^const funny2::F0, ^^funny2::F1));\n+static_assert (!is_swappable_with_type (^^funny2::F2, ^^funny2::F3));\n+static_assert (!is_swappable_with_type (^^funny2::F2, ^^const funny2::F3));\n+static_assert (!is_swappable_with_type (^^const funny2::F2, ^^funny2::F3));\n+static_assert (!is_swappable_with_type (^^funny2::F4, ^^funny2::F4));\n+static_assert (!is_swappable_with_type (^^funny2::BoolLike, ^^funny2::BoolLike));\n+\n+static_assert (is_nothrow_swappable_type (^^int));\n+static_assert (is_nothrow_swappable_type (^^bool));\n+static_assert (is_nothrow_swappable_type (^^decltype (nullptr)));\n+static_assert (is_nothrow_swappable_type (^^int &));\n+static_assert (is_nothrow_swappable_type (^^int &&));\n+static_assert (is_nothrow_swappable_type (^^int [1]));\n+static_assert (is_nothrow_swappable_type (^^int [1][2]));\n+static_assert (is_nothrow_swappable_type (^^int [1][2][3]));\n+static_assert (is_nothrow_swappable_type (^^funny3::F [5]));\n+static_assert (is_nothrow_swappable_type (^^EnumType));\n+static_assert (is_nothrow_swappable_type (^^PODType));\n+static_assert (is_nothrow_swappable_type (^^UnionType));\n+static_assert (is_nothrow_swappable_type (^^N1::SE));\n+static_assert (is_nothrow_swappable_type (^^N1::Empty));\n+static_assert (is_nothrow_swappable_type (^^void *));\n+static_assert (is_nothrow_swappable_type (^^void (*) ()));\n+static_assert (is_nothrow_swappable_type (^^int const *));\n+static_assert (is_nothrow_swappable_type (^^ClassType *));\n+static_assert (is_nothrow_swappable_type (^^int ClassType::*));\n+static_assert (is_nothrow_swappable_type (^^void (ClassType::*) ()));\n+static_assert (is_nothrow_swappable_type (^^int (ClassType::*) () const volatile));\n+static_assert (is_nothrow_swappable_type (^^ns1::SwapThrow [3]));\n+static_assert (is_nothrow_swappable_type (^^ns3::SwapNoThrow));\n+static_assert (is_nothrow_swappable_type (^^ns3::SwapNoThrow [1]));\n+static_assert (is_nothrow_swappable_type (^^ns3::SwapNoThrow [3]));\n+static_assert (is_nothrow_swappable_type (^^ns3::SwapNoThrow [2][3][4]));\n+static_assert (is_nothrow_swappable_type (^^ns4::SwapNoThrow));\n+static_assert (is_nothrow_swappable_type (^^ns4::SwapNoThrow [1]));\n+static_assert (is_nothrow_swappable_type (^^ns4::SwapNoThrow [3]));\n+static_assert (is_nothrow_swappable_type (^^ns4::SwapNoThrow [2][3][4]));\n+static_assert (is_nothrow_swappable_type (^^std::pair ));\n+static_assert (is_nothrow_swappable_type (^^std::pair [1]));\n+static_assert (is_nothrow_swappable_type (^^std::pair [1][2]));\n+static_assert (is_nothrow_swappable_type (^^std::tuple ));\n+static_assert (is_nothrow_swappable_type (^^std::tuple [1]));\n+static_assert (is_nothrow_swappable_type (^^std::tuple [1][2]));\n+static_assert (is_nothrow_swappable_type (^^std::tuple <>));\n+static_assert (is_nothrow_swappable_type (^^std::tuple <> [1]));\n+static_assert (is_nothrow_swappable_type (^^std::tuple <> [1][2]));\n+static_assert (is_nothrow_swappable_type (^^std::array ));\n+static_assert (is_nothrow_swappable_type (^^std::array ));\n+static_assert (is_nothrow_swappable_type (^^std::array ));\n+static_assert (is_nothrow_swappable_type (^^std::array ));\n+static_assert (is_nothrow_swappable_type (^^std::queue ));\n+//static_assert (is_nothrow_swappable_type (^^std::priority_queue ));\n+static_assert (is_nothrow_swappable_type (^^std::stack ));\n+//static_assert (is_nothrow_swappable_type (^^std::priority_queue , comps::CompareNoThrowCopyable>));\n+static_assert (!is_nothrow_swappable_type (^^void));\n+static_assert (!is_nothrow_swappable_type (^^const void));\n+static_assert (!is_nothrow_swappable_type (^^void ()));\n+static_assert (!is_nothrow_swappable_type (^^void () const));\n+static_assert (!is_nothrow_swappable_type (^^void () volatile));\n+static_assert (!is_nothrow_swappable_type (^^void () const volatile));\n+static_assert (!is_nothrow_swappable_type (^^const int));\n+static_assert (!is_nothrow_swappable_type (^^const bool));\n+static_assert (!is_nothrow_swappable_type (^^const int [1]));\n+static_assert (!is_nothrow_swappable_type (^^const int [1][2]));\n+static_assert (!is_nothrow_swappable_type (^^const int [1][2][3]));\n+static_assert (!is_nothrow_swappable_type (^^int []));\n+static_assert (!is_nothrow_swappable_type (^^const int []));\n+static_assert (!is_nothrow_swappable_type (^^int [][1]));\n+static_assert (!is_nothrow_swappable_type (^^const funny3::F [5]));\n+static_assert (!is_nothrow_swappable_type (^^N1::Abstract));\n+static_assert (!is_nothrow_swappable_type (^^N1::DelCopy));\n+static_assert (!is_nothrow_swappable_type (^^funny3::F));\n+static_assert (!is_nothrow_swappable_type (^^funny3::F [1]));\n+static_assert (!is_nothrow_swappable_type (^^funny3::F [1][2]));\n+static_assert (!is_nothrow_swappable_type (^^funny3::F [1][2][3]));\n+static_assert (!is_nothrow_swappable_type (^^funny3::F [6]));\n+static_assert (!is_nothrow_swappable_type (^^funny3::A));\n+static_assert (!is_nothrow_swappable_type (^^funny3::A [3]));\n+static_assert (!is_nothrow_swappable_type (^^ns1::SwapThrow));\n+static_assert (!is_nothrow_swappable_type (^^ns1::SwapThrow [1]));\n+static_assert (!is_nothrow_swappable_type (^^ns1::SwapThrow [3][2]));\n+static_assert (!is_nothrow_swappable_type (^^ns1::SwapThrow [2][3][4]));\n+static_assert (!is_nothrow_swappable_type (^^ns2::SwapThrow));\n+static_assert (!is_nothrow_swappable_type (^^ns2::SwapThrow [1]));\n+static_assert (!is_nothrow_swappable_type (^^ns2::SwapThrow [2][3][4]));\n+static_assert (!is_nothrow_swappable_type (^^ns5::SwapThrow));\n+static_assert (!is_nothrow_swappable_type (^^ns5::SwapThrow [1]));\n+static_assert (!is_nothrow_swappable_type (^^ns5::SwapThrow [2][3][4]));\n+static_assert (!is_nothrow_swappable_type (^^ThrowCopyConsClass));\n+static_assert (!is_nothrow_swappable_type (^^std::pair ));\n+static_assert (!is_nothrow_swappable_type (^^std::tuple ));\n+static_assert (!is_nothrow_swappable_type (^^std::array ));\n+static_assert (is_nothrow_swappable_type (^^std::queue ));\n+static_assert (is_nothrow_swappable_type (^^std::priority_queue , comps::CompareNoThrowCopyable>));\n+static_assert (is_nothrow_swappable_type (^^std::stack ));\n+static_assert (!is_nothrow_swappable_type (^^std::priority_queue , comps::CompareNonCopyable>));\n+static_assert (!is_nothrow_swappable_type (^^std::priority_queue , comps::CompareThrowCopyable>));\n+\n+static_assert (is_nothrow_swappable_with_type (^^int &, ^^int &));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::T0, ^^funny4::T0));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::T0, ^^const funny4::T0));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::T1, ^^funny4::T1));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::T1, ^^const funny4::T1));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::T2, ^^funny4::T3));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::T3, ^^funny4::T2));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::T0, ^^funny4::T4));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::T4, ^^funny4::T0));\n+static_assert (is_nothrow_swappable_with_type (^^funny4::BoolLike, ^^bool &));\n+static_assert (is_nothrow_swappable_with_type (^^const funny4::BoolLike, ^^bool &));\n+static_assert (!is_nothrow_swappable_with_type (^^const int &, ^^const int &));\n+static_assert (!is_nothrow_swappable_with_type (^^int &, ^^unsigned &));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F0, ^^funny4::F0));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F0, ^^const funny4::F0));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F1, ^^funny4::F1));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F1, ^^const funny4::F1));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F0, ^^funny4::F2));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F2, ^^funny4::F0));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F3, ^^funny4::F3));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F3, ^^const funny4::F3));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F4, ^^funny4::F4));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F4, ^^const funny4::F4));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::T0, ^^funny4::F5));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::F5, ^^funny4::T0));\n+static_assert (!is_nothrow_swappable_with_type (^^funny4::BoolLikeErr, ^^bool &));\n+static_assert (!is_nothrow_swappable_with_type (^^const funny4::BoolLikeErr, ^^bool &));\n+\n+static_assert (unwrap_reference (^^int) == ^^int);\n+static_assert (unwrap_reference (^^const int) == ^^const int);\n+static_assert (unwrap_reference (^^const int &) == ^^const int &);\n+static_assert (unwrap_reference (^^const int *) == ^^const int *);\n+static_assert (unwrap_reference (^^const int *&) == ^^const int *&);\n+static_assert (unwrap_reference (^^std::reference_wrapper ) == ^^int &);\n+static_assert (unwrap_reference (^^std::reference_wrapper ) == ^^const int &);\n+static_assert (unwrap_reference (^^std::reference_wrapper ) == ^^long &);\n+static_assert (unwrap_reference (^^const std::reference_wrapper ) == ^^const std::reference_wrapper );\n+static_assert (unwrap_reference (^^volatile std::reference_wrapper ) == ^^volatile std::reference_wrapper );\n+static_assert (unwrap_reference (^^const volatile std::reference_wrapper ) == ^^const volatile std::reference_wrapper );\n+static_assert (unwrap_reference (^^std::reference_wrapper &) == ^^std::reference_wrapper &);\n+static_assert (unwrap_reference (^^std::reference_wrapper &&) == ^^std::reference_wrapper &&);\n+static_assert (unwrap_reference (^^const std::reference_wrapper &) == ^^const std::reference_wrapper &);\n+\n+static_assert (unwrap_ref_decay (^^int) == decay (^^int));\n+static_assert (unwrap_ref_decay (^^const int) == decay (^^const int));\n+static_assert (unwrap_ref_decay (^^const int &) == decay (^^const int &));\n+static_assert (unwrap_ref_decay (^^const int *) == decay (^^const int *));\n+static_assert (unwrap_ref_decay (^^const int *&) == decay (^^const int *&));\n+static_assert (unwrap_ref_decay (^^std::reference_wrapper ) == ^^int &);\n+static_assert (unwrap_ref_decay (^^std::reference_wrapper &) == ^^int &);\n+static_assert (unwrap_ref_decay (^^const std::reference_wrapper ) == ^^int &);\n+static_assert (unwrap_ref_decay (^^const std::reference_wrapper &) == ^^int &);\n+static_assert (unwrap_ref_decay (^^std::reference_wrapper ) == ^^const int &);\n+static_assert (unwrap_ref_decay (^^std::reference_wrapper &) == ^^const int &);\n+static_assert (unwrap_ref_decay (^^std::reference_wrapper ) == ^^long &);\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait2.C b/gcc/testsuite/g++.dg/reflect/type_trait2.C\nnew file mode 100644\nindex 00000000000..3bf87ad2b8a\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait2.C\n@@ -0,0 +1,92 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], const-volatile\n+// modifications.\n+\n+#include \n+using namespace std::meta;\n+\n+struct C { };\n+\n+static_assert (remove_const (^^const int) == ^^int);\n+static_assert (remove_const (^^volatile int) == ^^volatile int);\n+static_assert (remove_const (^^const volatile int) == ^^volatile int);\n+static_assert (remove_const (^^const volatile int *) == ^^const volatile int *);\n+static_assert (remove_const (^^const volatile int &) == ^^const volatile int &);\n+static_assert (remove_const (^^const volatile int []) == ^^volatile int []);\n+static_assert (remove_const (^^volatile int *const) == ^^volatile int *);\n+static_assert (remove_const (^^const volatile C) == ^^volatile C);\n+static_assert (remove_const (^^void (C::* const volatile)(int) const) == ^^void (C::* volatile)(int) const);\n+static_assert (remove_const (^^int (int)) == ^^int (int));\n+using T1 = int;\n+static_assert (remove_const (^^T1) == dealias (^^T1));\n+\n+static_assert (remove_volatile (^^const int) == ^^const int);\n+static_assert (remove_volatile (^^volatile int) == ^^int);\n+static_assert (remove_volatile (^^const volatile int) == ^^const int);\n+static_assert (remove_volatile (^^const volatile int *) == ^^const volatile int *);\n+static_assert (remove_volatile (^^const volatile int &) == ^^const volatile int &);\n+static_assert (remove_volatile (^^const volatile int []) == ^^const int []);\n+static_assert (remove_volatile (^^volatile int *const) == ^^volatile int *const);\n+static_assert (remove_volatile (^^volatile int *volatile) == ^^volatile int *);\n+static_assert (remove_volatile (^^const volatile C) == ^^const C);\n+static_assert (remove_volatile (^^void (C::* const volatile)(int) const) == ^^void (C::* const)(int) const);\n+static_assert (remove_volatile (^^int (int)) == ^^int (int));\n+static_assert (remove_volatile (^^T1) == dealias (^^T1));\n+\n+static_assert (remove_cv (^^const int) == ^^int);\n+static_assert (remove_cv (^^volatile int) == ^^int);\n+static_assert (remove_cv (^^const volatile int) == ^^int);\n+static_assert (remove_cv (^^const volatile int *) == ^^const volatile int *);\n+static_assert (remove_cv (^^const volatile int &) == ^^const volatile int &);\n+static_assert (remove_cv (^^const volatile int []) == ^^int []);\n+static_assert (remove_cv (^^volatile int *const) == ^^volatile int *);\n+static_assert (remove_cv (^^const volatile C) == ^^C);\n+static_assert (remove_cv (^^void (C::* const volatile)(int) const) == ^^void (C::*)(int) const);\n+static_assert (remove_cv (^^int (int)) == ^^int (int));\n+static_assert (remove_cv (^^T1) == dealias (^^T1));\n+\n+static_assert (add_const (^^int) == ^^const int);\n+static_assert (add_const (^^const int) == ^^const int);\n+static_assert (add_const (^^volatile int) == ^^const volatile int);\n+static_assert (add_const (^^const volatile int) == ^^const volatile int);\n+static_assert (add_const (^^const volatile int *) == ^^const volatile int *const);\n+static_assert (add_const (^^int []) == ^^const int[]);\n+static_assert (add_const (^^int *) == ^^int *const);\n+static_assert (add_const (^^C) == ^^const C);\n+static_assert (add_const (^^void (C::*)(int) const) == ^^void (C::* const)(int) const);\n+static_assert (add_const (^^int (int)) == ^^int (int));\n+static_assert (add_const (^^int &) == ^^int &);\n+static_assert (add_const (^^const int &&) == ^^const int &&);\n+using T2 = const int;\n+static_assert (add_const (^^T2) == dealias (^^T2));\n+\n+static_assert (add_volatile (^^int) == ^^volatile int);\n+static_assert (add_volatile (^^const int) == ^^const volatile int);\n+static_assert (add_volatile (^^volatile int) == ^^volatile int);\n+static_assert (add_volatile (^^const volatile int) == ^^const volatile int);\n+static_assert (add_volatile (^^const volatile int *) == ^^const volatile int *volatile);\n+static_assert (add_volatile (^^int []) == ^^volatile int[]);\n+static_assert (add_volatile (^^int *) == ^^int *volatile);\n+static_assert (add_volatile (^^C) == ^^volatile C);\n+static_assert (add_volatile (^^void (C::*)(int) const) == ^^void (C::* volatile)(int) const);\n+static_assert (add_volatile (^^int (int)) == ^^int (int));\n+static_assert (add_volatile (^^int &) == ^^int &);\n+static_assert (add_volatile (^^const int &&) == ^^const int &&);\n+using T3 = volatile int;\n+static_assert (add_volatile (^^T3) == dealias (^^T3));\n+\n+static_assert (add_cv (^^int) == ^^const volatile int);\n+static_assert (add_cv (^^const int) == ^^const volatile int);\n+static_assert (add_cv (^^volatile int) == ^^const volatile int);\n+static_assert (add_cv (^^const volatile int) == ^^const volatile int);\n+static_assert (add_cv (^^const volatile int *) == ^^const volatile int *const volatile);\n+static_assert (add_cv (^^int []) == ^^const volatile int[]);\n+static_assert (add_cv (^^int *) == ^^int *const volatile);\n+static_assert (add_cv (^^C) == ^^const volatile C);\n+static_assert (add_cv (^^void (C::*)(int) const) == ^^void (C::* const volatile)(int) const);\n+static_assert (add_cv (^^int (int)) == ^^int (int));\n+static_assert (add_cv (^^int &) == ^^int &);\n+static_assert (add_cv (^^const int &&) == ^^const int &&);\n+using T4 = const volatile int;\n+static_assert (add_cv (^^T4) == dealias (^^T4));\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait3.C b/gcc/testsuite/g++.dg/reflect/type_trait3.C\nnew file mode 100644\nindex 00000000000..eca95ad04ec\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait3.C\n@@ -0,0 +1,218 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], reference, sign,\n+// array and pointer modifications.\n+\n+#include \n+using namespace std::meta;\n+\n+struct C { };\n+enum E1 : int { E10, E11 };\n+enum E2 : unsigned char { E20, E21 };\n+enum E3 : short int { E30, E31 };\n+enum E4 : long long { E40, E41 };\n+\n+static_assert (remove_reference (^^int) == ^^int);\n+static_assert (remove_reference (^^const int *) == ^^const int *);\n+static_assert (remove_reference (^^unsigned long &) == ^^unsigned long);\n+static_assert (remove_reference (^^const short &) == ^^const short);\n+static_assert (remove_reference (^^long long &&) == ^^long long);\n+static_assert (remove_reference (^^volatile char &&) == ^^volatile char);\n+static_assert (remove_reference (^^int *&) == ^^int *);\n+static_assert (remove_reference (^^C &) == ^^C);\n+static_assert (remove_reference (^^C &&) == ^^C);\n+static_assert (remove_reference (^^C) == ^^C);\n+static_assert (remove_reference (^^int (&) (int)) == ^^int (int));\n+static_assert (remove_reference (^^int (&&) (int)) == ^^int (int));\n+static_assert (remove_reference (^^int (int)) == ^^int (int));\n+using T1 = int;\n+static_assert (remove_reference (^^T1) == dealias (^^T1));\n+\n+static_assert (add_lvalue_reference (^^int) == ^^int &);\n+static_assert (add_lvalue_reference (^^int &) == ^^int &);\n+static_assert (add_lvalue_reference (^^const int) == ^^const int &);\n+static_assert (add_lvalue_reference (^^int *) == ^^int *&);\n+static_assert (add_lvalue_reference (^^C &) == ^^C &);\n+static_assert (add_lvalue_reference (^^C) == ^^C &);\n+static_assert (add_lvalue_reference (^^int (int)) == ^^int (&) (int));\n+static_assert (add_lvalue_reference (^^int &&) == ^^int &);\n+static_assert (add_lvalue_reference (^^C &&) == ^^C &);\n+static_assert (add_lvalue_reference (^^void) == ^^void);\n+static_assert (add_lvalue_reference (^^const void) == ^^const void);\n+static_assert (add_lvalue_reference (^^bool (int) const) == ^^bool (int) const);\n+static_assert (add_lvalue_reference (^^bool (int) &) == ^^bool (int) &);\n+static_assert (add_lvalue_reference (^^bool (int) const &&) == ^^bool (int) const &&);\n+static_assert (add_lvalue_reference (^^bool (int)) == ^^bool (&) (int));\n+using T2 = int &;\n+static_assert (add_lvalue_reference (^^T2) == dealias (^^T2));\n+\n+static_assert (add_rvalue_reference (^^int) == ^^int &&);\n+static_assert (add_rvalue_reference (^^int &&) == ^^int &&);\n+static_assert (add_rvalue_reference (^^int &) == ^^int &);\n+static_assert (add_rvalue_reference (^^const int) == ^^const int &&);\n+static_assert (add_rvalue_reference (^^int *) == ^^int *&&);\n+static_assert (add_rvalue_reference (^^C &&) == ^^C &&);\n+static_assert (add_rvalue_reference (^^C) == ^^C &&);\n+static_assert (add_rvalue_reference (^^int (int)) == ^^int (&&) (int));\n+static_assert (add_rvalue_reference (^^void) == ^^void);\n+static_assert (add_rvalue_reference (^^const void) == ^^const void);\n+static_assert (add_rvalue_reference (^^bool (int) const) == ^^bool (int) const);\n+static_assert (add_rvalue_reference (^^bool (int) &) == ^^bool (int) &);\n+static_assert (add_rvalue_reference (^^bool (int) const &&) == ^^bool (int) const &&);\n+static_assert (add_rvalue_reference (^^bool (int)) == ^^bool (&&) (int));\n+using T3 = int &&;\n+static_assert (add_rvalue_reference (^^T3) == dealias (^^T3));\n+\n+static_assert (make_signed (^^const char) == ^^const signed char);\n+static_assert (make_signed (^^volatile signed char) == ^^volatile signed char);\n+static_assert (make_signed (^^unsigned char) == ^^signed char);\n+static_assert (make_signed (^^const signed short) == ^^const short);\n+static_assert (make_signed (^^volatile unsigned short) == ^^volatile signed short);\n+static_assert (make_signed (^^int) == ^^signed int);\n+static_assert (make_signed (^^const unsigned int) == ^^const int);\n+static_assert (make_signed (^^volatile long) == ^^volatile signed long);\n+static_assert (make_signed (^^unsigned long) == ^^long);\n+static_assert (make_signed (^^const signed long long) == ^^const long long);\n+static_assert (make_signed (^^volatile long long unsigned) == ^^volatile long long);\n+#if __SIZEOF_SHORT__ > 1 && __SIZEOF_SHORT__ < __SIZEOF_INT__ \\\n+ && __SIZEOF_INT__ < __SIZEOF_LONG_LONG__\n+static_assert (make_signed (^^const E1) == ^^const int);\n+static_assert (make_signed (^^volatile E2) == ^^volatile signed char);\n+static_assert (make_signed (^^E3) == ^^short);\n+#if __SIZEOF_LONG__ < __SIZEOF_LONG_LONG__\n+static_assert (make_signed (^^const volatile E4) == ^^const volatile long long);\n+#else\n+static_assert (make_signed (^^const volatile E4) == ^^const volatile long);\n+#endif\n+static_assert (make_signed (^^volatile char8_t) == ^^volatile signed char);\n+static_assert (sizeof (char16_t) != sizeof (short) || make_signed (^^char16_t) == ^^signed short);\n+static_assert (sizeof (char32_t) != sizeof (int) || make_signed (^^const volatile char32_t) == ^^const volatile int);\n+static_assert (sizeof (wchar_t) != sizeof (short) || make_signed (^^wchar_t) == ^^short);\n+static_assert (sizeof (wchar_t) != sizeof (int) || make_signed (^^wchar_t) == ^^signed int);\n+#endif\n+static_assert (make_signed (^^T1) == ^^int);\n+\n+static_assert (make_unsigned (^^const char) == ^^const unsigned char);\n+static_assert (make_unsigned (^^volatile signed char) == ^^volatile unsigned char);\n+static_assert (make_unsigned (^^unsigned char) == ^^unsigned char);\n+static_assert (make_unsigned (^^const signed short) == ^^const unsigned short);\n+static_assert (make_unsigned (^^volatile unsigned short) == ^^volatile unsigned short);\n+static_assert (make_unsigned (^^int) == ^^unsigned int);\n+static_assert (make_unsigned (^^const unsigned int) == ^^const unsigned);\n+static_assert (make_unsigned (^^volatile long) == ^^volatile unsigned long);\n+static_assert (make_unsigned (^^unsigned long) == ^^unsigned long);\n+static_assert (make_unsigned (^^const signed long long) == ^^const unsigned long long);\n+static_assert (make_unsigned (^^volatile long long unsigned) == ^^volatile unsigned long long);\n+#if __SIZEOF_SHORT__ > 1 && __SIZEOF_SHORT__ < __SIZEOF_INT__ \\\n+ && __SIZEOF_INT__ < __SIZEOF_LONG_LONG__\n+static_assert (make_unsigned (^^const E1) == ^^const unsigned int);\n+static_assert (make_unsigned (^^volatile E2) == ^^volatile unsigned char);\n+static_assert (make_unsigned (^^E3) == ^^unsigned short);\n+#if __SIZEOF_LONG__ < __SIZEOF_LONG_LONG__\n+static_assert (make_unsigned (^^const volatile E4) == ^^const volatile unsigned long long);\n+#else\n+static_assert (make_unsigned (^^const volatile E4) == ^^const volatile long unsigned);\n+#endif\n+static_assert (make_unsigned (^^volatile char8_t) == ^^volatile unsigned char);\n+static_assert (sizeof (char16_t) != sizeof (short) || make_unsigned (^^char16_t) == ^^unsigned short);\n+static_assert (sizeof (char32_t) != sizeof (int) || make_unsigned (^^const volatile char32_t) == ^^const volatile unsigned);\n+static_assert (sizeof (wchar_t) != sizeof (short) || make_unsigned (^^wchar_t) == ^^unsigned short);\n+static_assert (sizeof (wchar_t) != sizeof (int) || make_unsigned (^^wchar_t) == ^^unsigned int);\n+#endif\n+using T4 = unsigned;\n+static_assert (make_unsigned (^^T4) == ^^unsigned);\n+\n+static_assert (remove_extent (^^int) == ^^int);\n+static_assert (remove_extent (^^int[2]) == ^^int);\n+static_assert (remove_extent (^^int[2][3]) == ^^int[3]);\n+static_assert (remove_extent (^^int[][3]) == ^^int[3]);\n+static_assert (remove_extent (^^const int[2]) == ^^const int);\n+static_assert (remove_extent (^^C) == ^^C);\n+static_assert (remove_extent (^^C[2]) == ^^C);\n+static_assert (remove_extent (^^C[2][3]) == ^^C[3]);\n+static_assert (remove_extent (^^C[][3]) == ^^C[3]);\n+static_assert (remove_extent (^^const C[2]) == ^^const C);\n+static_assert (remove_extent (^^T1) == ^^int);\n+\n+static_assert (remove_all_extents (^^int) == ^^int);\n+static_assert (remove_all_extents (^^int[2]) == ^^int);\n+static_assert (remove_all_extents (^^int[2][3]) == ^^int);\n+static_assert (remove_all_extents (^^int[][3]) == ^^int);\n+static_assert (remove_all_extents (^^const int[2][3]) == ^^const int);\n+static_assert (remove_all_extents (^^C) == ^^C);\n+static_assert (remove_all_extents (^^C[2]) == ^^C);\n+static_assert (remove_all_extents (^^C[2][3]) == ^^C);\n+static_assert (remove_all_extents (^^C[][3]) == ^^C);\n+static_assert (remove_all_extents (^^const C[2][3]) == ^^const C);\n+static_assert (remove_all_extents (^^T1) == ^^int);\n+\n+static_assert (remove_pointer (^^int *) == ^^int);\n+static_assert (remove_pointer (^^int) == ^^int);\n+static_assert (remove_pointer (^^const int *) == ^^const int);\n+static_assert (remove_pointer (^^int **) == ^^int *);\n+static_assert (remove_pointer (^^C *) == ^^C);\n+static_assert (remove_pointer (^^C) == ^^C);\n+static_assert (remove_pointer (^^T1) == ^^int);\n+\n+static_assert (add_pointer (^^int) == ^^int *);\n+static_assert (add_pointer (^^int *) == ^^int **);\n+static_assert (add_pointer (^^const int) == ^^const int *);\n+static_assert (add_pointer (^^int &) == ^^int *);\n+static_assert (add_pointer (^^C *) == ^^C **);\n+static_assert (add_pointer (^^C) == ^^C *);\n+static_assert (add_pointer (^^void) == ^^void *);\n+static_assert (add_pointer (^^const void) == ^^const void *);\n+static_assert (add_pointer (^^volatile void) == ^^volatile void *);\n+static_assert (add_pointer (^^const volatile void) == ^^const volatile void *);\n+\n+consteval\n+{\n+ try\n+ {\n+ make_signed (^^bool);\n+ throw 1;\n+ }\n+ catch (std::meta::exception &)\n+ {\n+ }\n+ try\n+ {\n+ make_unsigned (^^bool);\n+ throw 1;\n+ }\n+ catch (std::meta::exception &)\n+ {\n+ }\n+ try\n+ {\n+ make_signed (^^float);\n+ throw 1;\n+ }\n+ catch (std::meta::exception &)\n+ {\n+ }\n+ try\n+ {\n+ make_unsigned (^^double);\n+ throw 1;\n+ }\n+ catch (std::meta::exception &)\n+ {\n+ }\n+ try\n+ {\n+ make_signed (^^C);\n+ throw 1;\n+ }\n+ catch (std::meta::exception &)\n+ {\n+ }\n+ try\n+ {\n+ make_unsigned (^^C);\n+ throw 1;\n+ }\n+ catch (std::meta::exception &)\n+ {\n+ }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait4.C b/gcc/testsuite/g++.dg/reflect/type_trait4.C\nnew file mode 100644\nindex 00000000000..7d44ab2dac9\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait4.C\n@@ -0,0 +1,12 @@\n+// { dg-do compile { target { c++26 && int128 } } }\n+// { dg-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], sign modifications.\n+\n+#include \n+using namespace std::meta;\n+\n+static_assert (make_signed (^^const signed __int128) == ^^const __int128);\n+static_assert (make_signed (^^volatile __int128 unsigned) == ^^volatile __int128);\n+\n+static_assert (make_unsigned (^^const volatile signed __int128) == ^^const volatile unsigned __int128);\n+static_assert (make_unsigned (^^__int128 unsigned) == ^^unsigned __int128);\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait5.C b/gcc/testsuite/g++.dg/reflect/type_trait5.C\nnew file mode 100644\nindex 00000000000..ff025882b4f\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait5.C\n@@ -0,0 +1,453 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], type properties.\n+\n+#include \n+using namespace std::meta;\n+\n+struct C { };\n+\n+struct HasTemplateCCtor\n+{\n+ HasTemplateCCtor (const HasTemplateCCtor &) = default;\n+ template \n+ HasTemplateCCtor (T &&);\n+};\n+ \n+struct MoveOnly\n+{\n+ MoveOnly (MoveOnly &&) = default;\n+};\n+ \n+struct MoveOnly2\n+{\n+ MoveOnly2 (MoveOnly2 &&) = delete;\n+};\n+\n+class EmptyClassOne\n+{ typedef int type; };\n+\n+class EmptyClassTwo\n+{ static int data; };\n+\n+class EmptyClassThree\n+{ int f(); };\n+\n+class NonEmptyClassOne\n+{ int data; };\n+\n+class NonEmptyClassTwo\n+{\n+ virtual int f();\n+ virtual ~NonEmptyClassTwo();\n+};\n+\n+class ClassType { };\n+typedef const ClassType cClassType;\n+typedef volatile ClassType vClassType;\n+typedef const volatile ClassType cvClassType;\n+\n+class DerivedType : public ClassType { };\n+\n+class FinalType final : public DerivedType { };\n+\n+enum EnumType { e0 };\n+\n+struct ConvType\n+{ operator int () const; };\n+\n+class AbstractClass\n+{\n+ virtual void rotate (int) = 0;\n+};\n+\n+class PolymorphicClass\n+{\n+ virtual void rotate (int);\n+};\n+\n+class DerivedPolymorphic : public PolymorphicClass { };\n+\n+class VirtualDestructorClass\n+{\n+ virtual ~VirtualDestructorClass();\n+};\n+\n+union UnionType { };\n+\n+union IncompleteUnion;\n+\n+class IncompleteClass;\n+\n+struct ExplicitClass\n+{\n+ ExplicitClass (double &);\n+ explicit ExplicitClass (int &);\n+ ExplicitClass (double &, int &, double &);\n+};\n+\n+struct NoexceptMoveAssignClass\n+{\n+ NoexceptMoveAssignClass (NoexceptMoveAssignClass &&) = default;\n+ NoexceptMoveAssignClass &operator= (NoexceptMoveAssignClass &&) noexcept (true);\n+};\n+\n+struct NType\n+{\n+ int i;\n+ int j;\n+ virtual ~NType ();\n+};\n+\n+struct TType\n+{\n+ int i;\n+private:\n+ int j;\n+};\n+\n+struct SLType\n+{\n+ int i;\n+ int j;\n+ ~SLType ();\n+};\n+\n+struct PODType\n+{\n+ int i;\n+ int j;\n+};\n+\n+struct CopyConsOnlyType\n+{\n+ CopyConsOnlyType (int) { }\n+ CopyConsOnlyType (CopyConsOnlyType &&) = delete;\n+ CopyConsOnlyType (const CopyConsOnlyType &) = default;\n+ CopyConsOnlyType &operator= (const CopyConsOnlyType &) = delete;\n+ CopyConsOnlyType &operator= (CopyConsOnlyType &&) = delete;\n+};\n+\n+struct MoveConsOnlyType\n+{\n+ MoveConsOnlyType (int) { }\n+ MoveConsOnlyType (const MoveConsOnlyType &) = delete;\n+ MoveConsOnlyType (MoveConsOnlyType &&) = default;\n+ MoveConsOnlyType& operator= (const MoveConsOnlyType &) = delete;\n+ MoveConsOnlyType& operator= (MoveConsOnlyType &&) = delete;\n+};\n+\n+struct Incomplete_struct;\n+\n+namespace construct\n+{\n+ struct Empty {};\n+\n+ struct B { int i; B () {} };\n+\n+ union U { int i; Empty b; };\n+\n+ struct Abstract\n+ {\n+ virtual ~Abstract () = 0;\n+ };\n+\n+ struct Any\n+ {\n+ template \n+ Any (T &&) {}\n+ };\n+\n+ struct DelDef\n+ {\n+ DelDef () = delete;\n+ };\n+\n+ struct DelCopy\n+ {\n+ DelCopy (const DelCopy &) = delete;\n+ };\n+\n+ struct DelDtor\n+ {\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+\n+ struct Ellipsis\n+ {\n+ Ellipsis (...) {}\n+ };\n+\n+ struct DelEllipsis\n+ {\n+ DelEllipsis (...) = delete;\n+ };\n+\n+ struct Nontrivial\n+ {\n+ Nontrivial ();\n+ Nontrivial (const Nontrivial &);\n+ Nontrivial &operator= (const Nontrivial &);\n+ ~Nontrivial ();\n+ };\n+\n+ struct UnusualCopy\n+ {\n+ UnusualCopy (UnusualCopy &);\n+ };\n+}\n+\n+namespace N\n+{\n+ void foo ();\n+}\n+\n+int v = 1;\n+struct S1 { decltype (^^long) a; };\n+union U2 { int a; decltype (^^N::foo) b; };\n+struct S3 { const decltype (^^N) *c; };\n+struct S4 : public S3 {};\n+struct S5 { int a; long *b; };\n+\n+static_assert (is_const_type (^^const int));\n+static_assert (is_const_type (^^const volatile int));\n+static_assert (is_const_type (^^cClassType));\n+static_assert (is_const_type (^^cvClassType));\n+static_assert (!is_const_type (^^int));\n+static_assert (!is_const_type (^^volatile int));\n+static_assert (!is_const_type (^^ClassType));\n+static_assert (!is_const_type (^^vClassType));\n+\n+static_assert (is_volatile_type (^^volatile int));\n+static_assert (is_volatile_type (^^const volatile int));\n+static_assert (is_volatile_type (^^vClassType));\n+static_assert (is_volatile_type (^^cvClassType));\n+static_assert (!is_volatile_type (^^int));\n+static_assert (!is_volatile_type (^^const int));\n+static_assert (!is_volatile_type (^^ClassType));\n+static_assert (!is_volatile_type (^^cClassType));\n+\n+static_assert (is_trivially_copyable_type (^^int));\n+static_assert (is_trivially_copyable_type (^^volatile int));\n+static_assert (is_trivially_copyable_type (^^TType));\n+static_assert (is_trivially_copyable_type (^^PODType));\n+static_assert (!is_trivially_copyable_type (^^NType));\n+static_assert (!is_trivially_copyable_type (^^SLType));\n+static_assert (is_trivially_copyable_type (^^construct::DelDef));\n+static_assert (!is_trivially_copyable_type (^^construct::Abstract));\n+static_assert (is_trivially_copyable_type (^^construct::Ellipsis));\n+static_assert (is_trivially_copyable_type (^^construct::DelEllipsis));\n+static_assert (is_trivially_copyable_type (^^construct::Any));\n+static_assert (is_trivially_copyable_type (^^construct::DelCopy));\n+static_assert (is_trivially_copyable_type (^^construct::DelDtor));\n+static_assert (!is_trivially_copyable_type (^^construct::Nontrivial));\n+static_assert (!is_trivially_copyable_type (^^construct::UnusualCopy));\n+static_assert (is_trivially_copyable_type (^^CopyConsOnlyType));\n+static_assert (is_trivially_copyable_type (^^MoveConsOnlyType));\n+static_assert (is_trivially_copyable_type (^^HasTemplateCCtor));\n+static_assert (is_trivially_copyable_type (^^MoveOnly));\n+static_assert (is_trivially_copyable_type (^^MoveOnly2));\n+static_assert (is_trivially_copyable_type (^^volatile int));\n+static_assert (is_trivially_copyable_type (^^TType));\n+static_assert (is_trivially_copyable_type (^^PODType));\n+static_assert (!is_trivially_copyable_type (^^NType));\n+static_assert (!is_trivially_copyable_type (^^SLType));\n+static_assert (is_trivially_copyable_type (^^construct::DelDef));\n+static_assert (!is_trivially_copyable_type (^^construct::Abstract));\n+static_assert (is_trivially_copyable_type (^^construct::Ellipsis));\n+static_assert (is_trivially_copyable_type (^^construct::DelEllipsis));\n+static_assert (is_trivially_copyable_type (^^construct::Any));\n+static_assert (is_trivially_copyable_type (^^construct::DelCopy));\n+static_assert (is_trivially_copyable_type (^^construct::DelDtor));\n+static_assert (!is_trivially_copyable_type (^^construct::Nontrivial));\n+static_assert (!is_trivially_copyable_type (^^construct::UnusualCopy));\n+static_assert (is_trivially_copyable_type (^^CopyConsOnlyType));\n+static_assert (is_trivially_copyable_type (^^MoveConsOnlyType));\n+static_assert (is_trivially_copyable_type (^^HasTemplateCCtor));\n+static_assert (is_trivially_copyable_type (^^MoveOnly));\n+static_assert (is_trivially_copyable_type (^^MoveOnly2));\n+\n+static_assert (is_standard_layout_type (^^SLType));\n+static_assert (is_standard_layout_type (^^PODType));\n+static_assert (!is_standard_layout_type (^^NType));\n+static_assert (!is_standard_layout_type (^^TType));\n+\n+static_assert (is_empty_type (^^ClassType));\n+static_assert (is_empty_type (^^EmptyClassOne));\n+static_assert (is_empty_type (^^EmptyClassTwo));\n+static_assert (is_empty_type (^^EmptyClassThree));\n+static_assert (!is_empty_type (^^void));\n+static_assert (!is_empty_type (^^float));\n+static_assert (!is_empty_type (^^int[4]));\n+static_assert (!is_empty_type (^^int *));\n+static_assert (!is_empty_type (^^int &));\n+static_assert (!is_empty_type (^^int (ClassType::*)));\n+static_assert (!is_empty_type (^^EnumType));\n+static_assert (!is_empty_type (^^int (int)));\n+static_assert (!is_empty_type (^^AbstractClass));\n+static_assert (!is_empty_type (^^NonEmptyClassOne));\n+static_assert (!is_empty_type (^^NonEmptyClassTwo));\n+\n+static_assert (is_polymorphic_type (^^PolymorphicClass));\n+static_assert (is_polymorphic_type (^^DerivedPolymorphic));\n+static_assert (is_polymorphic_type (^^AbstractClass));\n+static_assert (is_polymorphic_type (^^VirtualDestructorClass));\n+static_assert (!is_polymorphic_type (^^void));\n+static_assert (!is_polymorphic_type (^^int (int)));\n+static_assert (!is_polymorphic_type (^^int &));\n+static_assert (!is_polymorphic_type (^^EnumType));\n+static_assert (!is_polymorphic_type (^^ClassType));\n+static_assert (!is_polymorphic_type (^^DerivedType));\n+\n+static_assert (is_abstract_type (^^AbstractClass));\n+static_assert (!is_abstract_type (^^void));\n+static_assert (!is_abstract_type (^^int (int)));\n+static_assert (!is_abstract_type (^^int &));\n+static_assert (!is_abstract_type (^^ClassType));\n+\n+static_assert (is_final_type (^^FinalType));\n+static_assert (!is_final_type (^^ClassType));\n+static_assert (!is_final_type (^^DerivedType));\n+\n+static_assert (is_aggregate_type (^^ClassType));\n+static_assert (is_aggregate_type (^^UnionType));\n+static_assert (is_aggregate_type (^^SLType));\n+static_assert (is_aggregate_type (^^unsigned[3]));\n+static_assert (is_aggregate_type (^^unsigned[3][2]));\n+static_assert (is_aggregate_type (^^unsigned[]));\n+static_assert (is_aggregate_type (^^unsigned[][2]));\n+static_assert (is_aggregate_type (^^EnumType[3]));\n+static_assert (is_aggregate_type (^^EnumType[3][2]));\n+static_assert (is_aggregate_type (^^EnumType[]));\n+static_assert (is_aggregate_type (^^EnumType[][2]));\n+static_assert (!is_aggregate_type (^^AbstractClass));\n+static_assert (!is_aggregate_type (^^PolymorphicClass));\n+static_assert (!is_aggregate_type (^^ExplicitClass));\n+static_assert (!is_aggregate_type (^^char));\n+static_assert (!is_aggregate_type (^^unsigned char));\n+static_assert (!is_aggregate_type (^^signed char));\n+static_assert (!is_aggregate_type (^^unsigned));\n+static_assert (!is_aggregate_type (^^bool));\n+static_assert (!is_aggregate_type (^^float));\n+static_assert (!is_aggregate_type (^^double));\n+static_assert (!is_aggregate_type (^^EnumType));\n+static_assert (!is_aggregate_type (^^void));\n+static_assert (!is_aggregate_type (^^NoexceptMoveAssignClass));\n+\n+static_assert (is_consteval_only_type (^^decltype (^^long)));\n+static_assert (is_consteval_only_type (^^const decltype (^^N::foo)));\n+static_assert (is_consteval_only_type (^^volatile decltype (^^N)));\n+static_assert (is_consteval_only_type (^^const volatile decltype (^^v)));\n+static_assert (is_consteval_only_type (^^const S1));\n+static_assert (is_consteval_only_type (^^U2));\n+static_assert (is_consteval_only_type (^^S3));\n+static_assert (is_consteval_only_type (^^S4));\n+static_assert (!is_consteval_only_type (^^int));\n+static_assert (!is_consteval_only_type (^^S5));\n+\n+static_assert (!is_signed_type (^^void));\n+static_assert (char (-1) < char (0) ? is_signed_type (^^char) : !is_signed_type (^^char));\n+static_assert (is_signed_type (^^signed char));\n+static_assert (!is_signed_type (^^unsigned char));\n+static_assert (wchar_t (-1) < wchar_t (0) ? is_signed_type (^^wchar_t) : !is_signed_type (^^wchar_t));\n+static_assert (is_signed_type (^^short));\n+static_assert (!is_signed_type (^^unsigned short));\n+static_assert (is_signed_type (^^int));\n+static_assert (!is_signed_type (^^unsigned int));\n+static_assert (is_signed_type (^^long));\n+static_assert (!is_signed_type (^^unsigned long));\n+static_assert (is_signed_type (^^long long));\n+static_assert (!is_signed_type (^^unsigned long long));\n+static_assert (is_signed_type (^^float));\n+static_assert (is_signed_type (^^double));\n+static_assert (is_signed_type (^^long double));\n+static_assert (!is_signed_type (^^ClassType));\n+\n+static_assert (!is_unsigned_type (^^void));\n+static_assert (char (-1) < char (0) ? !is_unsigned_type (^^char) : is_unsigned_type (^^char));\n+static_assert (!is_unsigned_type (^^signed char));\n+static_assert (is_unsigned_type (^^unsigned char));\n+static_assert (wchar_t (-1) < wchar_t (0) ? !is_unsigned_type (^^wchar_t) : is_unsigned_type (^^wchar_t));\n+static_assert (!is_unsigned_type (^^short));\n+static_assert (is_unsigned_type (^^unsigned short));\n+static_assert (!is_unsigned_type (^^int));\n+static_assert (is_unsigned_type (^^unsigned int));\n+static_assert (!is_unsigned_type (^^long));\n+static_assert (is_unsigned_type (^^unsigned long));\n+static_assert (!is_unsigned_type (^^long long));\n+static_assert (is_unsigned_type (^^unsigned long long));\n+static_assert (!is_unsigned_type (^^float));\n+static_assert (!is_unsigned_type (^^double));\n+static_assert (!is_unsigned_type (^^long double));\n+static_assert (!is_unsigned_type (^^ClassType));\n+\n+static_assert (is_bounded_array_type (^^int[2]));\n+static_assert (!is_bounded_array_type (^^int[]));\n+static_assert (is_bounded_array_type (^^int[2][3]));\n+static_assert (!is_bounded_array_type (^^int[][3]));\n+static_assert (is_bounded_array_type (^^float *[2]));\n+static_assert (!is_bounded_array_type (^^float *[]));\n+static_assert (is_bounded_array_type (^^float *[2][3]));\n+static_assert (!is_bounded_array_type (^^float *[][3]));\n+static_assert (is_bounded_array_type (^^ClassType[2]));\n+static_assert (!is_bounded_array_type (^^ClassType[]));\n+static_assert (is_bounded_array_type (^^ClassType[2][3]));\n+static_assert (!is_bounded_array_type (^^ClassType[][3]));\n+static_assert (!is_bounded_array_type (^^int (*)[2]));\n+static_assert (!is_bounded_array_type (^^int (*)[]));\n+static_assert (!is_bounded_array_type (^^int (&)[2]));\n+static_assert (!is_bounded_array_type (^^int (&)[]));\n+static_assert (!is_bounded_array_type (^^ClassType));\n+static_assert (!is_bounded_array_type (^^void ()));\n+\n+static_assert (!is_unbounded_array_type (^^int[2]));\n+static_assert (is_unbounded_array_type (^^int[]));\n+static_assert (!is_unbounded_array_type (^^int[2][3]));\n+static_assert (is_unbounded_array_type (^^int[][3]));\n+static_assert (!is_unbounded_array_type (^^float *[2]));\n+static_assert (is_unbounded_array_type (^^float *[]));\n+static_assert (!is_unbounded_array_type (^^float *[2][3]));\n+static_assert (is_unbounded_array_type (^^float *[][3]));\n+static_assert (!is_unbounded_array_type (^^ClassType[2]));\n+static_assert (is_unbounded_array_type (^^ClassType[]));\n+static_assert (!is_unbounded_array_type (^^ClassType[2][3]));\n+static_assert (is_unbounded_array_type (^^ClassType[][3]));\n+static_assert (!is_unbounded_array_type (^^IncompleteClass[2][3]));\n+static_assert (is_unbounded_array_type (^^IncompleteClass[][3]));\n+static_assert (!is_unbounded_array_type (^^int (*)[2]));\n+static_assert (!is_unbounded_array_type (^^int (*)[]));\n+static_assert (!is_unbounded_array_type (^^int (&)[2]));\n+static_assert (!is_unbounded_array_type (^^int (&)[]));\n+static_assert (!is_unbounded_array_type (^^ClassType));\n+static_assert (!is_unbounded_array_type (^^IncompleteClass));\n+static_assert (!is_unbounded_array_type (^^IncompleteUnion));\n+\n+enum class E { e1, e2 };\n+static_assert (is_scoped_enum_type (^^E));\n+enum class Ec : char { e1, e2 };\n+static_assert (is_scoped_enum_type (^^Ec));\n+enum U { u1, u2 };\n+static_assert (!is_scoped_enum_type (^^U));\n+enum F : int { f1, f2 };\n+static_assert (!is_scoped_enum_type (^^F));\n+static_assert (!is_scoped_enum_type (^^Incomplete_struct));\n+struct S;\n+static_assert (!is_scoped_enum_type (^^S));\n+struct S { };\n+static_assert (!is_scoped_enum_type (^^S));\n+static_assert (!is_scoped_enum_type (^^int));\n+static_assert (!is_scoped_enum_type (^^int[]));\n+static_assert (!is_scoped_enum_type (^^int[2]));\n+static_assert (!is_scoped_enum_type (^^int[][2]));\n+static_assert (!is_scoped_enum_type (^^int[2][3]));\n+static_assert (!is_scoped_enum_type (^^int *));\n+static_assert (!is_scoped_enum_type (^^int &));\n+static_assert (!is_scoped_enum_type (^^int *&));\n+static_assert (!is_scoped_enum_type (^^int ()));\n+static_assert (!is_scoped_enum_type (^^int (*) ()));\n+static_assert (!is_scoped_enum_type (^^int (&) ()));\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait6.C b/gcc/testsuite/g++.dg/reflect/type_trait6.C\nnew file mode 100644\nindex 00000000000..e1b466f3cb6\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait6.C\n@@ -0,0 +1,1381 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], type properties.\n+\n+#include \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+\n+namespace N1\n+{\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 \n+ struct ImplicitTo { operator To (); };\n+ template \n+ struct DelImplicitTo { operator To () = delete; };\n+ template \n+ struct ExplicitTo { explicit operator To (); };\n+ struct Ellipsis { Ellipsis (...) {} };\n+ struct DelEllipsis { DelEllipsis (...) = delete; };\n+ struct Any { template Any (T &&) {} };\n+ struct nAny { template nAny (T &&...) {} };\n+ struct DelnAny { template DelnAny (T &&...) = delete; };\n+ template \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+\n+namespace N2\n+{\n+ struct E {};\n+ struct NTD1 { ~NTD1 () = default; };\n+ struct NTD2 { ~NTD2 (); };\n+ struct NTD3 { ~NTD3 () noexcept (true); };\n+ struct TD1 { ~TD1 () noexcept (false); };\n+ struct TD2 { ~TD2 () noexcept (false); };\n+ struct Aggr { int i; bool b; E e; };\n+ struct Aggr2 { int i; bool b; TD1 r; };\n+ struct Del { ~Del () = delete; };\n+ struct Del2 { ~Del2 () noexcept = delete; };\n+ struct Del3 { ~Del3 () noexcept (false) = delete; };\n+ struct Der : Aggr {};\n+ struct Der2 : Aggr2 {};\n+ union U1 { int i; double d; void *p; TD1 *pt; };\n+ union Ut { int i; double d; void *p; TD1 pt; };\n+ enum class En { a, b, c, d };\n+ enum En2 { En2a, En2b, En2c, En2d };\n+ enum OpE : int;\n+ enum class OpSE : bool;\n+ struct Abstract1 { virtual ~Abstract1 () = 0; };\n+ struct AbstractDelDtor { ~AbstractDelDtor () = delete; virtual void foo () = 0; };\n+ struct Abstract2 { virtual ~Abstract2 () noexcept (false) = 0; };\n+ struct Abstract3 { ~Abstract3 () noexcept (false); virtual void foo () noexcept = 0; };\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+ struct Ellipsis { Ellipsis (...) {} };\n+ struct DelEllipsis { DelEllipsis (...) = delete; };\n+ struct DelDef { DelDef () = delete; };\n+ struct DelCopy { DelCopy (const DelCopy &) = delete; };\n+}\n+\n+namespace N3\n+{\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+ union UAssignAll { bool b; char c; template void operator= (T &&); };\n+ union UDelAssignAll { bool b; char c; template void operator= (T &&) = delete; };\n+ struct Abstract { virtual ~Abstract () = 0; };\n+ struct AbstractDelDtor { ~AbstractDelDtor () = delete; virtual void foo () = 0; };\n+ struct Ukn;\n+ template \n+ struct ImplicitTo { operator To (); };\n+ template \n+ struct ExplicitTo { explicit operator To (); };\n+ template \n+ struct DelImplicitTo { operator To () = delete; };\n+ template struct DelExplicitTo { explicit operator To () = delete; };\n+ struct Ellipsis { Ellipsis (...) {} };\n+ struct DelEllipsis { DelEllipsis (...) = delete; };\n+ struct Any { template Any (T &&) {} };\n+ struct nAny { template nAny (T &&...) {} };\n+ struct DelnAny { template DelnAny (T &&...) = delete; };\n+ template\n+ struct FromArgs { FromArgs (Args...); };\n+ template\n+ struct DelFromArgs { DelFromArgs (Args...) = delete; };\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+ struct AnyAssign { template void operator= (T &&); };\n+ struct DelAnyAssign { template void operator= (T &&) = delete; };\n+ struct DelCopyAssign {\n+ DelCopyAssign &operator= (const DelCopyAssign &) = delete;\n+ DelCopyAssign &operator= (DelCopyAssign &&) = default;\n+ };\n+ struct MO { MO (MO &&) = default; MO &operator= (MO &&) = default; };\n+}\n+\n+struct CopyConsOnlyType {\n+ CopyConsOnlyType (int) { }\n+ CopyConsOnlyType (CopyConsOnlyType &&) = delete;\n+ CopyConsOnlyType (const CopyConsOnlyType &) = default;\n+ CopyConsOnlyType &operator= (const CopyConsOnlyType &) = delete;\n+ CopyConsOnlyType &operator= (CopyConsOnlyType &&) = delete;\n+};\n+\n+struct MoveConsOnlyType {\n+ MoveConsOnlyType (int) { }\n+ MoveConsOnlyType (const MoveConsOnlyType &) = delete;\n+ MoveConsOnlyType (MoveConsOnlyType &&) = default;\n+ MoveConsOnlyType &operator= (const MoveConsOnlyType &) = delete;\n+ MoveConsOnlyType &operator= (MoveConsOnlyType &&) = delete;\n+};\n+\n+struct HasTemplateCtor { HasTemplateCtor () = default; template HasTemplateCtor (); };\n+struct HasTemplateCCtor {\n+ HasTemplateCCtor (const HasTemplateCCtor &) = default;\n+ template \n+ HasTemplateCCtor (T &&);\n+};\n+struct MoveOnly { MoveOnly (MoveOnly &&) = default; };\n+struct MoveOnly2 { MoveOnly2 (MoveOnly2 &&) = delete; };\n+struct HasTemplateCAssign\n+{\n+ HasTemplateCAssign &operator= (const HasTemplateCAssign &) = default;\n+ template \n+ HasTemplateCAssign &operator= (T &&);\n+};\n+struct MoveOnly3 { MoveOnly3 &operator= (MoveOnly3 &&) = default; };\n+struct MoveOnly4 { MoveOnly4 &operator= (MoveOnly4 &&) = delete; };\n+\n+static_assert (is_default_constructible_type (^^int));\n+static_assert (is_default_constructible_type (^^int const));\n+static_assert (is_default_constructible_type (^^int const volatile));\n+static_assert (is_default_constructible_type (^^int *));\n+static_assert (is_default_constructible_type (^^void *));\n+static_assert (is_default_constructible_type (^^void *const));\n+static_assert (is_default_constructible_type (^^int N1::B::*));\n+static_assert (is_default_constructible_type (^^void (*) ()));\n+static_assert (is_default_constructible_type (^^std::nullptr_t));\n+static_assert (is_default_constructible_type (^^std::nullptr_t const));\n+static_assert (is_default_constructible_type (^^N1::Empty));\n+static_assert (is_default_constructible_type (^^N1::Empty const));\n+static_assert (is_default_constructible_type (^^N1::FromArgs <>));\n+static_assert (is_default_constructible_type (^^N1::FromArgs <> const));\n+static_assert (is_default_constructible_type (^^N1::nAny));\n+static_assert (is_default_constructible_type (^^N1::nAny const));\n+static_assert (is_default_constructible_type (^^N1::Ellipsis));\n+static_assert (is_default_constructible_type (^^N1::Ellipsis const));\n+static_assert (is_default_constructible_type (^^N1::U));\n+static_assert (is_default_constructible_type (^^N1::U const));\n+static_assert (is_default_constructible_type (^^N1::E));\n+static_assert (is_default_constructible_type (^^N1::E const));\n+static_assert (is_default_constructible_type (^^N1::SE));\n+static_assert (is_default_constructible_type (^^N1::SE const));\n+static_assert (is_default_constructible_type (^^N1::OpE));\n+static_assert (is_default_constructible_type (^^N1::OpE const));\n+static_assert (is_default_constructible_type (^^N1::OpSE));\n+static_assert (is_default_constructible_type (^^N1::OpSE const));\n+static_assert (is_default_constructible_type (^^int [1]));\n+static_assert (is_default_constructible_type (^^const int [1]));\n+static_assert (is_default_constructible_type (^^int [1][2]));\n+static_assert (is_default_constructible_type (^^const int [1][2]));\n+static_assert (is_default_constructible_type (^^N1::FromArgs <> [1]));\n+static_assert (is_default_constructible_type (^^const N1::FromArgs <> [1]));\n+static_assert (is_default_constructible_type (^^N1::U [1]));\n+static_assert (is_default_constructible_type (^^const N1::U [1]));\n+static_assert (is_default_constructible_type (^^N1::Empty [1]));\n+static_assert (is_default_constructible_type (^^const N1::Empty [1]));\n+static_assert (is_default_constructible_type (^^N1::Ellipsis [1]));\n+static_assert (is_default_constructible_type (^^const N1::Ellipsis [1]));\n+static_assert (is_default_constructible_type (^^std::nullptr_t [1]));\n+static_assert (is_default_constructible_type (^^const std::nullptr_t [1]));\n+static_assert (is_default_constructible_type (^^N1::nAny [1]));\n+static_assert (is_default_constructible_type (^^const N1::nAny [1]));\n+static_assert (is_default_constructible_type (^^N1::E [1]));\n+static_assert (is_default_constructible_type (^^const N1::E [1]));\n+static_assert (is_default_constructible_type (^^N1::SE [1]));\n+static_assert (is_default_constructible_type (^^const N1::SE [1]));\n+static_assert (is_default_constructible_type (^^N1::OpE [1]));\n+static_assert (is_default_constructible_type (^^const N1::OpE [1]));\n+static_assert (is_default_constructible_type (^^N1::OpSE [1]));\n+static_assert (is_default_constructible_type (^^const N1::OpSE [1]));\n+static_assert (is_default_constructible_type (^^int * [1]));\n+static_assert (is_default_constructible_type (^^int * const [1]));\n+static_assert (is_default_constructible_type (^^int N1::B::* [1]));\n+static_assert (is_default_constructible_type (^^int N1::B::* const [1]));\n+static_assert (is_default_constructible_type (^^std::initializer_list ));\n+static_assert (is_default_constructible_type (^^const std::initializer_list ));\n+static_assert (is_default_constructible_type (^^std::initializer_list [1]));\n+static_assert (is_default_constructible_type (^^const std::initializer_list [1]));\n+static_assert (is_default_constructible_type (^^NoexceptDefaultClass));\n+static_assert (is_default_constructible_type (^^ThrowDefaultClass));\n+static_assert (is_default_constructible_type (^^ExceptDefaultClass));\n+static_assert (!is_default_constructible_type (^^void));\n+static_assert (!is_default_constructible_type (^^const void));\n+static_assert (!is_default_constructible_type (^^N1::Abstract));\n+static_assert (!is_default_constructible_type (^^const N1::Abstract));\n+static_assert (!is_default_constructible_type (^^N1::Any));\n+static_assert (!is_default_constructible_type (^^const N1::Any));\n+static_assert (!is_default_constructible_type (^^N1::FromArgs ));\n+static_assert (!is_default_constructible_type (^^const N1::FromArgs ));\n+static_assert (!is_default_constructible_type (^^int &));\n+static_assert (!is_default_constructible_type (^^int &&));\n+static_assert (!is_default_constructible_type (^^void ()));\n+static_assert (!is_default_constructible_type (^^void () const volatile));\n+static_assert (!is_default_constructible_type (^^void (&) ()));\n+static_assert (!is_default_constructible_type (^^int (&) [1]));\n+static_assert (!is_default_constructible_type (^^int (&) []));\n+static_assert (!is_default_constructible_type (^^int []));\n+static_assert (!is_default_constructible_type (^^const int []));\n+static_assert (!is_default_constructible_type (^^int [][1][2]));\n+static_assert (!is_default_constructible_type (^^const int [][1][2]));\n+static_assert (!is_default_constructible_type (^^N1::Any [1]));\n+static_assert (!is_default_constructible_type (^^const N1::Any [1]));\n+static_assert (!is_default_constructible_type (^^N1::FromArgs [1]));\n+static_assert (!is_default_constructible_type (^^const N1::FromArgs [1]));\n+static_assert (!is_default_constructible_type (^^N1::FromArgs >));\n+static_assert (!is_default_constructible_type (^^const N1::FromArgs >));\n+static_assert (!is_default_constructible_type (^^const N1::FromArgs >));\n+static_assert (!is_default_constructible_type (^^N1::DelDef));\n+static_assert (!is_default_constructible_type (^^const N1::DelDef));\n+static_assert (!is_default_constructible_type (^^N1::DelCopy));\n+static_assert (!is_default_constructible_type (^^const N1::DelCopy));\n+static_assert (!is_default_constructible_type (^^N1::DelDtor));\n+static_assert (!is_default_constructible_type (^^const N1::DelDtor));\n+static_assert (!is_default_constructible_type (^^int []));\n+static_assert (!is_default_constructible_type (^^N1::Empty []));\n+static_assert (!is_default_constructible_type (^^N1::B []));\n+static_assert (!is_default_constructible_type (^^N1::D []));\n+static_assert (!is_default_constructible_type (^^N1::U []));\n+static_assert (!is_default_constructible_type (^^N1::Ukn []));\n+static_assert (!is_default_constructible_type (^^N1::Ellipsis []));\n+static_assert (!is_default_constructible_type (^^N1::Any []));\n+static_assert (!is_default_constructible_type (^^N1::nAny []));\n+\n+static_assert (is_copy_constructible_type (^^int));\n+static_assert (is_copy_constructible_type (^^float));\n+static_assert (is_copy_constructible_type (^^EnumType));\n+static_assert (is_copy_constructible_type (^^int *));\n+static_assert (is_copy_constructible_type (^^int (*) (int)));\n+static_assert (is_copy_constructible_type (^^int (ClassType::*)));\n+static_assert (is_copy_constructible_type (^^int (ClassType::*) (int)));\n+static_assert (is_copy_constructible_type (^^NoexceptCopyConsClass));\n+static_assert (is_copy_constructible_type (^^const NoexceptCopyConsClass));\n+static_assert (is_copy_constructible_type (^^ThrowCopyConsClass));\n+static_assert (is_copy_constructible_type (^^ExceptCopyConsClass));\n+static_assert (!is_copy_constructible_type (^^void));\n+static_assert (!is_copy_constructible_type (^^int [2]));\n+static_assert (!is_copy_constructible_type (^^int []));\n+static_assert (!is_copy_constructible_type (^^float [][3]));\n+static_assert (!is_copy_constructible_type (^^EnumType [2][3][4]));\n+static_assert (!is_copy_constructible_type (^^int * [3]));\n+static_assert (!is_copy_constructible_type (^^int (* [][2]) (int)));\n+static_assert (!is_copy_constructible_type (^^int (ClassType::* [2][3])));\n+static_assert (!is_copy_constructible_type (^^int (ClassType::* [][2][3]) (int)));\n+static_assert (!is_copy_constructible_type (^^ClassType (unsigned) const &));\n+static_assert (!is_copy_constructible_type (^^bool (ClassType) const));\n+static_assert (!is_copy_constructible_type (^^bool (...) &&));\n+static_assert (!is_copy_constructible_type (^^EnumType (int, ...)));\n+static_assert (!is_copy_constructible_type (^^volatile NoexceptCopyConsClass));\n+\n+static_assert (is_move_constructible_type (^^int));\n+static_assert (is_move_constructible_type (^^float));\n+static_assert (is_move_constructible_type (^^EnumType));\n+static_assert (is_move_constructible_type (^^int *));\n+static_assert (is_move_constructible_type (^^int (*) (int)));\n+static_assert (is_move_constructible_type (^^int (ClassType::*)));\n+static_assert (is_move_constructible_type (^^int (ClassType::*) (int)));\n+static_assert (is_move_constructible_type (^^NoexceptMoveConsClass));\n+static_assert (is_move_constructible_type (^^ThrowMoveConsClass));\n+static_assert (is_move_constructible_type (^^ExceptMoveConsClass));\n+static_assert (!is_move_constructible_type (^^void));\n+static_assert (!is_move_constructible_type (^^int [2]));\n+static_assert (!is_move_constructible_type (^^int []));\n+static_assert (!is_move_constructible_type (^^float [][3]));\n+static_assert (!is_move_constructible_type (^^EnumType [2][3][4]));\n+static_assert (!is_move_constructible_type (^^int * [3]));\n+static_assert (!is_move_constructible_type (^^int (* [][2]) (int)));\n+static_assert (!is_move_constructible_type (^^int (ClassType::* [2][3])));\n+static_assert (!is_move_constructible_type (^^int (ClassType::* [][2][3]) (int)));\n+static_assert (!is_move_constructible_type (^^ClassType (unsigned) const &));\n+static_assert (!is_move_constructible_type (^^bool (ClassType) const));\n+static_assert (!is_move_constructible_type (^^bool (...) &&));\n+static_assert (!is_move_constructible_type (^^EnumType (int, ...)));\n+static_assert (!is_move_constructible_type (^^const NoexceptMoveConsClass));\n+static_assert (!is_move_constructible_type (^^volatile NoexceptMoveConsClass));\n+\n+static_assert (is_assignable_type (^^int &, ^^int));\n+static_assert (is_assignable_type (^^int &, ^^const int));\n+static_assert (is_assignable_type (^^int &, ^^int &));\n+static_assert (is_assignable_type (^^int &, ^^const int &));\n+static_assert (!is_assignable_type (^^int, ^^int));\n+static_assert (!is_assignable_type (^^int, ^^const int));\n+static_assert (!is_assignable_type (^^int, ^^int &));\n+static_assert (!is_assignable_type (^^int, ^^const int &));\n+static_assert (!is_assignable_type (^^const int, ^^int));\n+static_assert (!is_assignable_type (^^const int, ^^const int));\n+static_assert (!is_assignable_type (^^const int, ^^int &));\n+static_assert (!is_assignable_type (^^const int, ^^const int &));\n+static_assert (!is_assignable_type (^^const int &, ^^int));\n+static_assert (!is_assignable_type (^^const int &, ^^const int));\n+static_assert (!is_assignable_type (^^const int &, ^^int &));\n+static_assert (!is_assignable_type (^^const int &, ^^const int &));\n+static_assert (is_assignable_type (^^N3::Empty &, ^^N3::Empty));\n+static_assert (is_assignable_type (^^N3::Empty &, ^^const N3::Empty));\n+static_assert (is_assignable_type (^^N3::Empty &, ^^N3::Empty &));\n+static_assert (is_assignable_type (^^N3::Empty &, ^^const N3::Empty &));\n+static_assert (is_assignable_type (^^N3::Empty, ^^N3::Empty));\n+static_assert (is_assignable_type (^^N3::Empty, ^^const N3::Empty));\n+static_assert (is_assignable_type (^^N3::Empty, ^^N3::Empty &));\n+static_assert (is_assignable_type (^^N3::Empty, ^^const N3::Empty &));\n+static_assert (is_assignable_type (^^N3::B &, ^^N3::B));\n+static_assert (is_assignable_type (^^N3::B &, ^^const N3::B));\n+static_assert (is_assignable_type (^^N3::B &, ^^N3::B &));\n+static_assert (is_assignable_type (^^N3::B &, ^^const N3::B &));\n+static_assert (is_assignable_type (^^N3::B, ^^N3::B));\n+static_assert (is_assignable_type (^^N3::B, ^^const N3::B));\n+static_assert (is_assignable_type (^^N3::B, ^^N3::B &));\n+static_assert (is_assignable_type (^^N3::B, ^^const N3::B &));\n+static_assert (is_assignable_type (^^bool &, ^^bool));\n+static_assert (is_assignable_type (^^bool &, ^^const bool));\n+static_assert (is_assignable_type (^^bool &, ^^bool &));\n+static_assert (is_assignable_type (^^bool &, ^^const bool &));\n+static_assert (!is_assignable_type (^^bool, ^^bool));\n+static_assert (!is_assignable_type (^^bool, ^^const bool));\n+static_assert (!is_assignable_type (^^bool, ^^bool &));\n+static_assert (!is_assignable_type (^^bool, ^^const bool &));\n+static_assert (is_assignable_type (^^std::nullptr_t &, ^^std::nullptr_t));\n+static_assert (is_assignable_type (^^std::nullptr_t &, ^^const std::nullptr_t));\n+static_assert (is_assignable_type (^^std::nullptr_t &, ^^std::nullptr_t &));\n+static_assert (is_assignable_type (^^std::nullptr_t &, ^^const std::nullptr_t &));\n+static_assert (!is_assignable_type (^^std::nullptr_t, ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^std::nullptr_t, ^^const std::nullptr_t));\n+static_assert (!is_assignable_type (^^std::nullptr_t, ^^std::nullptr_t &));\n+static_assert (!is_assignable_type (^^std::nullptr_t, ^^const std::nullptr_t &));\n+static_assert (is_assignable_type (^^N3::E &, ^^N3::E));\n+static_assert (is_assignable_type (^^N3::E &, ^^const N3::E));\n+static_assert (is_assignable_type (^^N3::E &, ^^N3::E &));\n+static_assert (is_assignable_type (^^N3::E &, ^^const N3::E &));\n+static_assert (is_assignable_type (^^int &, ^^N3::E));\n+static_assert (is_assignable_type (^^int &, ^^const N3::E));\n+static_assert (is_assignable_type (^^int &, ^^N3::E &));\n+static_assert (is_assignable_type (^^int &, ^^const N3::E &));\n+static_assert (!is_assignable_type (^^N3::E &, ^^int));\n+static_assert (!is_assignable_type (^^N3::E &, ^^const int));\n+static_assert (!is_assignable_type (^^N3::E &, ^^int &));\n+static_assert (!is_assignable_type (^^N3::E &, ^^const int &));\n+static_assert (!is_assignable_type (^^N3::E &, ^^N3::E2));\n+static_assert (!is_assignable_type (^^N3::E &, ^^const N3::E2));\n+static_assert (!is_assignable_type (^^N3::E &, ^^N3::E2 &));\n+static_assert (!is_assignable_type (^^N3::E &, ^^const N3::E2 &));\n+static_assert (!is_assignable_type (^^N3::E, ^^N3::E));\n+static_assert (!is_assignable_type (^^N3::E, ^^const N3::E));\n+static_assert (!is_assignable_type (^^N3::E, ^^N3::E &));\n+static_assert (!is_assignable_type (^^N3::E, ^^const N3::E &));\n+static_assert (is_assignable_type (^^N3::SE &, ^^N3::SE));\n+static_assert (is_assignable_type (^^N3::SE &, ^^const N3::SE));\n+static_assert (is_assignable_type (^^N3::SE &, ^^N3::SE &));\n+static_assert (is_assignable_type (^^N3::SE &, ^^const N3::SE &));\n+static_assert (!is_assignable_type (^^int &, ^^N3::SE));\n+static_assert (!is_assignable_type (^^int &, ^^const N3::SE));\n+static_assert (!is_assignable_type (^^int &, ^^N3::SE &));\n+static_assert (!is_assignable_type (^^int &, ^^const N3::SE &));\n+static_assert (!is_assignable_type (^^N3::SE &, ^^int));\n+static_assert (!is_assignable_type (^^N3::SE &, ^^const int));\n+static_assert (!is_assignable_type (^^N3::SE &, ^^int &));\n+static_assert (!is_assignable_type (^^N3::SE &, ^^const int &));\n+static_assert (!is_assignable_type (^^N3::SE, ^^N3::SE));\n+static_assert (!is_assignable_type (^^N3::SE, ^^const N3::SE));\n+static_assert (!is_assignable_type (^^N3::SE, ^^N3::SE &));\n+static_assert (!is_assignable_type (^^N3::SE, ^^const N3::SE &));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^int));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^std::nullptr_t));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::E));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::SE));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::Empty));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::U));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^int &));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^std::nullptr_t &));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::E &));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::SE &));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::Empty &));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::U &));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::AnyAssign));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^std::initializer_list ));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^int [1]));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^std::nullptr_t [1]));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::E [1]));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::SE [1]));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^int (&) [1]));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^std::nullptr_t (&) [1]));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::E (&) [1]));\n+static_assert (is_assignable_type (^^N3::AnyAssign &, ^^N3::SE (&) [1]));\n+static_assert (is_assignable_type (^^int &, ^^N3::E));\n+static_assert (!is_assignable_type (^^int &, ^^N3::SE));\n+static_assert (is_assignable_type (^^bool &, ^^N3::E));\n+static_assert (!is_assignable_type (^^bool &, ^^N3::SE));\n+static_assert (is_assignable_type (^^bool &, ^^void *));\n+static_assert (is_assignable_type (^^bool &, ^^int N3::B::*));\n+static_assert (is_assignable_type (^^bool &, ^^void *));\n+static_assert (!is_assignable_type (^^bool &, ^^std::nullptr_t));\n+static_assert (is_assignable_type (^^std::nullptr_t &, ^^std::nullptr_t));\n+static_assert (is_assignable_type (^^void *&, ^^std::nullptr_t));\n+static_assert (is_assignable_type (^^int *&, ^^std::nullptr_t));\n+static_assert (is_assignable_type (^^int N3::B::*&, ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^std::nullptr_t &, ^^bool));\n+static_assert (!is_assignable_type (^^void *&, ^^bool));\n+static_assert (!is_assignable_type (^^N3::E &, ^^bool));\n+static_assert (!is_assignable_type (^^N3::SE &, ^^bool));\n+static_assert (is_assignable_type (^^std::initializer_list &, ^^std::initializer_list ));\n+static_assert (is_assignable_type (^^std::initializer_list &, ^^std::initializer_list &&));\n+static_assert (is_assignable_type (^^std::initializer_list &, ^^const std::initializer_list &&));\n+static_assert (is_assignable_type (^^std::initializer_list &, ^^std::initializer_list &));\n+static_assert (is_assignable_type (^^std::initializer_list &, ^^const std::initializer_list &));\n+static_assert (!is_assignable_type (^^const std::initializer_list &, ^^std::initializer_list ));\n+static_assert (!is_assignable_type (^^const N3::AnyAssign &, ^^int));\n+static_assert (!is_assignable_type (^^N3::AnyAssign &, ^^void));\n+static_assert (!is_assignable_type (^^void, ^^int));\n+static_assert (!is_assignable_type (^^const void, ^^int));\n+static_assert (!is_assignable_type (^^int, ^^void));\n+static_assert (!is_assignable_type (^^int, ^^const void));\n+static_assert (!is_assignable_type (^^const int, ^^void));\n+static_assert (!is_assignable_type (^^const int, ^^const void));\n+static_assert (!is_assignable_type (^^int &, ^^void));\n+static_assert (!is_assignable_type (^^int &, ^^const void));\n+static_assert (!is_assignable_type (^^const int &, ^^void));\n+static_assert (!is_assignable_type (^^const int &, ^^const void));\n+static_assert (!is_assignable_type (^^void, ^^void));\n+static_assert (!is_assignable_type (^^const void, ^^void));\n+static_assert (!is_assignable_type (^^const void, ^^const void));\n+static_assert (!is_assignable_type (^^int [1], ^^int [1]));\n+static_assert (!is_assignable_type (^^int (&) [1], ^^int [1]));\n+static_assert (!is_assignable_type (^^int (&) [1], ^^int (&) [1]));\n+static_assert (!is_assignable_type (^^int [2], ^^int [1]));\n+static_assert (!is_assignable_type (^^int (&) [2], ^^int [1]));\n+static_assert (!is_assignable_type (^^int (&) [2], ^^int (&) [1]));\n+static_assert (!is_assignable_type (^^int [1], ^^void));\n+static_assert (!is_assignable_type (^^int (&) [1], ^^void));\n+static_assert (!is_assignable_type (^^void, ^^int [1]));\n+static_assert (!is_assignable_type (^^void, ^^int (&) [1]));\n+static_assert (!is_assignable_type (^^int [], ^^int []));\n+static_assert (!is_assignable_type (^^int (&) [], ^^int []));\n+static_assert (!is_assignable_type (^^int (&) [], ^^int (&) []));\n+static_assert (!is_assignable_type (^^int [1], ^^int []));\n+static_assert (!is_assignable_type (^^int (&) [1], ^^int []));\n+static_assert (!is_assignable_type (^^int (&) [1], ^^int (&) []));\n+static_assert (!is_assignable_type (^^int [], ^^int [1]));\n+static_assert (!is_assignable_type (^^int (&) [], ^^int [1]));\n+static_assert (!is_assignable_type (^^int (&) [], ^^int (&) [1]));\n+static_assert (!is_assignable_type (^^int [], ^^void));\n+static_assert (!is_assignable_type (^^int (&) [], ^^void));\n+static_assert (!is_assignable_type (^^void, ^^int []));\n+static_assert (!is_assignable_type (^^void, ^^int (&) []));\n+static_assert (is_assignable_type (^^N3::DelCopyAssign &, ^^N3::DelCopyAssign));\n+static_assert (!is_assignable_type (^^N3::DelCopyAssign &, ^^const N3::DelCopyAssign));\n+static_assert (!is_assignable_type (^^N3::DelCopyAssign &, ^^N3::DelCopyAssign &));\n+static_assert (!is_assignable_type (^^N3::DelCopyAssign &, ^^const N3::DelCopyAssign &));\n+static_assert (!is_assignable_type (^^N3::DelCopyAssign &, ^^void));\n+static_assert (!is_assignable_type (^^N3::DelCopyAssign &, ^^void ()));\n+static_assert (!is_assignable_type (^^N3::DelCopyAssign &, ^^void (&) ()));\n+static_assert (!is_assignable_type (^^N3::DelCopyAssign &, ^^int));\n+static_assert (is_assignable_type (^^N3::DelAnyAssign &, ^^N3::DelAnyAssign &&));\n+static_assert (is_assignable_type (^^N3::DelAnyAssign &, ^^const N3::DelAnyAssign &));\n+static_assert (is_assignable_type (^^N3::DelAnyAssign, ^^N3::DelAnyAssign &&));\n+static_assert (is_assignable_type (^^N3::DelAnyAssign, ^^const N3::DelAnyAssign &));\n+static_assert (!is_assignable_type (^^const N3::DelAnyAssign &, ^^N3::DelAnyAssign &&));\n+static_assert (!is_assignable_type (^^const N3::DelAnyAssign &, ^^const N3::DelAnyAssign &));\n+static_assert (!is_assignable_type (^^const N3::DelAnyAssign, ^^N3::DelAnyAssign &&));\n+static_assert (!is_assignable_type (^^const N3::DelAnyAssign, ^^const N3::DelAnyAssign &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^const int &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^void));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^void ()));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^void () const));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^void (&) ()));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^void (&&) ()));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^std::nullptr_t &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^std::initializer_list ));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^std::initializer_list &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^bool));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^bool &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::E));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::E &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::SE));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::SE &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::Empty));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::Empty &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::B));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::B &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::U));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::U &));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^void *));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int *));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::B *));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^N3::D *));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int N3::B::*));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int N3::D::*));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int []));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int [1]));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int (&) []));\n+static_assert (!is_assignable_type (^^N3::DelAnyAssign &, ^^int (&) [1]));\n+static_assert (!is_assignable_type (^^void (), ^^void));\n+static_assert (!is_assignable_type (^^void, ^^void ()));\n+static_assert (!is_assignable_type (^^void (), ^^void ()));\n+static_assert (!is_assignable_type (^^void (&) (), ^^void));\n+static_assert (!is_assignable_type (^^void, ^^void (&) ()));\n+static_assert (!is_assignable_type (^^void (&) (), ^^void (&) ()));\n+static_assert (!is_assignable_type (^^void (&) (), ^^void ()));\n+static_assert (!is_assignable_type (^^void (), ^^void (&) ()));\n+static_assert (is_assignable_type (^^int &, ^^N3::ImplicitTo ));\n+static_assert (!is_assignable_type (^^int &, ^^N3::ExplicitTo ));\n+static_assert (!is_assignable_type (^^int, ^^N3::ImplicitTo ));\n+static_assert (!is_assignable_type (^^int, ^^N3::ExplicitTo ));\n+static_assert (!is_assignable_type (^^const int, ^^N3::ImplicitTo ));\n+static_assert (!is_assignable_type (^^const int, ^^N3::ExplicitTo ));\n+static_assert (!is_assignable_type (^^const int &, ^^N3::ImplicitTo ));\n+static_assert (!is_assignable_type (^^const int &, ^^N3::ExplicitTo ));\n+static_assert (is_assignable_type (^^N3::DelImplicitTo &, ^^N3::DelImplicitTo ));\n+static_assert (is_assignable_type (^^N3::DelImplicitTo , ^^N3::DelImplicitTo ));\n+static_assert (!is_assignable_type (^^int &, ^^N3::DelImplicitTo ));\n+static_assert (!is_assignable_type (^^int, ^^N3::DelImplicitTo ));\n+static_assert (!is_assignable_type (^^const int &, ^^N3::DelImplicitTo ));\n+static_assert (!is_assignable_type (^^const int, ^^N3::DelImplicitTo ));\n+static_assert (!is_assignable_type (^^int &, ^^N3::DelExplicitTo ));\n+static_assert (!is_assignable_type (^^int, ^^N3::DelExplicitTo ));\n+static_assert (!is_assignable_type (^^const int &, ^^N3::DelExplicitTo ));\n+static_assert (!is_assignable_type (^^const int, ^^N3::DelExplicitTo ));\n+static_assert (is_assignable_type (^^N3::B &, ^^N3::B));\n+static_assert (is_assignable_type (^^N3::B &, ^^N3::D));\n+static_assert (is_assignable_type (^^N3::B &, ^^N3::B &));\n+static_assert (is_assignable_type (^^N3::B &, ^^N3::D &));\n+static_assert (!is_assignable_type (^^const N3::B &, ^^N3::B &));\n+static_assert (!is_assignable_type (^^const N3::B &, ^^N3::D &));\n+static_assert (!is_assignable_type (^^N3::D &, ^^N3::B));\n+static_assert (!is_assignable_type (^^N3::D &, ^^N3::B &));\n+static_assert (is_assignable_type (^^N3::B *&, ^^N3::B *));\n+static_assert (is_assignable_type (^^N3::B *&, ^^N3::D *));\n+static_assert (is_assignable_type (^^const N3::B *&, ^^N3::D *));\n+static_assert (is_assignable_type (^^const N3::B *&, ^^const N3::D *));\n+static_assert (is_assignable_type (^^N3::B *&, ^^N3::B *&));\n+static_assert (is_assignable_type (^^N3::B *&, ^^N3::D *&));\n+static_assert (is_assignable_type (^^const N3::B *&, ^^N3::B *&));\n+static_assert (is_assignable_type (^^const N3::B *&, ^^N3::D *&));\n+static_assert (!is_assignable_type (^^N3::B * const &, ^^N3::B *&));\n+static_assert (!is_assignable_type (^^N3::B * const &, ^^N3::D *&));\n+static_assert (!is_assignable_type (^^N3::D *&, ^^N3::B *));\n+static_assert (!is_assignable_type (^^N3::D *&, ^^N3::B *&));\n+static_assert (is_assignable_type (^^N3::MO &, ^^N3::MO));\n+static_assert (is_assignable_type (^^N3::MO &, ^^N3::MO &&));\n+static_assert (is_assignable_type (^^N3::MO, ^^N3::MO));\n+static_assert (is_assignable_type (^^N3::MO, ^^N3::MO &&));\n+static_assert (!is_assignable_type (^^const N3::MO &, ^^N3::MO));\n+static_assert (!is_assignable_type (^^const N3::MO &, ^^N3::MO &&));\n+static_assert (!is_assignable_type (^^N3::MO &, ^^const N3::MO &&));\n+static_assert (!is_assignable_type (^^N3::MO &, ^^N3::MO &));\n+static_assert (!is_assignable_type (^^N3::MO &, ^^const N3::MO &));\n+static_assert (!is_assignable_type (^^const N3::MO, ^^N3::MO));\n+static_assert (!is_assignable_type (^^const N3::MO, ^^N3::MO &&));\n+static_assert (!is_assignable_type (^^N3::MO, ^^const N3::MO &&));\n+static_assert (!is_assignable_type (^^N3::MO, ^^N3::MO &));\n+static_assert (!is_assignable_type (^^N3::MO, ^^const N3::MO &));\n+static_assert (!is_assignable_type (^^N3::NontrivialUnion &, ^^N3::NontrivialUnion));\n+static_assert (!is_assignable_type (^^N3::NontrivialUnion &, ^^N3::NontrivialUnion &&));\n+static_assert (!is_assignable_type (^^N3::NontrivialUnion &, ^^N3::NontrivialUnion &));\n+static_assert (!is_assignable_type (^^N3::NontrivialUnion &, ^^const N3::NontrivialUnion &));\n+static_assert (!is_assignable_type (^^N3::NontrivialUnion &, ^^const N3::NontrivialUnion &&));\n+static_assert (is_assignable_type (^^N3::Abstract &, ^^N3::Abstract));\n+static_assert (is_assignable_type (^^N3::Abstract &, ^^N3::Abstract &&));\n+static_assert (is_assignable_type (^^N3::Abstract &, ^^N3::Abstract &));\n+static_assert (is_assignable_type (^^N3::Abstract &, ^^const N3::Abstract &));\n+static_assert (is_assignable_type (^^N3::Abstract &, ^^const N3::Abstract &&));\n+static_assert (is_assignable_type (^^N3::Abstract &&, ^^N3::Abstract));\n+static_assert (is_assignable_type (^^N3::Abstract &&, ^^N3::Abstract &&));\n+static_assert (is_assignable_type (^^N3::Abstract &&, ^^N3::Abstract &));\n+static_assert (is_assignable_type (^^N3::Abstract &&, ^^const N3::Abstract &));\n+static_assert (is_assignable_type (^^N3::Abstract &&, ^^const N3::Abstract &&));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &, ^^N3::AbstractDelDtor));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &, ^^N3::AbstractDelDtor &&));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &, ^^N3::AbstractDelDtor &));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &, ^^const N3::AbstractDelDtor &));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &, ^^const N3::AbstractDelDtor &&));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &&, ^^N3::AbstractDelDtor));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &&, ^^N3::AbstractDelDtor &&));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &&, ^^N3::AbstractDelDtor &));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &&, ^^const N3::AbstractDelDtor &));\n+static_assert (is_assignable_type (^^N3::AbstractDelDtor &&, ^^const N3::AbstractDelDtor &&));\n+static_assert (is_assignable_type (^^N3::DelDef &, ^^N3::DelDef));\n+static_assert (is_assignable_type (^^N3::DelDef &, ^^N3::DelDef &&));\n+static_assert (is_assignable_type (^^N3::DelDef &, ^^N3::DelDef &));\n+static_assert (is_assignable_type (^^N3::DelDef &, ^^const N3::DelDef &));\n+static_assert (is_assignable_type (^^N3::DelDef &, ^^const N3::DelDef &&));\n+static_assert (is_assignable_type (^^N3::DelDef &&, ^^N3::DelDef));\n+static_assert (is_assignable_type (^^N3::DelDef &&, ^^N3::DelDef &&));\n+static_assert (is_assignable_type (^^N3::DelDef &&, ^^N3::DelDef &));\n+static_assert (is_assignable_type (^^N3::DelDef &&, ^^const N3::DelDef &));\n+static_assert (is_assignable_type (^^N3::DelDef &&, ^^const N3::DelDef &&));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^N3::Ellipsis));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const N3::Ellipsis));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^N3::Ellipsis &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const N3::Ellipsis &));\n+static_assert (is_assignable_type (^^N3::Ellipsis, ^^N3::Ellipsis));\n+static_assert (is_assignable_type (^^N3::Ellipsis, ^^const N3::Ellipsis));\n+static_assert (is_assignable_type (^^N3::Ellipsis, ^^N3::Ellipsis &));\n+static_assert (is_assignable_type (^^N3::Ellipsis, ^^const N3::Ellipsis &));\n+static_assert (!is_assignable_type (^^N3::Ellipsis &, ^^void));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^int));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const int));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^int &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const int &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^N3::Empty));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const N3::Empty));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^N3::Empty &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const N3::Empty &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^N3::E));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const N3::E));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^N3::E &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const N3::E &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^N3::SE));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const N3::SE));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^N3::SE &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const N3::SE &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^bool));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const bool));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^bool &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const bool &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^std::nullptr_t));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const std::nullptr_t));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^std::nullptr_t &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const std::nullptr_t &));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^void *));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const void *));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^void *&));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^const void *&));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^void ()));\n+static_assert (is_assignable_type (^^N3::Ellipsis &, ^^void (&) ()));\n+static_assert (is_assignable_type (^^N3::DelEllipsis &, ^^N3::DelEllipsis));\n+static_assert (is_assignable_type (^^N3::DelEllipsis &, ^^const N3::DelEllipsis));\n+static_assert (is_assignable_type (^^N3::DelEllipsis &, ^^N3::DelEllipsis &));\n+static_assert (is_assignable_type (^^N3::DelEllipsis &, ^^const N3::DelEllipsis &));\n+static_assert (is_assignable_type (^^N3::DelEllipsis, ^^N3::DelEllipsis));\n+static_assert (is_assignable_type (^^N3::DelEllipsis, ^^const N3::DelEllipsis));\n+static_assert (is_assignable_type (^^N3::DelEllipsis, ^^N3::DelEllipsis &));\n+static_assert (is_assignable_type (^^N3::DelEllipsis, ^^const N3::DelEllipsis &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^void));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^int));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const int));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^int &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const int &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^N3::Empty));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const N3::Empty));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^N3::Empty &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const N3::Empty &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^N3::E));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const N3::E));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^N3::E &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const N3::E &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^N3::SE));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const N3::SE));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^N3::SE &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const N3::SE &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^bool));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const bool));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^bool &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const bool &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const std::nullptr_t));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^std::nullptr_t &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const std::nullptr_t &));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^void *));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const void *));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^void *&));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^const void *&));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^void ()));\n+static_assert (!is_assignable_type (^^N3::DelEllipsis &, ^^void (&) ()));\n+static_assert (is_assignable_type (^^N3::FromArgs &, ^^int));\n+static_assert (is_assignable_type (^^N3::FromArgs &, ^^const int));\n+static_assert (!is_assignable_type (^^N3::FromArgs &, ^^N3::ImplicitTo ));\n+static_assert (!is_assignable_type (^^N3::FromArgs &, ^^N3::ImplicitTo ));\n+static_assert (!is_assignable_type (^^N3::FromArgs &, ^^N3::ExplicitTo ));\n+static_assert (!is_assignable_type (^^N3::FromArgs &, ^^N3::ExplicitTo ));\n+static_assert (!is_assignable_type (^^N3::DelFromArgs &, ^^int));\n+static_assert (!is_assignable_type (^^N3::DelFromArgs &, ^^const int));\n+static_assert (is_assignable_type (^^void (*&) (), ^^N3::ImplicitTo ));\n+static_assert (!is_assignable_type (^^void (*&) (), ^^N3::ExplicitTo ));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::UAssignAll));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^const N3::UAssignAll));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::UAssignAll &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^const N3::UAssignAll &));\n+static_assert (is_assignable_type (^^N3::UAssignAll, ^^N3::UAssignAll));\n+static_assert (is_assignable_type (^^N3::UAssignAll, ^^const N3::UAssignAll));\n+static_assert (is_assignable_type (^^N3::UAssignAll, ^^N3::UAssignAll &));\n+static_assert (is_assignable_type (^^N3::UAssignAll, ^^const N3::UAssignAll &));\n+static_assert (!is_assignable_type (^^N3::UAssignAll &, ^^void));\n+static_assert (!is_assignable_type (^^const N3::UAssignAll &, ^^void));\n+static_assert (!is_assignable_type (^^const N3::UAssignAll &, ^^N3::UAssignAll));\n+static_assert (!is_assignable_type (^^const N3::UAssignAll &, ^^const N3::UAssignAll));\n+static_assert (!is_assignable_type (^^const N3::UAssignAll &, ^^N3::UAssignAll &));\n+static_assert (!is_assignable_type (^^const N3::UAssignAll &, ^^const N3::UAssignAll &));\n+static_assert (!is_assignable_type (^^N3::UAssignAll &, ^^void () const));\n+static_assert (!is_assignable_type (^^N3::UAssignAll &, ^^void () &));\n+static_assert (!is_assignable_type (^^N3::UAssignAll &, ^^void () const volatile &&));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^int));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^int &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::E));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::E &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::SE));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::SE &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^double));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^double &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::Empty));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::Empty &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::B));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::B &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::U));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^N3::U &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^std::nullptr_t));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^std::nullptr_t &));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^void ()));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^void (&) ()));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^void (*) ()));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^void (*&) ()));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^int *));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^int *&));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^void *));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^void *&));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^const int *));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^const int *&));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^const void *));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^const void *&));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^int [1]));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^int (&) [1]));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^int []));\n+static_assert (is_assignable_type (^^N3::UAssignAll &, ^^int (&) []));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^int));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^int &));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::E));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::E &));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::SE));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::SE &));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^double));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^double &));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::Empty));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::Empty &));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::B));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::B &));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::U));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^N3::U &));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^std::nullptr_t &));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^void ()));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^void (&) ()));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^void () const));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^void (*) ()));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^void (*&) ()));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^int *));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^int *&));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^void *));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^void *&));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^const int *));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^const int *&));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^const void *));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^const void *&));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^int [1]));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^int (&) [1]));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^int []));\n+static_assert (!is_assignable_type (^^N3::UDelAssignAll &, ^^int (&) []));\n+static_assert (!is_assignable_type (^^void (&) (), ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^std::nullptr_t, ^^void (&) ()));\n+static_assert (!is_assignable_type (^^void (&) (), ^^int []));\n+static_assert (!is_assignable_type (^^int [], ^^void (&) ()));\n+static_assert (!is_assignable_type (^^int [], ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^std::nullptr_t, ^^int []));\n+static_assert (!is_assignable_type (^^int [1], ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^std::nullptr_t, ^^int [1]));\n+static_assert (!is_assignable_type (^^void, ^^std::nullptr_t));\n+static_assert (!is_assignable_type (^^std::nullptr_t, ^^void));\n+static_assert (!is_assignable_type (^^const N3::D &, ^^N3::B &));\n+static_assert (!is_assignable_type (^^const N3::B &, ^^N3::B &));\n+static_assert (is_assignable_type (^^N3::B &, ^^const N3::D &));\n+static_assert (is_assignable_type (^^N3::B &, ^^const N3::B &));\n+static_assert (is_assignable_type (^^int &, ^^const int &));\n+static_assert (is_assignable_type (^^int &, ^^const double &));\n+\n+static_assert (is_copy_assignable_type (^^int));\n+static_assert (is_copy_assignable_type (^^float));\n+static_assert (is_copy_assignable_type (^^EnumType));\n+static_assert (is_copy_assignable_type (^^int *));\n+static_assert (is_copy_assignable_type (^^int (*) (int)));\n+static_assert (is_copy_assignable_type (^^int (ClassType::*)));\n+static_assert (is_copy_assignable_type (^^int (ClassType::*) (int)));\n+static_assert (is_copy_assignable_type (^^NoexceptCopyAssignClass));\n+static_assert (is_copy_assignable_type (^^ExceptCopyAssignClass));\n+static_assert (!is_copy_assignable_type (^^void));\n+static_assert (!is_copy_assignable_type (^^int [2]));\n+static_assert (!is_copy_assignable_type (^^float [][3]));\n+static_assert (!is_copy_assignable_type (^^EnumType [2][3][4]));\n+static_assert (!is_copy_assignable_type (^^int * [3]));\n+static_assert (!is_copy_assignable_type (^^int (* [][2]) (int)));\n+static_assert (!is_copy_assignable_type (^^int (ClassType::* [2][3])));\n+static_assert (!is_copy_assignable_type (^^int (ClassType::* [][2][3]) (int)));\n+static_assert (!is_copy_assignable_type (^^ClassType (unsigned) const &));\n+static_assert (!is_copy_assignable_type (^^bool (ClassType) const));\n+static_assert (!is_copy_assignable_type (^^bool (...) &&));\n+static_assert (!is_copy_assignable_type (^^EnumType (int, ...)));\n+static_assert (!is_copy_assignable_type (^^NoexceptMoveAssignClass));\n+static_assert (!is_copy_assignable_type (^^ExceptMoveAssignClass));\n+static_assert (!is_copy_assignable_type (^^DeletedCopyAssignClass));\n+static_assert (!is_copy_assignable_type (^^DeletedMoveAssignClass));\n+\n+static_assert (is_move_assignable_type (^^int));\n+static_assert (is_move_assignable_type (^^float));\n+static_assert (is_move_assignable_type (^^EnumType));\n+static_assert (is_move_assignable_type (^^int *));\n+static_assert (is_move_assignable_type (^^int (*) (int)));\n+static_assert (is_move_assignable_type (^^int (ClassType::*)));\n+static_assert (is_move_assignable_type (^^int (ClassType::*) (int)));\n+static_assert (is_move_assignable_type (^^NoexceptMoveAssignClass));\n+static_assert (is_move_assignable_type (^^ExceptMoveAssignClass));\n+static_assert (is_move_assignable_type (^^NoexceptCopyAssignClass));\n+static_assert (is_move_assignable_type (^^ExceptCopyAssignClass));\n+static_assert (!is_move_assignable_type (^^void));\n+static_assert (!is_move_assignable_type (^^int [2]));\n+static_assert (!is_move_assignable_type (^^float [][3]));\n+static_assert (!is_move_assignable_type (^^EnumType [2][3][4]));\n+static_assert (!is_move_assignable_type (^^int * [3]));\n+static_assert (!is_move_assignable_type (^^int (* [][2]) (int)));\n+static_assert (!is_move_assignable_type (^^int (ClassType::* [2][3])));\n+static_assert (!is_move_assignable_type (^^int (ClassType::* [][2][3]) (int)));\n+static_assert (!is_move_assignable_type (^^ClassType (unsigned) const &));\n+static_assert (!is_move_assignable_type (^^bool (ClassType) const));\n+static_assert (!is_move_assignable_type (^^bool (...) &&));\n+static_assert (!is_move_assignable_type (^^EnumType (int, ...)));\n+static_assert (!is_move_assignable_type (^^DeletedCopyAssignClass));\n+static_assert (!is_move_assignable_type (^^DeletedMoveAssignClass));\n+\n+static_assert (is_destructible_type (^^int));\n+static_assert (is_destructible_type (^^const int));\n+static_assert (is_destructible_type (^^bool));\n+static_assert (is_destructible_type (^^const bool));\n+static_assert (is_destructible_type (^^int *));\n+static_assert (is_destructible_type (^^void *));\n+static_assert (is_destructible_type (^^int N2::Der::*));\n+static_assert (is_destructible_type (^^const int N2::Der::*));\n+static_assert (is_destructible_type (^^void (N2::Der::*) () const));\n+static_assert (is_destructible_type (^^void (*) ()));\n+static_assert (is_destructible_type (^^N2::En));\n+static_assert (is_destructible_type (^^const N2::En));\n+static_assert (is_destructible_type (^^N2::En2));\n+static_assert (is_destructible_type (^^const N2::En2));\n+static_assert (is_destructible_type (^^N2::OpE));\n+static_assert (is_destructible_type (^^const N2::OpE));\n+static_assert (is_destructible_type (^^N2::OpSE));\n+static_assert (is_destructible_type (^^const N2::OpSE));\n+static_assert (is_destructible_type (^^std::nullptr_t));\n+static_assert (is_destructible_type (^^const std::nullptr_t));\n+static_assert (is_destructible_type (^^N2::Der));\n+static_assert (is_destructible_type (^^const N2::Der));\n+static_assert (is_destructible_type (^^N2::Aggr));\n+static_assert (is_destructible_type (^^const N2::Aggr));\n+static_assert (is_destructible_type (^^N2::E));\n+static_assert (is_destructible_type (^^const N2::E));\n+static_assert (is_destructible_type (^^N2::U1));\n+static_assert (is_destructible_type (^^const N2::U1));\n+static_assert (is_destructible_type (^^N2::Abstract1));\n+static_assert (is_destructible_type (^^const N2::Abstract1));\n+static_assert (is_destructible_type (^^int [1]));\n+static_assert (is_destructible_type (^^const int [1]));\n+static_assert (is_destructible_type (^^int [1][2]));\n+static_assert (is_destructible_type (^^const int [1][2]));\n+static_assert (is_destructible_type (^^int &));\n+static_assert (is_destructible_type (^^int &&));\n+static_assert (is_destructible_type (^^int (&) [1]));\n+static_assert (is_destructible_type (^^const int (&) [1]));\n+static_assert (is_destructible_type (^^void (&) ()));\n+static_assert (is_destructible_type (^^N2::Ellipsis));\n+static_assert (is_destructible_type (^^const N2::Ellipsis));\n+static_assert (is_destructible_type (^^N2::Abstract2));\n+static_assert (is_destructible_type (^^const N2::Abstract2));\n+static_assert (is_destructible_type (^^N2::Aggr2));\n+static_assert (is_destructible_type (^^const N2::Aggr2));\n+static_assert (is_destructible_type (^^N2::DelDef));\n+static_assert (is_destructible_type (^^const N2::DelDef));\n+static_assert (is_destructible_type (^^N2::DelCopy));\n+static_assert (is_destructible_type (^^const N2::DelCopy));\n+static_assert (is_destructible_type (^^N2::DelEllipsis));\n+static_assert (is_destructible_type (^^const N2::DelEllipsis));\n+static_assert (is_destructible_type (^^std::initializer_list ));\n+static_assert (is_destructible_type (^^const std::initializer_list ));\n+static_assert (is_destructible_type (^^std::initializer_list ));\n+static_assert (!is_destructible_type (^^void));\n+static_assert (!is_destructible_type (^^const void));\n+static_assert (!is_destructible_type (^^void ()));\n+static_assert (!is_destructible_type (^^void () const));\n+static_assert (!is_destructible_type (^^int []));\n+static_assert (!is_destructible_type (^^const int []));\n+static_assert (!is_destructible_type (^^N2::Del));\n+static_assert (!is_destructible_type (^^const N2::Del));\n+static_assert (!is_destructible_type (^^N2::AbstractDelDtor));\n+static_assert (!is_destructible_type (^^const N2::AbstractDelDtor));\n+static_assert (!is_destructible_type (^^int [][1]));\n+static_assert (!is_destructible_type (^^const int [][1]));\n+static_assert (!is_destructible_type (^^N2::Del [1]));\n+static_assert (!is_destructible_type (^^const N2::Del [1]));\n+static_assert (!is_destructible_type (^^N2::Del []));\n+static_assert (!is_destructible_type (^^const N2::Del []));\n+static_assert (!is_destructible_type (^^N2::NontrivialUnion));\n+static_assert (is_destructible_type (^^N2::UnusualCopy));\n+\n+static_assert (is_trivially_default_constructible_type (^^int));\n+static_assert (is_trivially_default_constructible_type (^^TType));\n+static_assert (is_trivially_default_constructible_type (^^PODType));\n+static_assert (!is_trivially_default_constructible_type (^^NType));\n+static_assert (!is_trivially_default_constructible_type (^^SLType));\n+static_assert (!is_trivially_default_constructible_type (^^N1::DelDef));\n+static_assert (!is_trivially_default_constructible_type (^^N1::Abstract));\n+static_assert (!is_trivially_default_constructible_type (^^N1::Ellipsis));\n+static_assert (!is_trivially_default_constructible_type (^^N1::DelEllipsis));\n+static_assert (!is_trivially_default_constructible_type (^^N1::Any));\n+static_assert (!is_trivially_default_constructible_type (^^N1::DelCopy));\n+static_assert (!is_trivially_default_constructible_type (^^N1::DelDtor));\n+static_assert (!is_trivially_default_constructible_type (^^N1::Nontrivial));\n+static_assert (is_trivially_default_constructible_type (^^HasTemplateCtor));\n+\n+static_assert (!is_trivially_default_constructible_type (^^int []));\n+struct A { };\n+static_assert (!is_trivially_default_constructible_type (^^A []));\n+struct B { B () { } };\n+static_assert (!is_trivially_default_constructible_type (^^B []));\n+\n+static_assert (is_trivially_copy_constructible_type (^^int));\n+static_assert (is_trivially_copy_constructible_type (^^TType));\n+static_assert (is_trivially_copy_constructible_type (^^PODType));\n+static_assert (!is_trivially_copy_constructible_type (^^NType));\n+static_assert (!is_trivially_copy_constructible_type (^^SLType));\n+static_assert (is_trivially_copy_constructible_type (^^N1::DelDef));\n+static_assert (!is_trivially_copy_constructible_type (^^N1::Abstract));\n+static_assert (is_trivially_copy_constructible_type (^^N1::Ellipsis));\n+static_assert (is_trivially_copy_constructible_type (^^N1::DelEllipsis));\n+static_assert (is_trivially_copy_constructible_type (^^N1::Any));\n+static_assert (!is_trivially_copy_constructible_type (^^N1::DelCopy));\n+static_assert (!is_trivially_copy_constructible_type (^^N1::DelDtor));\n+static_assert (!is_trivially_copy_constructible_type (^^N1::Nontrivial));\n+static_assert (!is_trivially_copy_constructible_type (^^N1::UnusualCopy));\n+static_assert (is_trivially_copy_constructible_type (^^CopyConsOnlyType));\n+static_assert (!is_trivially_copy_constructible_type (^^MoveConsOnlyType));\n+static_assert (is_trivially_copy_constructible_type (^^HasTemplateCCtor));\n+static_assert (!is_trivially_copy_constructible_type (^^MoveOnly));\n+static_assert (!is_trivially_copy_constructible_type (^^MoveOnly2));\n+static_assert (!is_trivially_copy_constructible_type (^^void));\n+\n+static_assert (is_trivially_move_constructible_type (^^int));\n+static_assert (is_trivially_move_constructible_type (^^TType));\n+static_assert (is_trivially_move_constructible_type (^^PODType));\n+static_assert (!is_trivially_move_constructible_type (^^NType));\n+static_assert (!is_trivially_move_constructible_type (^^SLType));\n+static_assert (is_trivially_move_constructible_type (^^N1::DelDef));\n+static_assert (!is_trivially_move_constructible_type (^^N1::Abstract));\n+static_assert (is_trivially_move_constructible_type (^^N1::Ellipsis));\n+static_assert (is_trivially_move_constructible_type (^^N1::DelEllipsis));\n+static_assert (is_trivially_move_constructible_type (^^N1::Any));\n+static_assert (!is_trivially_move_constructible_type (^^N1::DelCopy));\n+static_assert (!is_trivially_move_constructible_type (^^N1::DelDtor));\n+static_assert (!is_trivially_move_constructible_type (^^N1::Nontrivial));\n+static_assert (!is_trivially_move_constructible_type (^^N1::UnusualCopy));\n+static_assert (!is_trivially_move_constructible_type (^^CopyConsOnlyType));\n+static_assert (is_trivially_move_constructible_type (^^MoveConsOnlyType));\n+static_assert (!is_trivially_move_constructible_type (^^HasTemplateCCtor));\n+static_assert (is_trivially_move_constructible_type (^^MoveOnly));\n+static_assert (!is_trivially_move_constructible_type (^^MoveOnly2));\n+static_assert (!is_trivially_move_constructible_type (^^void));\n+\n+static_assert (!is_trivially_assignable_type (^^int, ^^int));\n+static_assert (is_trivially_assignable_type (^^int &, ^^int));\n+static_assert (is_trivially_assignable_type (^^int &, ^^int &));\n+static_assert (is_trivially_assignable_type (^^int &, ^^int &&));\n+static_assert (is_trivially_assignable_type (^^int &, ^^const int &));\n+static_assert (!is_trivially_assignable_type (^^int &, ^^int *));\n+static_assert (!is_trivially_assignable_type (^^int &, ^^void *));\n+static_assert (!is_trivially_assignable_type (^^const int, ^^int));\n+static_assert (!is_trivially_assignable_type (^^const int &, ^^int));\n+static_assert (!is_trivially_assignable_type (^^const int &, ^^const int &));\n+static_assert (is_trivially_assignable_type (^^const int *&, ^^int *));\n+static_assert (!is_trivially_assignable_type (^^int *&, ^^const int *&));\n+static_assert (!is_trivially_assignable_type (^^int *&, ^^const int &));\n+static_assert (!is_trivially_assignable_type (^^const int *&, ^^void *));\n+static_assert (is_trivially_assignable_type (^^const void *&, ^^void *));\n+static_assert (is_trivially_assignable_type (^^const void *&, ^^int *));\n+static_assert (is_trivially_assignable_type (^^TType, ^^TType));\n+static_assert (is_trivially_assignable_type (^^TType &, ^^TType));\n+static_assert (is_trivially_assignable_type (^^TType &, ^^TType &));\n+static_assert (is_trivially_assignable_type (^^TType &, ^^TType &&));\n+static_assert (is_trivially_assignable_type (^^TType &, ^^const TType &));\n+static_assert (is_trivially_assignable_type (^^PODType, ^^PODType));\n+static_assert (!is_trivially_assignable_type (^^NType &, ^^NType &));\n+static_assert (is_trivially_assignable_type (^^SLType, ^^SLType));\n+static_assert (is_trivially_assignable_type (^^N3::Empty, ^^N3::Empty));\n+static_assert (!is_trivially_assignable_type (^^N3::Abstract, ^^N3::Abstract));\n+static_assert (is_trivially_assignable_type (^^N3::Ellipsis, ^^N3::Ellipsis));\n+static_assert (is_trivially_assignable_type (^^N3::DelEllipsis, ^^N3::DelEllipsis));\n+static_assert (is_trivially_assignable_type (^^N3::Any, ^^N3::Any));\n+static_assert (is_trivially_assignable_type (^^N3::DelDef, ^^N3::DelDef));\n+static_assert (is_trivially_assignable_type (^^N3::DelCopy, ^^N3::DelCopy));\n+static_assert (!is_trivially_assignable_type (^^N3::Nontrivial, ^^N3::Nontrivial));\n+static_assert (is_trivially_assignable_type (^^N3::AnyAssign, ^^N3::AnyAssign));\n+static_assert (is_trivially_assignable_type (^^N3::DelAnyAssign, ^^N3::DelAnyAssign));\n+static_assert (is_trivially_assignable_type (^^N3::DelCopyAssign, ^^N3::DelCopyAssign));\n+static_assert (is_trivially_assignable_type (^^N3::MO, ^^N3::MO));\n+static_assert (is_trivially_assignable_type (^^N3::MO, ^^N3::MO &&));\n+static_assert (!is_trivially_assignable_type (^^N3::MO, ^^N3::MO &));\n+static_assert (!is_trivially_assignable_type (^^N3::MO, ^^const N3::MO &));\n+static_assert (!is_trivially_assignable_type (^^CopyConsOnlyType, ^^CopyConsOnlyType));\n+static_assert (!is_trivially_assignable_type (^^CopyConsOnlyType, ^^const CopyConsOnlyType &));\n+static_assert (!is_trivially_assignable_type (^^MoveConsOnlyType, ^^MoveConsOnlyType));\n+static_assert (!is_trivially_assignable_type (^^MoveConsOnlyType, ^^MoveConsOnlyType &&));\n+static_assert (!is_trivially_assignable_type (^^HasTemplateCAssign, ^^HasTemplateCAssign));\n+static_assert (is_trivially_assignable_type (^^HasTemplateCAssign, ^^const HasTemplateCAssign &));\n+static_assert (is_trivially_assignable_type (^^ClassType, ^^DerivedType));\n+static_assert (is_trivially_assignable_type (^^ClassType, ^^DerivedType &));\n+static_assert (is_trivially_assignable_type (^^ClassType, ^^DerivedType &&));\n+static_assert (is_trivially_assignable_type (^^ClassType, ^^const DerivedType &));\n+static_assert (is_trivially_assignable_type (^^MoveOnly3, ^^MoveOnly3));\n+static_assert (is_trivially_assignable_type (^^MoveOnly3, ^^MoveOnly3 &&));\n+static_assert (!is_trivially_assignable_type (^^MoveOnly3, ^^MoveOnly3 &));\n+static_assert (!is_trivially_assignable_type (^^MoveOnly3, ^^const MoveOnly3 &));\n+static_assert (!is_trivially_assignable_type (^^MoveOnly4, ^^MoveOnly4));\n+\n+static_assert (is_trivially_copy_assignable_type (^^int));\n+static_assert (is_trivially_copy_assignable_type (^^TType));\n+static_assert (is_trivially_copy_assignable_type (^^PODType));\n+static_assert (!is_trivially_copy_assignable_type (^^NType));\n+static_assert (is_trivially_copy_assignable_type (^^SLType));\n+static_assert (is_trivially_copy_assignable_type (^^N3::Empty));\n+static_assert (!is_trivially_copy_assignable_type (^^N3::Abstract));\n+static_assert (is_trivially_copy_assignable_type (^^N3::Ellipsis));\n+static_assert (is_trivially_copy_assignable_type (^^N3::DelEllipsis));\n+static_assert (is_trivially_copy_assignable_type (^^N3::Any));\n+static_assert (is_trivially_copy_assignable_type (^^N3::DelDef));\n+static_assert (is_trivially_copy_assignable_type (^^N3::DelCopy));\n+static_assert (!is_trivially_copy_assignable_type (^^N3::Nontrivial));\n+static_assert (is_trivially_copy_assignable_type (^^N3::AnyAssign));\n+static_assert (is_trivially_copy_assignable_type (^^N3::DelAnyAssign));\n+static_assert (!is_trivially_copy_assignable_type (^^N3::DelCopyAssign));\n+static_assert (!is_trivially_copy_assignable_type (^^N3::MO));\n+static_assert (!is_trivially_copy_assignable_type (^^CopyConsOnlyType));\n+static_assert (!is_trivially_copy_assignable_type (^^MoveConsOnlyType));\n+static_assert (is_trivially_copy_assignable_type (^^HasTemplateCAssign));\n+static_assert (!is_trivially_copy_assignable_type (^^MoveOnly3));\n+static_assert (!is_trivially_copy_assignable_type (^^MoveOnly4));\n+static_assert (!is_trivially_copy_assignable_type (^^void));\n+\n+static_assert (is_trivially_move_assignable_type (^^int));\n+static_assert (is_trivially_move_assignable_type (^^TType));\n+static_assert (is_trivially_move_assignable_type (^^PODType));\n+static_assert (!is_trivially_move_assignable_type (^^NType));\n+static_assert (is_trivially_move_assignable_type (^^SLType));\n+static_assert (is_trivially_move_assignable_type (^^N3::Empty));\n+static_assert (!is_trivially_move_assignable_type (^^N3::Abstract));\n+static_assert (is_trivially_move_assignable_type (^^N3::Ellipsis));\n+static_assert (is_trivially_move_assignable_type (^^N3::DelEllipsis));\n+static_assert (is_trivially_move_assignable_type (^^N3::Any));\n+static_assert (is_trivially_move_assignable_type (^^N3::DelDef));\n+static_assert (is_trivially_move_assignable_type (^^N3::DelCopy));\n+static_assert (!is_trivially_move_assignable_type (^^N3::Nontrivial));\n+static_assert (is_trivially_move_assignable_type (^^N3::AnyAssign));\n+static_assert (is_trivially_move_assignable_type (^^N3::DelAnyAssign));\n+static_assert (is_trivially_move_assignable_type (^^N3::DelCopyAssign));\n+static_assert (is_trivially_move_assignable_type (^^N3::MO));\n+static_assert (!is_trivially_move_assignable_type (^^CopyConsOnlyType));\n+static_assert (!is_trivially_move_assignable_type (^^MoveConsOnlyType));\n+static_assert (!is_trivially_move_assignable_type (^^HasTemplateCAssign));\n+static_assert (is_trivially_move_assignable_type (^^MoveOnly3));\n+static_assert (!is_trivially_move_assignable_type (^^MoveOnly4));\n+static_assert (!is_trivially_move_assignable_type (^^void));\n+\n+static_assert (is_trivially_destructible_type (^^int));\n+static_assert (is_trivially_destructible_type (^^TType));\n+static_assert (is_trivially_destructible_type (^^PODType));\n+static_assert (!is_trivially_destructible_type (^^NType));\n+static_assert (!is_trivially_destructible_type (^^SLType));\n+\n+static_assert (is_nothrow_default_constructible_type (^^int));\n+static_assert (is_nothrow_default_constructible_type (^^float));\n+static_assert (is_nothrow_default_constructible_type (^^EnumType));\n+static_assert (is_nothrow_default_constructible_type (^^int *));\n+static_assert (is_nothrow_default_constructible_type (^^int (*) (int)));\n+static_assert (is_nothrow_default_constructible_type (^^int (ClassType:: *)));\n+static_assert (is_nothrow_default_constructible_type (^^int (ClassType:: *) (int)));\n+static_assert (is_nothrow_default_constructible_type (^^int [2]));\n+static_assert (is_nothrow_default_constructible_type (^^EnumType [2][3][4]));\n+static_assert (is_nothrow_default_constructible_type (^^int * [3]));\n+static_assert (is_nothrow_default_constructible_type (^^int (ClassType::* [2][3])));\n+static_assert (is_nothrow_default_constructible_type (^^ClassType));\n+static_assert (is_nothrow_default_constructible_type (^^NoexceptDefaultClass));\n+static_assert (!is_nothrow_default_constructible_type (^^void));\n+static_assert (!is_nothrow_default_constructible_type (^^int []));\n+static_assert (!is_nothrow_default_constructible_type (^^float [][3]));\n+static_assert (!is_nothrow_default_constructible_type (^^int (* [][2]) (int)));\n+static_assert (!is_nothrow_default_constructible_type (^^int (ClassType:: * [][2][3]) (int)));\n+static_assert (!is_nothrow_default_constructible_type (^^ThrowDefaultClass));\n+static_assert (!is_nothrow_default_constructible_type (^^ExceptDefaultClass));\n+\n+static_assert (is_nothrow_copy_constructible_type (^^int));\n+static_assert (is_nothrow_copy_constructible_type (^^float));\n+static_assert (is_nothrow_copy_constructible_type (^^EnumType));\n+static_assert (is_nothrow_copy_constructible_type (^^int *));\n+static_assert (is_nothrow_copy_constructible_type (^^int (*) (int)));\n+static_assert (is_nothrow_copy_constructible_type (^^int (ClassType:: *)));\n+static_assert (is_nothrow_copy_constructible_type (^^int (ClassType:: *) (int)));\n+static_assert (is_nothrow_copy_constructible_type (^^NoexceptCopyConsClass));\n+static_assert (is_nothrow_copy_constructible_type (^^const NoexceptCopyConsClass));\n+static_assert (!is_nothrow_copy_constructible_type (^^void));\n+static_assert (!is_nothrow_copy_constructible_type (^^int [2]));\n+static_assert (!is_nothrow_copy_constructible_type (^^int []));\n+static_assert (!is_nothrow_copy_constructible_type (^^float [][3]));\n+static_assert (!is_nothrow_copy_constructible_type (^^EnumType [2][3][4]));\n+static_assert (!is_nothrow_copy_constructible_type (^^int * [3]));\n+static_assert (!is_nothrow_copy_constructible_type (^^int (* [][2]) (int)));\n+static_assert (!is_nothrow_copy_constructible_type (^^int (ClassType:: * [2][3])));\n+static_assert (!is_nothrow_copy_constructible_type (^^int (ClassType:: * [][2][3]) (int)));\n+static_assert (!is_nothrow_copy_constructible_type (^^ClassType (unsigned) const &));\n+static_assert (!is_nothrow_copy_constructible_type (^^bool (ClassType) const));\n+static_assert (!is_nothrow_copy_constructible_type (^^bool (...) &&));\n+static_assert (!is_nothrow_copy_constructible_type (^^EnumType (int, ...)));\n+static_assert (!is_nothrow_copy_constructible_type (^^volatile NoexceptCopyConsClass));\n+static_assert (!is_nothrow_copy_constructible_type (^^ThrowCopyConsClass));\n+static_assert (!is_nothrow_copy_constructible_type (^^ExceptCopyConsClass));\n+\n+static_assert (is_nothrow_move_constructible_type (^^int));\n+static_assert (is_nothrow_move_constructible_type (^^float));\n+static_assert (is_nothrow_move_constructible_type (^^EnumType));\n+static_assert (is_nothrow_move_constructible_type (^^int *));\n+static_assert (is_nothrow_move_constructible_type (^^int (*) (int)));\n+static_assert (is_nothrow_move_constructible_type (^^int (ClassType:: *)));\n+static_assert (is_nothrow_move_constructible_type (^^int (ClassType:: *) (int)));\n+static_assert (is_nothrow_move_constructible_type (^^NoexceptMoveConsClass));\n+static_assert (!is_nothrow_move_constructible_type (^^void));\n+static_assert (!is_nothrow_move_constructible_type (^^int [2]));\n+static_assert (!is_nothrow_move_constructible_type (^^int []));\n+static_assert (!is_nothrow_move_constructible_type (^^float [][3]));\n+static_assert (!is_nothrow_move_constructible_type (^^EnumType [2][3][4]));\n+static_assert (!is_nothrow_move_constructible_type (^^int * [3]));\n+static_assert (!is_nothrow_move_constructible_type (^^int (* [][2]) (int)));\n+static_assert (!is_nothrow_move_constructible_type (^^int (ClassType:: * [2][3])));\n+static_assert (!is_nothrow_move_constructible_type (^^int (ClassType:: * [][2][3]) (int)));\n+static_assert (!is_nothrow_move_constructible_type (^^ClassType (unsigned) const &));\n+static_assert (!is_nothrow_move_constructible_type (^^bool (ClassType) const));\n+static_assert (!is_nothrow_move_constructible_type (^^bool (...) &&));\n+static_assert (!is_nothrow_move_constructible_type (^^EnumType (int, ...)));\n+static_assert (!is_nothrow_move_constructible_type (^^const NoexceptMoveConsClass));\n+static_assert (!is_nothrow_move_constructible_type (^^volatile NoexceptMoveConsClass));\n+static_assert (!is_nothrow_move_constructible_type (^^ThrowMoveConsClass));\n+static_assert (!is_nothrow_move_constructible_type (^^ExceptMoveConsClass));\n+\n+static_assert (is_nothrow_assignable_type (^^int &, ^^int));\n+static_assert (is_nothrow_assignable_type (^^int &, ^^const int));\n+static_assert (is_nothrow_assignable_type (^^NoexceptCopyAssignClass &, ^^const NoexceptCopyAssignClass &));\n+static_assert (is_nothrow_assignable_type (^^NoexceptMoveAssignClass &, ^^NoexceptMoveAssignClass &&));\n+static_assert (is_nothrow_assignable_type (^^NoexceptCopyAssignClass &, ^^NoexceptCopyAssignClass &&));\n+static_assert (!is_nothrow_assignable_type (^^int, ^^int));\n+static_assert (!is_nothrow_assignable_type (^^int, ^^const int));\n+static_assert (!is_nothrow_assignable_type (^^ExceptCopyAssignClass &, ^^const ExceptCopyAssignClass &));\n+static_assert (!is_nothrow_assignable_type (^^ExceptMoveAssignClass &, ^^ExceptMoveAssignClass &&));\n+static_assert (!is_nothrow_assignable_type (^^NoexceptMoveAssignClass &, ^^const NoexceptMoveAssignClass &));\n+\n+static_assert (is_nothrow_copy_assignable_type (^^int));\n+static_assert (is_nothrow_copy_assignable_type (^^float));\n+static_assert (is_nothrow_copy_assignable_type (^^EnumType));\n+static_assert (is_nothrow_copy_assignable_type (^^int *));\n+static_assert (is_nothrow_copy_assignable_type (^^int (*) (int)));\n+static_assert (is_nothrow_copy_assignable_type (^^int (ClassType:: *)));\n+static_assert (is_nothrow_copy_assignable_type (^^int (ClassType:: *) (int)));\n+static_assert (is_nothrow_copy_assignable_type (^^NoexceptCopyAssignClass));\n+static_assert (!is_nothrow_copy_assignable_type (^^void));\n+static_assert (!is_nothrow_copy_assignable_type (^^int [2]));\n+static_assert (!is_nothrow_copy_assignable_type (^^float [][3]));\n+static_assert (!is_nothrow_copy_assignable_type (^^EnumType [2][3][4]));\n+static_assert (!is_nothrow_copy_assignable_type (^^int * [3]));\n+static_assert (!is_nothrow_copy_assignable_type (^^int (* [][2]) (int)));\n+static_assert (!is_nothrow_copy_assignable_type (^^int (ClassType:: * [2][3])));\n+static_assert (!is_nothrow_copy_assignable_type (^^int (ClassType:: * [][2][3]) (int)));\n+static_assert (!is_nothrow_copy_assignable_type (^^ClassType (unsigned) const &));\n+static_assert (!is_nothrow_copy_assignable_type (^^bool (ClassType) const));\n+static_assert (!is_nothrow_copy_assignable_type (^^bool (...) &&));\n+static_assert (!is_nothrow_copy_assignable_type (^^EnumType (int, ...)));\n+static_assert (!is_nothrow_copy_assignable_type (^^ExceptCopyAssignClass));\n+static_assert (!is_nothrow_copy_assignable_type (^^NoexceptMoveAssignClass));\n+static_assert (!is_nothrow_copy_assignable_type (^^ExceptMoveAssignClass));\n+static_assert (!is_nothrow_copy_assignable_type (^^DeletedCopyAssignClass));\n+static_assert (!is_nothrow_copy_assignable_type (^^DeletedMoveAssignClass));\n+\n+static_assert (is_nothrow_move_assignable_type (^^int));\n+static_assert (is_nothrow_move_assignable_type (^^float));\n+static_assert (is_nothrow_move_assignable_type (^^EnumType));\n+static_assert (is_nothrow_move_assignable_type (^^int *));\n+static_assert (is_nothrow_move_assignable_type (^^int (*) (int)));\n+static_assert (is_nothrow_move_assignable_type (^^int (ClassType:: *)));\n+static_assert (is_nothrow_move_assignable_type (^^int (ClassType:: *) (int)));\n+static_assert (is_nothrow_move_assignable_type (^^NoexceptMoveAssignClass));\n+static_assert (is_nothrow_move_assignable_type (^^NoexceptCopyAssignClass));\n+static_assert (!is_nothrow_move_assignable_type (^^void));\n+static_assert (!is_nothrow_move_assignable_type (^^int [2]));\n+static_assert (!is_nothrow_move_assignable_type (^^float [][3]));\n+static_assert (!is_nothrow_move_assignable_type (^^EnumType [2][3][4]));\n+static_assert (!is_nothrow_move_assignable_type (^^int * [3]));\n+static_assert (!is_nothrow_move_assignable_type (^^int (* [][2]) (int)));\n+static_assert (!is_nothrow_move_assignable_type (^^int (ClassType:: * [2][3])));\n+static_assert (!is_nothrow_move_assignable_type (^^int (ClassType:: * [][2][3]) (int)));\n+static_assert (!is_nothrow_move_assignable_type (^^ClassType (unsigned) const &));\n+static_assert (!is_nothrow_move_assignable_type (^^bool (ClassType) const));\n+static_assert (!is_nothrow_move_assignable_type (^^bool (...) &&));\n+static_assert (!is_nothrow_move_assignable_type (^^EnumType (int, ...)));\n+static_assert (!is_nothrow_move_assignable_type (^^ExceptMoveAssignClass));\n+static_assert (!is_nothrow_move_assignable_type (^^ExceptCopyAssignClass));\n+static_assert (!is_nothrow_move_assignable_type (^^DeletedMoveAssignClass));\n+static_assert (!is_nothrow_move_assignable_type (^^DeletedCopyAssignClass));\n+\n+static_assert (is_nothrow_destructible_type (^^int));\n+static_assert (is_nothrow_destructible_type (^^const int));\n+static_assert (is_nothrow_destructible_type (^^const volatile int));\n+static_assert (is_nothrow_destructible_type (^^int [12]));\n+static_assert (is_nothrow_destructible_type (^^const int [12]));\n+static_assert (is_nothrow_destructible_type (^^const volatile int [12]));\n+static_assert (is_nothrow_destructible_type (^^decltype (nullptr)));\n+static_assert (is_nothrow_destructible_type (^^std::initializer_list));\n+static_assert (is_nothrow_destructible_type (^^std::initializer_list));\n+static_assert (is_nothrow_destructible_type (^^std::initializer_list));\n+static_assert (is_nothrow_destructible_type (^^std::initializer_list));\n+static_assert (is_nothrow_destructible_type (^^N2::E));\n+static_assert (is_nothrow_destructible_type (^^const N2::E));\n+static_assert (is_nothrow_destructible_type (^^const volatile N2::E));\n+static_assert (is_nothrow_destructible_type (^^N2::NTD1));\n+static_assert (is_nothrow_destructible_type (^^N2::NTD2));\n+static_assert (is_nothrow_destructible_type (^^N2::NTD3));\n+static_assert (is_nothrow_destructible_type (^^N2::Aggr));\n+static_assert (is_nothrow_destructible_type (^^N2::U1));\n+static_assert (is_nothrow_destructible_type (^^void (*) ()));\n+static_assert (is_nothrow_destructible_type (^^void *));\n+static_assert (is_nothrow_destructible_type (^^int &));\n+static_assert (is_nothrow_destructible_type (^^N2::TD1 &));\n+static_assert (is_nothrow_destructible_type (^^N2::TD2 &));\n+static_assert (is_nothrow_destructible_type (^^N2::TD1 *));\n+static_assert (is_nothrow_destructible_type (^^N2::TD2 *));\n+static_assert (is_nothrow_destructible_type (^^void (&) ()));\n+static_assert (is_nothrow_destructible_type (^^void (&&) ()));\n+static_assert (is_nothrow_destructible_type (^^N2::En));\n+static_assert (is_nothrow_destructible_type (^^N2::En *));\n+static_assert (is_nothrow_destructible_type (^^N2::En &));\n+static_assert (is_nothrow_destructible_type (^^N2::En2));\n+static_assert (is_nothrow_destructible_type (^^N2::En2 *));\n+static_assert (is_nothrow_destructible_type (^^N2::En2 &));\n+static_assert (is_nothrow_destructible_type (^^N2::TD1 (&) (N2::Aggr2, N2::TD2)));\n+static_assert (is_nothrow_destructible_type (^^N2::TD1 (*) (N2::Aggr2, N2::TD2)));\n+static_assert (is_nothrow_destructible_type (^^N2::Abstract1));\n+static_assert (is_nothrow_destructible_type (^^N2::Der));\n+static_assert (is_nothrow_destructible_type (^^N2::Del &));\n+static_assert (is_nothrow_destructible_type (^^N2::Del2 &));\n+static_assert (is_nothrow_destructible_type (^^N2::Del3 &));\n+static_assert (is_nothrow_destructible_type (^^N2::Del (&) [1]));\n+static_assert (is_nothrow_destructible_type (^^N2::Del2 (&) [2]));\n+static_assert (is_nothrow_destructible_type (^^N2::Del3 (&) [3]));\n+static_assert (is_nothrow_destructible_type (^^N2::Del &&));\n+static_assert (is_nothrow_destructible_type (^^N2::Del2 &&));\n+static_assert (is_nothrow_destructible_type (^^N2::Del3 &));\n+static_assert (is_nothrow_destructible_type (^^N2::Del (&&) [1]));\n+static_assert (is_nothrow_destructible_type (^^N2::Del2 (&&) [2]));\n+static_assert (is_nothrow_destructible_type (^^N2::Del3 (&&) [3]));\n+static_assert (is_nothrow_destructible_type (^^N2::Ut &));\n+static_assert (is_nothrow_destructible_type (^^N2::Ut &&));\n+static_assert (is_nothrow_destructible_type (^^N2::Ut *));\n+static_assert (is_nothrow_destructible_type (^^N2::Abstract2 &));\n+static_assert (is_nothrow_destructible_type (^^N2::Abstract3 &));\n+static_assert (is_nothrow_destructible_type (^^N2::Abstract2 *));\n+static_assert (is_nothrow_destructible_type (^^N2::Abstract3 *));\n+static_assert (!is_nothrow_destructible_type (^^void));\n+static_assert (!is_nothrow_destructible_type (^^const void));\n+static_assert (!is_nothrow_destructible_type (^^void ()));\n+static_assert (!is_nothrow_destructible_type (^^void () const));\n+static_assert (!is_nothrow_destructible_type (^^N2::TD1 (N2::Aggr2, N2::TD2)));\n+static_assert (!is_nothrow_destructible_type (^^int []));\n+static_assert (!is_nothrow_destructible_type (^^const int []));\n+static_assert (!is_nothrow_destructible_type (^^const volatile int []));\n+static_assert (!is_nothrow_destructible_type (^^int [][123]));\n+static_assert (!is_nothrow_destructible_type (^^N2::TD1));\n+static_assert (!is_nothrow_destructible_type (^^N2::TD2));\n+static_assert (!is_nothrow_destructible_type (^^N2::Aggr2));\n+static_assert (!is_nothrow_destructible_type (^^N2::Aggr2 [1]));\n+static_assert (!is_nothrow_destructible_type (^^N2::TD1 [1][2]));\n+static_assert (!is_nothrow_destructible_type (^^N2::Ut));\n+static_assert (!is_nothrow_destructible_type (^^N2::Ut [3]));\n+static_assert (!is_nothrow_destructible_type (^^N2::AbstractDelDtor));\n+static_assert (!is_nothrow_destructible_type (^^N2::Abstract2));\n+static_assert (!is_nothrow_destructible_type (^^N2::Abstract3));\n+static_assert (!is_nothrow_destructible_type (^^N2::Der2));\n+static_assert (!is_nothrow_destructible_type (^^N2::Del));\n+static_assert (!is_nothrow_destructible_type (^^N2::Del2));\n+static_assert (!is_nothrow_destructible_type (^^N2::Del3));\n+static_assert (!is_nothrow_destructible_type (^^N2::Del [1]));\n+static_assert (!is_nothrow_destructible_type (^^N2::Del2 [2]));\n+static_assert (!is_nothrow_destructible_type (^^N2::Del3 [3]));\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait8.C b/gcc/testsuite/g++.dg/reflect/type_trait8.C\nnew file mode 100644\nindex 00000000000..33f04098911\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait8.C\n@@ -0,0 +1,129 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], type properties.\n+\n+#include \n+using namespace std::meta;\n+\n+class ClassType { };\n+class DerivedType : public ClassType { };\n+enum EnumType { e0 };\n+class AbstractClass { virtual void rotate (int) = 0; };\n+class PolymorphicClass { virtual void rotate (int); };\n+class DerivedPolymorphic : public PolymorphicClass { };\n+class VirtualDestructorClass { virtual ~VirtualDestructorClass (); };\n+\n+static_assert (has_virtual_destructor (^^VirtualDestructorClass));\n+static_assert (!has_virtual_destructor (^^PolymorphicClass));\n+static_assert (!has_virtual_destructor (^^DerivedPolymorphic));\n+static_assert (!has_virtual_destructor (^^AbstractClass));\n+static_assert (!has_virtual_destructor (^^void));\n+static_assert (!has_virtual_destructor (^^int (int)));\n+static_assert (!has_virtual_destructor (^^int &));\n+static_assert (!has_virtual_destructor (^^EnumType));\n+static_assert (!has_virtual_destructor (^^ClassType));\n+static_assert (!has_virtual_destructor (^^DerivedType));\n+\n+static_assert (has_unique_object_representations (^^char));\n+static_assert (has_unique_object_representations (^^unsigned char));\n+static_assert (has_unique_object_representations (^^signed char));\n+static_assert (has_unique_object_representations (^^unsigned));\n+static_assert (has_unique_object_representations (^^bool));\n+enum E3 : unsigned { };\n+static_assert (has_unique_object_representations (^^E3));\n+static_assert (has_unique_object_representations (^^unsigned [3]));\n+static_assert (has_unique_object_representations (^^unsigned [3][2]));\n+static_assert (has_unique_object_representations (^^unsigned []));\n+static_assert (has_unique_object_representations (^^unsigned [][2]));\n+static_assert (has_unique_object_representations (^^E3 [3]));\n+static_assert (has_unique_object_representations (^^E3 [3][2]));\n+static_assert (has_unique_object_representations (^^E3 []));\n+static_assert (has_unique_object_representations (^^E3 [][2]));\n+struct Padded { char c1; alignas(4) char c2; };\n+struct Bitfield { int i : 3; };\n+struct Aligned { alignas(4) char c; };\n+static_assert (!has_unique_object_representations (^^void));\n+static_assert (!has_unique_object_representations (^^float));\n+static_assert (!has_unique_object_representations (^^Padded));\n+static_assert (!has_unique_object_representations (^^Padded [2]));\n+static_assert (!has_unique_object_representations (^^Padded [2][1]));\n+static_assert (!has_unique_object_representations (^^Padded []));\n+static_assert (!has_unique_object_representations (^^Padded [][1]));\n+static_assert (!has_unique_object_representations (^^Bitfield));\n+static_assert (!has_unique_object_representations (^^Bitfield [2]));\n+static_assert (!has_unique_object_representations (^^Bitfield [2][1]));\n+static_assert (!has_unique_object_representations (^^Bitfield []));\n+static_assert (!has_unique_object_representations (^^Bitfield [][1]));\n+static_assert (!has_unique_object_representations (^^Aligned));\n+static_assert (!has_unique_object_representations (^^Aligned [2]));\n+static_assert (!has_unique_object_representations (^^Aligned [2][1]));\n+static_assert (!has_unique_object_representations (^^Aligned []));\n+static_assert (!has_unique_object_representations (^^Aligned [][1]));\n+\n+struct A { A(); };\n+struct B { operator int (); explicit operator int && (); };\n+struct C { operator int (); explicit operator int & (); };\n+\n+static_assert (!reference_constructs_from_temporary (^^int, ^^int));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^void));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^const volatile void));\n+static_assert (!reference_constructs_from_temporary (^^void, ^^void));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^int));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^int &));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^int &&));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^long));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^long &));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^long &&));\n+static_assert (reference_constructs_from_temporary (^^const int &, ^^int));\n+static_assert (!reference_constructs_from_temporary (^^const int &, ^^int &));\n+static_assert (!reference_constructs_from_temporary (^^const int &, ^^int &&));\n+static_assert (reference_constructs_from_temporary (^^const int &, ^^long));\n+static_assert (reference_constructs_from_temporary (^^const int &, ^^long &));\n+static_assert (reference_constructs_from_temporary (^^const int &, ^^long &&));\n+static_assert (reference_constructs_from_temporary (^^int &&, ^^int));\n+static_assert (!reference_constructs_from_temporary (^^int &&, ^^int &));\n+static_assert (!reference_constructs_from_temporary (^^int &&, ^^int &&));\n+static_assert (reference_constructs_from_temporary (^^int &&, ^^long));\n+static_assert (reference_constructs_from_temporary (^^int &&, ^^long &));\n+static_assert (reference_constructs_from_temporary (^^int &&, ^^long &&));\n+static_assert (reference_constructs_from_temporary (^^const A &, ^^A));\n+static_assert (!reference_constructs_from_temporary (^^const A &, ^^A &&));\n+static_assert (reference_constructs_from_temporary (^^A &&, ^^A));\n+static_assert (!reference_constructs_from_temporary (^^int &, ^^int []));\n+static_assert (!reference_constructs_from_temporary (^^const int &, ^^int []));\n+static_assert (!reference_constructs_from_temporary (^^int &&, ^^int []));\n+static_assert (!reference_constructs_from_temporary (^^int &&, ^^B));\n+static_assert (!reference_constructs_from_temporary (^^const int &, ^^C));\n+static_assert (reference_constructs_from_temporary (^^const std::string &, ^^const char *));\n+\n+static_assert (!reference_converts_from_temporary (^^int, ^^int));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^void));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^const volatile void));\n+static_assert (!reference_converts_from_temporary (^^void, ^^void));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^int));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^int &));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^int &&));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^long));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^long &));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^long &&));\n+static_assert (reference_converts_from_temporary (^^const int &, ^^int));\n+static_assert (!reference_converts_from_temporary (^^const int &, ^^int &));\n+static_assert (!reference_converts_from_temporary (^^const int &, ^^int &&));\n+static_assert (reference_converts_from_temporary (^^const int &, ^^long));\n+static_assert (reference_converts_from_temporary (^^const int &, ^^long &));\n+static_assert (reference_converts_from_temporary (^^const int &, ^^long &&));\n+static_assert (reference_converts_from_temporary (^^int &&, ^^int));\n+static_assert (!reference_converts_from_temporary (^^int &&, ^^int &));\n+static_assert (!reference_converts_from_temporary (^^int &&, ^^int &&));\n+static_assert (reference_converts_from_temporary (^^int &&, ^^long));\n+static_assert (reference_converts_from_temporary (^^int &&, ^^long &));\n+static_assert (reference_converts_from_temporary (^^int &&, ^^long &&));\n+static_assert (reference_converts_from_temporary (^^const A &, ^^A));\n+static_assert (!reference_converts_from_temporary (^^const A &, ^^A &&));\n+static_assert (reference_converts_from_temporary (^^A &&, ^^A));\n+static_assert (!reference_converts_from_temporary (^^int &, ^^int []));\n+static_assert (!reference_converts_from_temporary (^^const int &, ^^int []));\n+static_assert (!reference_converts_from_temporary (^^int &&, ^^int []));\n+static_assert (reference_converts_from_temporary (^^int &&, ^^B));\n+static_assert (reference_converts_from_temporary (^^const int &, ^^C));\n+static_assert (reference_converts_from_temporary (^^const std::string &, ^^const char *));\ndiff --git a/gcc/testsuite/g++.dg/reflect/type_trait9.C b/gcc/testsuite/g++.dg/reflect/type_trait9.C\nnew file mode 100644\nindex 00000000000..4790f16e002\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/type_trait9.C\n@@ -0,0 +1,67 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test reflection type traits [meta.reflection.traits], type property\n+// queries.\n+\n+#include \n+using namespace std::meta;\n+\n+class ClassType { };\n+\n+static_assert (rank (^^int) == 0);\n+static_assert (rank (^^const void) == 0);\n+static_assert (rank (^^char &) == 0);\n+static_assert (rank (^^long &&) == 0);\n+static_assert (rank (^^int [2]) == 1);\n+static_assert (rank (^^int [][4]) == 2);\n+static_assert (rank (^^int [2][2][4][4][6][6]) == 6);\n+static_assert (rank (^^int []) == 1);\n+static_assert (rank (^^ClassType) == 0);\n+static_assert (rank (^^ClassType [2]) == 1);\n+static_assert (rank (^^ClassType [][4]) == 2);\n+static_assert (rank (^^ClassType [2][2][4][4][6][6]) == 6);\n+static_assert (rank (^^ClassType []) == 1);\n+using D = ClassType [2][2][4][4][6][6][6];\n+static_assert (rank (^^D) == 7);\n+\n+static_assert (extent (^^int) == 0);\n+static_assert (extent (^^const void, 0) == 0);\n+static_assert (extent (^^char &, 42) == 0);\n+static_assert (extent (^^long &&, 18) == 0);\n+static_assert (extent (^^int [2]) == 2);\n+static_assert (extent (^^int [2][4]) == 2);\n+static_assert (extent (^^int [][4]) == 0);\n+static_assert (extent (^^int []) == 0);\n+static_assert (extent (^^int, 0) == 0);\n+static_assert (extent (^^int [2], 0) == 2);\n+static_assert (extent (^^int [2][4], 0) == 2);\n+static_assert (extent (^^int [][4], 0) == 0);\n+static_assert (extent (^^int [], 0) == 0);\n+static_assert (extent (^^int, 1) == 0);\n+static_assert (extent (^^int [2], 1) == 0);\n+static_assert (extent (^^int [2][4], 1) == 4);\n+static_assert (extent (^^int [][4], 1) == 4);\n+static_assert (extent (^^int [10][4][6][8][12][2], 4) == 12);\n+static_assert (extent (^^int [], 1) == 0);\n+static_assert (extent (^^ClassType) == 0);\n+static_assert (extent (^^ClassType [2]) == 2);\n+static_assert (extent (^^ClassType [2][4]) == 2);\n+static_assert (extent (^^ClassType [][4]) == 0);\n+static_assert (extent (^^ClassType, 0) == 0);\n+static_assert (extent (^^ClassType [2], 0) == 2);\n+static_assert (extent (^^ClassType [2][4], 0) == 2);\n+static_assert (extent (^^ClassType [][4], 0) == 0);\n+static_assert (extent (^^ClassType, 1) == 0);\n+static_assert (extent (^^ClassType [2], 1) == 0);\n+static_assert (extent (^^ClassType [2][4], 1) == 4);\n+static_assert (extent (^^ClassType [][4], 1) == 4);\n+static_assert (extent (^^ClassType [10][4][6][8][12][2], 4) == 12);\n+\n+__extension__ void\n+ext ()\n+{\n+ static_assert (rank (^^int [0]) == 1);\n+ static_assert (extent (^^int [0]) == 0);\n+ static_assert (extent (^^int [0], 0) == 0);\n+ static_assert (extent (^^int [0], 1) == 0);\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/u8display_string_of1.C b/gcc/testsuite/g++.dg/reflect/u8display_string_of1.C\nnew file mode 100644\nindex 00000000000..762a3c4be19\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/u8display_string_of1.C\n@@ -0,0 +1,230 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::u8display_string_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr info null_reflection;\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+ int v : 5;\n+};\n+template struct TCls {};\n+template void TFn();\n+template int TVar;\n+template concept Concept = requires { true; };\n+namespace NS {};\n+namespace NSAlias = NS;\n+namespace {\n+ namespace NS2 {}\n+};\n+namespace NS3 {\n+ namespace {\n+ namespace {\n+ namespace NS4 {}\n+ }\n+ }\n+};\n+enum { Z };\n+\n+constexpr auto ctx = access_context::current ();\n+\n+struct AN { int a; long b; char c; };\n+\n+[[=1, =AN { 1, 42, ' ' }]] void bar (long, const T f, int g[2], T &);\n+\n+struct V1 {\n+ constexpr V1 (int) {}\n+};\n+struct V2 {\n+ V2 &operator = (const V2 &);\n+};\n+struct V3 {\n+ V3 &operator = (V3 &&);\n+};\n+struct V4 {\n+ V4 &operator += (const V4 &);\n+};\n+struct V5 {\n+ operator int ();\n+};\n+int operator \"\"_a (const char *);\n+\n+void\n+foo (int a, const long b, T c, int d[4], T &e)\n+{\n+ static_assert (u8display_string_of (^^a) == u8\"a\");\n+ static_assert (u8display_string_of (^^b) == u8\"b\");\n+ static_assert (u8display_string_of (^^c) == u8\"c\");\n+ static_assert (u8display_string_of (^^d) == u8\"d\");\n+ static_assert (u8display_string_of (^^e) == u8\"e\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[0]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[1]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[2]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[3]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[4]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^bar)[0]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^bar)[1]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^bar)[2]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^bar)[3]) == u8\"\");\n+ static_assert (u8display_string_of (null_reflection) == u8\"\");\n+ static_assert (u8display_string_of (^^::) == u8\"::\");\n+ static_assert (u8display_string_of (^^NS2) == u8\"{anonymous}::NS2\");\n+ static_assert (u8display_string_of (parent_of (^^NS2)) == u8\"{anonymous}\");\n+ static_assert (u8display_string_of (^^NS3::NS4) == u8\"NS3::{anonymous}::{anonymous}::NS4\");\n+ static_assert (u8display_string_of (parent_of (^^NS3::NS4)) == u8\"NS3::{anonymous}::{anonymous}\");\n+ static_assert (u8display_string_of (parent_of (parent_of (^^NS3::NS4))) == u8\"NS3::{anonymous}\");\n+ static_assert (u8display_string_of (parent_of (parent_of (parent_of (^^NS3::NS4)))) == u8\"NS3\");\n+ static_assert (u8display_string_of (^^Z) == u8\"Z\");\n+ static_assert (u8display_string_of (parent_of (^^Z)) == u8\"\");\n+ static_assert (u8display_string_of (reflect_constant (42)) == u8\"42\");\n+ static_assert (u8display_string_of (reflect_object (arr[1])) == u8\"arr[1]\");\n+ static_assert (u8display_string_of (^^arr) == u8\"arr\");\n+ static_assert (u8display_string_of (^^a3) == u8\"a3\");\n+ static_assert (u8display_string_of (^^fn) == u8\"void fn()\");\n+ static_assert (u8display_string_of (^^fn2) == u8\"auto& fn2()\");\n+ static_assert (u8display_string_of (^^Enum::A) == u8\"A\");\n+ static_assert (u8display_string_of (^^Alias) == u8\"Alias {aka int}\");\n+ static_assert (u8display_string_of (^^S) == u8\"S\");\n+ static_assert (u8display_string_of (^^S::mem) == u8\"S::mem\");\n+ static_assert (u8display_string_of (members_of (^^S, ctx)[1]) == u8\"S::\");\n+ static_assert (u8display_string_of (^^TCls) == u8\"template > struct TCls\");\n+ static_assert (u8display_string_of (^^TFn) == u8\"template > void TFn()\");\n+ static_assert (u8display_string_of (^^TVar) == u8\"template > int TVar< >\");\n+ static_assert (u8display_string_of (^^Concept) == u8\"template > concept Concept\");\n+ static_assert (u8display_string_of (^^NSAlias) == u8\"NSAlias\");\n+ static_assert (u8display_string_of (^^NS) == u8\"NS\");\n+ static_assert (u8display_string_of (bases_of (^^S, ctx)[0]) == u8\"(S, B)\");\n+ static_assert (u8display_string_of (data_member_spec (^^int, { .name = \"member\", .alignment = 128, .no_unique_address = true })) == u8\"(int, member, 128, , true)\");\n+ static_assert (u8display_string_of (data_member_spec (^^const int, { .name = \"member\", .bit_width = 6 })) == u8\"(const int, member, , 6, false)\");\n+ static_assert (u8display_string_of (data_member_spec (^^int, { .bit_width = 0 })) == u8\"(int, , , 0, false)\");\n+ static_assert (u8display_string_of (data_member_spec (^^long, { .bit_width = 5 })) == u8\"(long int, , , 5, false)\");\n+ static_assert (u8display_string_of (annotations_of (^^bar)[0]) == u8\"[[=1]]\");\n+ static_assert (u8display_string_of (annotations_of (^^bar)[1]) == u8\"[[=AN{1, 42, ' '}]]\");\n+ static_assert (u8display_string_of (^^int) == u8\"int\");\n+ static_assert (u8display_string_of (^^unsigned) == u8\"unsigned int\");\n+ static_assert (u8display_string_of (^^unsigned long) == u8\"long unsigned int\");\n+ static_assert (u8display_string_of (^^const long long &) == u8\"const long long int&\");\n+ static_assert (u8display_string_of (^^const double **) == u8\"const double**\");\n+ static_assert (u8display_string_of (^^int (int)) == u8\"int(int)\");\n+ static_assert (u8display_string_of (^^int (&) (int, long, S &)) == u8\"int (&)(int, long int, S&)\");\n+ static_assert (u8display_string_of (^^int (*) (int, long, S &)) == u8\"int (*)(int, long int, S&)\");\n+ static_assert (u8display_string_of (members_of (^^V2, ctx)[0]) == u8\"V2& V2::operator=(const V2&)\");\n+ static_assert (u8display_string_of (members_of (^^V3, ctx)[0]) == u8\"V3& V3::operator=(V3&&)\");\n+ static_assert (u8display_string_of (members_of (^^V4, ctx)[0]) == u8\"V4& V4::operator+=(const V4&)\");\n+ static_assert (u8display_string_of (members_of (^^V5, ctx)[0]) == u8\"V5::operator int()\");\n+ static_assert (u8display_string_of (^^operator\"\"_a) == u8\"int operator\\\"\\\"_a(const char*)\");\n+}\n+\n+namespace NS5 {\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+ int v : 5;\n+ };\n+ template struct TCls {};\n+ template void TFn();\n+ template int TVar;\n+ template concept Concept = requires { true; };\n+ enum { Z };\n+\n+ struct AN { int a; long b; char c; };\n+\n+ [[=1, =AN { 1, 42, ' ' }]] void bar (long, const T f, int g[2], T &);\n+\n+ struct V1 {\n+ constexpr V1 (int) {}\n+ };\n+ struct V2 {\n+ V2 &operator = (const V2 &);\n+ };\n+ struct V3 {\n+ V3 &operator = (V3 &&);\n+ };\n+ struct V4 {\n+ V4 &operator += (const V4 &);\n+ };\n+ struct V5 {\n+ operator int ();\n+ };\n+ int operator \"\"_a (const char *);\n+\n+ void\n+ foo (int a, const long b, T c, int d[4], T &e)\n+ {\n+ static_assert (u8display_string_of (^^a) == u8\"a\");\n+ static_assert (u8display_string_of (^^b) == u8\"b\");\n+ static_assert (u8display_string_of (^^c) == u8\"c\");\n+ static_assert (u8display_string_of (^^d) == u8\"d\");\n+ static_assert (u8display_string_of (^^e) == u8\"e\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[0]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[1]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[2]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[3]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^foo)[4]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^bar)[0]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^bar)[1]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^bar)[2]) == u8\"\");\n+ static_assert (u8display_string_of (parameters_of (^^bar)[3]) == u8\"\");\n+ static_assert (u8display_string_of (^^Z) == u8\"NS5::Z\");\n+ static_assert (u8display_string_of (parent_of (^^Z)) == u8\"NS5::\");\n+ static_assert (u8display_string_of (reflect_constant (42)) == u8\"42\");\n+ static_assert (u8display_string_of (reflect_object (arr[1])) == u8\"NS5::arr[1]\");\n+ static_assert (u8display_string_of (^^arr) == u8\"NS5::arr\");\n+ static_assert (u8display_string_of (^^a3) == u8\"NS5::a3\");\n+ static_assert (u8display_string_of (^^fn) == u8\"void NS5::fn()\");\n+ static_assert (u8display_string_of (^^fn2) == u8\"auto& NS5::fn2()\");\n+ static_assert (u8display_string_of (^^Enum::A) == u8\"NS5::A\");\n+ static_assert (u8display_string_of (^^Alias) == u8\"NS5::Alias {aka int}\");\n+ static_assert (u8display_string_of (^^S) == u8\"NS5::S\");\n+ static_assert (u8display_string_of (^^S::mem) == u8\"NS5::S::mem\");\n+ static_assert (u8display_string_of (members_of (^^S, ctx)[1]) == u8\"NS5::S::\");\n+ static_assert (u8display_string_of (^^TCls) == u8\"template > struct NS5::TCls\");\n+ static_assert (u8display_string_of (^^TFn) == u8\"template > void NS5::TFn()\");\n+ static_assert (u8display_string_of (^^TVar) == u8\"template > int NS5::TVar< >\");\n+ static_assert (u8display_string_of (^^Concept) == u8\"template > concept NS5::Concept\");\n+ static_assert (u8display_string_of (bases_of (^^S, ctx)[0]) == u8\"(NS5::S, NS5::B)\");\n+ static_assert (u8display_string_of (annotations_of (^^bar)[0]) == u8\"[[=1]]\");\n+ static_assert (u8display_string_of (annotations_of (^^bar)[1]) == u8\"[[=NS5::AN{1, 42, ' '}]]\");\n+ static_assert (u8display_string_of (^^int (&) (int, long, S &)) == u8\"int (&)(int, long int, NS5::S&)\");\n+ static_assert (u8display_string_of (^^int (*) (int, long, S &)) == u8\"int (*)(int, long int, NS5::S&)\");\n+ static_assert (u8display_string_of (members_of (^^V2, ctx)[0]) == u8\"NS5::V2& NS5::V2::operator=(const NS5::V2&)\");\n+ static_assert (u8display_string_of (members_of (^^V3, ctx)[0]) == u8\"NS5::V3& NS5::V3::operator=(NS5::V3&&)\");\n+ static_assert (u8display_string_of (members_of (^^V4, ctx)[0]) == u8\"NS5::V4& NS5::V4::operator+=(const NS5::V4&)\");\n+ static_assert (u8display_string_of (members_of (^^V5, ctx)[0]) == u8\"NS5::V5::operator int()\");\n+ static_assert (u8display_string_of (^^operator\"\"_a) == u8\"int NS5::operator\\\"\\\"_a(const char*)\");\n+ }\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/u8identifier_of1.C b/gcc/testsuite/g++.dg/reflect/u8identifier_of1.C\nnew file mode 100644\nindex 00000000000..0d30197d79d\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/u8identifier_of1.C\n@@ -0,0 +1,168 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::u8identifier_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+struct C { };\n+\n+constexpr std::u8string_view sv = std::meta::u8identifier_of (^^C);\n+static_assert (sv == u8\"C\");\n+static_assert (sv.data ()[0] == u8'C');\n+static_assert (sv.data ()[1] == u8'\\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 (u8identifier_of (^^T) == std::u8string_view (u8\"T\"));\n+static_assert (u8identifier_of (^^S) == std::u8string_view (u8\"S\"));\n+static_assert (u8identifier_of (^^U) == std::u8string_view (u8\"U\"));\n+static_assert (u8identifier_of (^^std) == std::u8string_view (u8\"std\"));\n+static_assert (u8identifier_of (^^std::meta) == std::u8string_view (u8\"meta\"));\n+static_assert (u8identifier_of (^^E1) == std::u8string_view (u8\"E1\"));\n+static_assert (u8identifier_of (^^E) == std::u8string_view (u8\"E\"));\n+static_assert (u8identifier_of (parent_of (^^E5)) == std::u8string_view (u8\"E7\"));\n+static_assert (u8identifier_of (^^E7) == std::u8string_view (u8\"E7\"));\n+static_assert (u8identifier_of (data_member_spec (^^long, { .name = u8\"foo\", .bit_width = 6 })) == std::u8string_view (u8\"foo\"));\n+static_assert (u8identifier_of (data_member_spec (^^long, { .name = u8\"extremely_long_string_used_as_identifier\" })) == std::u8string_view (u8\"extremely_long_string_used_as_identifier\"));\n+\n+namespace N {}\n+namespace NA = N;\n+static_assert (u8identifier_of (^^N) == std::u8string_view (u8\"N\"));\n+static_assert (u8identifier_of (^^NA) == std::u8string_view (u8\"NA\"));\n+\n+namespace {\n+ int a;\n+ namespace M {}\n+ static_assert (u8identifier_of (^^a) == std::u8string_view (u8\"a\"));\n+ static_assert (u8identifier_of (^^M) == std::u8string_view (u8\"M\"));\n+}\n+\n+typedef struct {\n+ int a;\n+ static_assert (u8identifier_of (^^a) == std::u8string_view (u8\"a\"));\n+} SV;\n+static_assert (u8identifier_of (^^SV) == std::u8string_view (u8\"SV\"));\n+static_assert (u8identifier_of (parent_of (^^SV::a)) == std::u8string_view (u8\"SV\"));\n+static_assert (u8identifier_of (dealias (^^SV)) == std::u8string_view (u8\"SV\"));\n+\n+template \n+struct ST\n+{\n+ static_assert (u8identifier_of (^^ST) == std::u8string_view (u8\"ST\"));\n+};\n+\n+struct V\n+{\n+ void foo () { int a; static_assert (u8identifier_of (parent_of (^^a)) == std::u8string_view (u8\"foo\")); }\n+ template \n+ void bar () { int a; static_assert (u8identifier_of (parent_of (^^a)) == std::u8string_view (u8\"bar\")); }\n+};\n+\n+int\n+operator \"\"_a (const char *)\n+{\n+ int a;\n+ static_assert (u8identifier_of (parent_of (^^a)) == std::u8string_view (u8\"_a\"));\n+ return 0;\n+}\n+\n+int v;\n+static_assert (u8identifier_of (^^V::foo) == std::u8string_view (u8\"foo\"));\n+static_assert (u8identifier_of (^^V::bar) == std::u8string_view (u8\"bar\"));\n+\n+void foo (int);\n+static_assert (u8identifier_of (^^foo) == std::u8string_view (u8\"foo\"));\n+\n+int arr[3];\n+\n+void\n+foo (int a)\n+{\n+ auto [b, c, d] = arr;\n+ static_assert (u8identifier_of (^^foo) == std::u8string_view (u8\"foo\"));\n+ static_assert (u8identifier_of (^^a) == std::u8string_view (u8\"a\"));\n+ static_assert (u8identifier_of (^^b) == std::u8string_view (u8\"b\"));\n+ static_assert (u8identifier_of (^^c) == std::u8string_view (u8\"c\"));\n+ static_assert (u8identifier_of (^^d) == std::u8string_view (u8\"d\"));\n+}\n+\n+template \n+void\n+bar (int a)\n+{\n+ auto [...b, c] = arr;\n+ static_assert (u8identifier_of (^^a) == std::u8string_view (u8\"a\"));\n+ static_assert (u8identifier_of (^^c) == std::u8string_view (u8\"c\"));\n+}\n+\n+void\n+baz ()\n+{\n+ auto a = [] {\n+ int a;\n+ static_assert (u8identifier_of (^^a) == std::u8string_view (u8\"a\"));\n+ static_assert (u8identifier_of (parent_of (parent_of (parent_of (^^a)))) == std::u8string_view (u8\"baz\"));\n+ };\n+ using t = decltype (a);\n+ static_assert (u8identifier_of (^^t) == std::u8string_view (u8\"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 (u8identifier_of (p1) == std::u8string_view (u8\"b\"));\n+static_assert (u8identifier_of (p2) == std::u8string_view (u8\"c\"));\n+static_assert (u8identifier_of (p3) == std::u8string_view (u8\"d\"));\n+void qux (int a, int, int c, int e, int);\n+static_assert (u8identifier_of (p0) == std::u8string_view (u8\"a\"));\n+static_assert (u8identifier_of (p1) == std::u8string_view (u8\"b\"));\n+static_assert (u8identifier_of (p2) == std::u8string_view (u8\"c\"));\n+\n+void\n+qux (int a, int, int, int e, int)\n+{\n+ static_assert (u8identifier_of (p0) == std::u8string_view (u8\"a\"));\n+ static_assert (u8identifier_of (p1) == std::u8string_view (u8\"b\"));\n+ static_assert (u8identifier_of (p2) == std::u8string_view (u8\"c\"));\n+ static_assert (u8identifier_of (variable_of (p0)) == std::u8string_view (u8\"a\"));\n+ static_assert (u8identifier_of (variable_of (p3)) == std::u8string_view (u8\"e\"));\n+}\n+\n+void qux (int f, int, int, int, int g);\n+static_assert (u8identifier_of (p1) == std::u8string_view (u8\"b\"));\n+static_assert (u8identifier_of (p2) == std::u8string_view (u8\"c\"));\n+static_assert (u8identifier_of (p4) == std::u8string_view (u8\"g\"));\n+\n+template \n+void\n+freddy (int a, T... b)\n+{\n+}\n+\n+static_assert (u8identifier_of (parameters_of (^^freddy )[0]) == std::u8string_view (u8\"a\"));\n+\n+struct {\n+ int a;\n+} s;\n+\n+static_assert (u8identifier_of (^^s) == std::u8string_view (u8\"s\"));\n+\n+int qu\\u00E6 = 1;\n+\n+static_assert (u8identifier_of (^^qu\\u00E6) == std::u8string_view (u8\"qu\\N{LATIN SMALL LETTER AE}\"));\n+\n+typedef enum {\n+ E8,\n+ E9\n+} E10;\n+static_assert (u8identifier_of (parent_of (^^E8)) == std::u8string_view (u8\"E10\"));\ndiff --git a/gcc/testsuite/g++.dg/reflect/u8symbol_of1.C b/gcc/testsuite/g++.dg/reflect/u8symbol_of1.C\nnew file mode 100644\nindex 00000000000..1c8bc411655\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/u8symbol_of1.C\n@@ -0,0 +1,61 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::u8symbol_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+consteval bool\n+has_u8symbol_of (operators op)\n+{\n+ try { u8symbol_of (op); }\n+ catch (std::meta::exception &) { return false; }\n+ return true;\n+}\n+\n+static_assert (!has_u8symbol_of (static_cast (4242)));\n+static_assert (u8symbol_of (op_new) == std::u8string_view (u8\"new\"));\n+static_assert (u8symbol_of (op_delete) == std::u8string_view (u8\"delete\"));\n+static_assert (u8symbol_of (op_array_new) == std::u8string_view (u8\"new[]\"));\n+static_assert (u8symbol_of (op_array_delete) == std::u8string_view (u8\"delete[]\"));\n+static_assert (u8symbol_of (op_co_await) == std::u8string_view (u8\"co_await\"));\n+static_assert (u8symbol_of (op_parentheses) == std::u8string_view (u8\"()\"));\n+static_assert (u8symbol_of (op_square_brackets) == std::u8string_view (u8\"[]\"));\n+static_assert (u8symbol_of (op_arrow) == std::u8string_view (u8\"->\"));\n+static_assert (u8symbol_of (op_arrow_star) == std::u8string_view (u8\"->*\"));\n+static_assert (u8symbol_of (op_tilde) == std::u8string_view (u8\"~\"));\n+static_assert (u8symbol_of (op_exclamation) == std::u8string_view (u8\"!\"));\n+static_assert (u8symbol_of (op_plus) == std::u8string_view (u8\"+\"));\n+static_assert (u8symbol_of (op_minus) == std::u8string_view (u8\"-\"));\n+static_assert (u8symbol_of (op_star) == std::u8string_view (u8\"*\"));\n+static_assert (u8symbol_of (op_slash) == std::u8string_view (u8\"/\"));\n+static_assert (u8symbol_of (op_percent) == std::u8string_view (u8\"%\"));\n+static_assert (u8symbol_of (op_caret) == std::u8string_view (u8\"^\"));\n+static_assert (u8symbol_of (op_ampersand) == std::u8string_view (u8\"&\"));\n+static_assert (u8symbol_of (op_equals) == std::u8string_view (u8\"=\"));\n+static_assert (u8symbol_of (op_pipe) == std::u8string_view (u8\"|\"));\n+static_assert (u8symbol_of (op_plus_equals) == std::u8string_view (u8\"+=\"));\n+static_assert (u8symbol_of (op_minus_equals) == std::u8string_view (u8\"-=\"));\n+static_assert (u8symbol_of (op_star_equals) == std::u8string_view (u8\"*=\"));\n+static_assert (u8symbol_of (op_slash_equals) == std::u8string_view (u8\"/=\"));\n+static_assert (u8symbol_of (op_percent_equals) == std::u8string_view (u8\"%=\"));\n+static_assert (u8symbol_of (op_caret_equals) == std::u8string_view (u8\"^=\"));\n+static_assert (u8symbol_of (op_ampersand_equals) == std::u8string_view (u8\"&=\"));\n+static_assert (u8symbol_of (op_pipe_equals) == std::u8string_view (u8\"|=\"));\n+static_assert (u8symbol_of (op_equals_equals) == std::u8string_view (u8\"==\"));\n+static_assert (u8symbol_of (op_exclamation_equals) == std::u8string_view (u8\"!=\"));\n+static_assert (u8symbol_of (op_less) == std::u8string_view (u8\"<\"));\n+static_assert (u8symbol_of (op_greater) == std::u8string_view (u8\">\"));\n+static_assert (u8symbol_of (op_less_equals) == std::u8string_view (u8\"<=\"));\n+static_assert (u8symbol_of (op_greater_equals) == std::u8string_view (u8\">=\"));\n+static_assert (u8symbol_of (op_spaceship) == std::u8string_view (u8\"<=>\"));\n+static_assert (u8symbol_of (op_ampersand_ampersand) == std::u8string_view (u8\"&&\"));\n+static_assert (u8symbol_of (op_pipe_pipe) == std::u8string_view (u8\"||\"));\n+static_assert (u8symbol_of (op_less_less) == std::u8string_view (u8\"<<\"));\n+static_assert (u8symbol_of (op_greater_greater) == std::u8string_view (u8\">>\"));\n+static_assert (u8symbol_of (op_less_less_equals) == std::u8string_view (u8\"<<=\"));\n+static_assert (u8symbol_of (op_greater_greater_equals) == std::u8string_view (u8\">>=\"));\n+static_assert (u8symbol_of (op_plus_plus) == std::u8string_view (u8\"++\"));\n+static_assert (u8symbol_of (op_minus_minus) == std::u8string_view (u8\"--\"));\n+static_assert (u8symbol_of (op_comma) == std::u8string_view (u8\",\"));\ndiff --git a/gcc/testsuite/g++.dg/reflect/underlying_type1.C b/gcc/testsuite/g++.dg/reflect/underlying_type1.C\nnew file mode 100644\nindex 00000000000..8d5dbb2e4c2\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/underlying_type1.C\n@@ -0,0 +1,13 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::underlying_type.\n+\n+#include \n+\n+constexpr auto a = std::meta::underlying_type (^^int);\t// { dg-error \"uncaught exception of type\" }\n+\n+enum E {\n+ E0 = 1,\n+ E1 = std::meta::underlying_type (^^E) == ^^int,\t// { dg-error \"uncaught exception of type\" }\n+ E2 = 2\t\t\t\t\t\t// { dg-error \"enumerator value for 'E1' is not an integer constant\" \"\" { target *-*-* } .-1 }\n+};\ndiff --git a/gcc/testsuite/g++.dg/reflect/using1.C b/gcc/testsuite/g++.dg/reflect/using1.C\nnew file mode 100644\nindex 00000000000..915f81f5171\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/using1.C\n@@ -0,0 +1,13 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+\n+struct A {\n+ int a;\n+ consteval A(int p) : a(p) {}\n+};\n+\n+constexpr auto r = ^^A;\n+\n+struct B : A {\n+ using typename [: r :]::A;\n+};\ndiff --git a/gcc/testsuite/g++.dg/reflect/value_or_object1.C b/gcc/testsuite/g++.dg/reflect/value_or_object1.C\nnew file mode 100644\nindex 00000000000..9135bab8be8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/value_or_object1.C\n@@ -0,0 +1,50 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::is_value and is_object.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+constexpr int i = 42;\n+\n+template\n+constexpr int v = N;\n+\n+static_assert (!is_object (^^i));\n+static_assert (!is_value (^^i));\n+static_assert (is_variable (^^i));\n+static_assert (!is_object (reflect_constant (^^i)));\n+static_assert (is_value (reflect_constant (^^i)));\n+static_assert (!is_variable (reflect_constant (^^i)));\n+static_assert (!is_object (substitute (^^v, { reflect_constant (15) })));\n+static_assert (!is_object (^^v<15>));\n+static_assert (!is_value (^^v<15>));\n+static_assert (is_variable (^^v<15>));\n+static_assert (is_value (reflect_constant (^^v<15>)));\n+static_assert (!is_object (reflect_constant (^^v<15>)));\n+static_assert (!is_variable (reflect_constant (^^v<15>)));\n+\n+constexpr std::pair, int> p = {{1, true}, 2};\n+constexpr info rfirst = reflect_object (p.first);\n+static_assert (is_object (rfirst) && !is_value (rfirst));\n+static_assert (type_of (rfirst) == ^^const std::pair);\n+static_assert (rfirst != reflect_constant (std::make_pair (1, true)));\n+\n+constexpr int k = 3;\n+constexpr const int *pk = &k;\n+constexpr const int &ref = k;\n+constexpr auto rp = ^^pk;\n+constexpr auto rref = ^^ref;\n+static_assert (is_variable (rp));\n+static_assert (!is_object (rp));\n+static_assert (!is_value (rp));\n+static_assert (!is_variable (reflect_constant (rp)));\n+static_assert (!is_object (reflect_constant (rp)));\n+static_assert (is_value (reflect_constant (rp)));\n+static_assert (is_variable (rref));\n+static_assert (!is_object (rref));\n+static_assert (!is_value (rref));\n+static_assert (!is_variable (reflect_constant (rref)));\n+static_assert (!is_object (reflect_constant (rref)));\n+static_assert (is_value (reflect_constant (rref)));\ndiff --git a/gcc/testsuite/g++.dg/reflect/variable_of1.C b/gcc/testsuite/g++.dg/reflect/variable_of1.C\nnew file mode 100644\nindex 00000000000..ae27875d0e9\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/variable_of1.C\n@@ -0,0 +1,136 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::variable_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+int arr[] = {1, 2, 3};\n+auto [a1, a2, a3] = arr;\n+void fn();\n+auto &fn2();\n+enum Enum { A };\n+using Alias = int;\n+struct B {};\n+struct S : B {\n+ int mem;\n+ int : 0;\n+};\n+struct T {\n+ T ();\n+ T (const T &);\n+ ~T ();\n+};\n+struct U {\n+ int u;\n+};\n+template struct TCls {};\n+template void TFn();\n+template int TVar;\n+template concept Concept = requires { true; };\n+namespace NS {};\n+namespace NSAlias = NS;\n+\n+constexpr auto ctx = std::meta::access_context::current ();\n+\n+consteval bool\n+has_variable_of (info r)\n+{\n+ try { variable_of (r); }\n+ catch (std::meta::exception &) { return false; }\n+ return true;\n+}\n+\n+static_assert (!has_variable_of (std::meta::reflect_constant (42)));\n+static_assert (!has_variable_of (std::meta::reflect_object (arr[1])));\n+static_assert (!has_variable_of (^^arr));\n+static_assert (!has_variable_of (^^a3));\n+static_assert (!has_variable_of (^^fn));\n+static_assert (!has_variable_of (^^fn2));\n+static_assert (!has_variable_of (^^Enum::A));\n+static_assert (!has_variable_of (^^Alias));\n+static_assert (!has_variable_of (^^S));\n+static_assert (!has_variable_of (^^S::mem));\n+static_assert (!has_variable_of (std::meta::members_of (^^S, ctx)[1]));\n+static_assert (!has_variable_of (^^TCls));\n+static_assert (!has_variable_of (^^TFn));\n+static_assert (!has_variable_of (^^TVar));\n+static_assert (!has_variable_of (^^Concept));\n+static_assert (!has_variable_of (^^NSAlias));\n+static_assert (!has_variable_of (^^NS));\n+static_assert (!has_variable_of (std::meta::bases_of (^^S, ctx)[0]));\n+static_assert (!has_variable_of (std::meta::data_member_spec (^^int, { .name = \"member\" })));\n+\n+void\n+bar (long, const T f, int g[2], T &)\n+{\n+}\n+\n+void\n+foo (int a, const long b, T c, int d[4], T &e)\n+{\n+ static_assert (!has_variable_of (^^a));\n+ static_assert (!has_variable_of (^^b));\n+ static_assert (!has_variable_of (^^c));\n+ static_assert (!has_variable_of (^^d));\n+ static_assert (!has_variable_of (^^e));\n+ static_assert (has_variable_of (parameters_of (^^foo)[0]));\n+ static_assert (has_variable_of (parameters_of (^^foo)[1]));\n+ static_assert (has_variable_of (parameters_of (^^foo)[2]));\n+ static_assert (has_variable_of (parameters_of (^^foo)[3]));\n+ static_assert (has_variable_of (parameters_of (^^foo)[4]));\n+ static_assert (!has_variable_of (parameters_of (^^bar)[0]));\n+ static_assert (!has_variable_of (parameters_of (^^bar)[1]));\n+ static_assert (!has_variable_of (parameters_of (^^bar)[2]));\n+ static_assert (!has_variable_of (parameters_of (^^bar)[3]));\n+ static_assert (variable_of (parameters_of (^^foo)[0]) == ^^a);\n+ static_assert (variable_of (parameters_of (^^foo)[1]) == ^^b);\n+ static_assert (variable_of (parameters_of (^^foo)[2]) == ^^c);\n+ static_assert (variable_of (parameters_of (^^foo)[3]) == ^^d);\n+ static_assert (variable_of (parameters_of (^^foo)[4]) == ^^e);\n+ static_assert (variable_of (parameters_of (^^foo)[0]) != parameters_of (^^foo)[0]);\n+ static_assert (variable_of (parameters_of (^^foo)[1]) != parameters_of (^^foo)[1]);\n+ static_assert (variable_of (parameters_of (^^foo)[2]) != parameters_of (^^foo)[2]);\n+ static_assert (variable_of (parameters_of (^^foo)[3]) != parameters_of (^^foo)[3]);\n+ static_assert (variable_of (parameters_of (^^foo)[4]) != parameters_of (^^foo)[4]);\n+ static_assert (parameters_of (^^foo)[0] != ^^a);\n+ static_assert (parameters_of (^^foo)[1] != ^^b);\n+ static_assert (parameters_of (^^foo)[2] != ^^c);\n+ static_assert (parameters_of (^^foo)[3] != ^^d);\n+ static_assert (parameters_of (^^foo)[4] != ^^e);\n+}\n+\n+consteval bool\n+baz (int a, info b, info c, info d)\n+{\n+ if (a != 43)\n+ return false;\n+ if (b != d)\n+ return false;\n+ if (b == c)\n+ return false;\n+ if (b == parameters_of (^^baz)[1])\n+ return false;\n+\n+ // variable can be accessed only in innermost scope\n+ try { variable_of (c); return false; }\n+ catch (exception) {}\n+ try { variable_of (parameters_of (^^baz)[1]); return false; } \n+ catch (exception) {}\n+ return true;\n+}\n+\n+consteval bool\n+qux (int a)\n+{\n+ return baz (a + 1, ^^a, parameters_of (^^qux)[0],\n+ // TODO: This doesn't work yet, I think we want to check\n+ // whether DECL_CONTEXT of the PARM_DECL is current_function_decl\n+ // or any of the ctx->call->fundef->decl on the constexpr evaluation\n+ // stack. But currently we only have access to the innermost.\n+\t // variable_of (parameters_of (^^qux)[0]));\n+\t ^^a);\n+}\n+\n+static_assert (qux (42));\ndiff --git a/gcc/testsuite/g++.dg/reflect/variable_of2.C b/gcc/testsuite/g++.dg/reflect/variable_of2.C\nnew file mode 100644\nindex 00000000000..0a55f696a0f\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/variable_of2.C\n@@ -0,0 +1,21 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::variable_of.\n+\n+#include \n+\n+using namespace std::meta;\n+\n+consteval int fn(int p) {\n+ constexpr auto rp = parameters_of(^^fn)[0];\n+ constexpr auto rv = variable_of(rp);\n+ static_assert(is_function_parameter(rp));\n+ static_assert(!is_function_parameter(rv));\n+ static_assert(!is_variable(rp));\n+ static_assert(is_variable(rv));\n+ static_assert(^^p == rv);\n+\n+ return [:variable_of(parameters_of(^^fn)[0]):];\n+}\n+\n+static_assert(fn(42) == 42);\ndiff --git a/gcc/testsuite/g++.dg/reflect/variable_of3.C b/gcc/testsuite/g++.dg/reflect/variable_of3.C\nnew file mode 100644\nindex 00000000000..9b16346bdf8\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/variable_of3.C\n@@ -0,0 +1,28 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::variable_of.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+constexpr int fn(int, int) {\n+ return [: variable_of (parameters_of (^^fn)[0]) :]\n+ + [: variable_of (parameters_of (^^fn)[1]) :];\n+}\n+\n+static_assert(fn(10, 32) == 42);\n+\n+template\n+constexpr int bar(Args...)\n+{\n+ constexpr int vt[] {__integer_pack (sizeof...(Args))...};\n+ constexpr auto [...ids] = vt;\n+ return (0 + ... + [: variable_of (parameters_of (^^bar)[ids]) :]);\n+}\n+\n+static_assert(bar(42) == 42);\n+static_assert(bar(10, 32) == 42);\n+static_assert(bar(10, 15, 17) == 42);\n+static_assert(bar(10, 15, 11, 6) == 42);\ndiff --git a/gcc/testsuite/g++.dg/reflect/variant1.C b/gcc/testsuite/g++.dg/reflect/variant1.C\nnew file mode 100644\nindex 00000000000..a3cc066da67\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/variant1.C\n@@ -0,0 +1,37 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::variant_{size,alternative}.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+using V0 = std::variant<>;\n+static_assert (variant_size (^^V0) == 0);\n+static_assert (variant_size (^^const V0) == 0);\n+\n+using V1 = std::variant;\n+static_assert (variant_size (^^V1) == 1);\n+static_assert (variant_size (^^const V1) == 1);\n+static_assert (variant_alternative (0, ^^V1) == ^^void *);\n+\n+using V4 = std::variant;\n+static_assert (variant_size (^^V4) == 4);\n+static_assert (variant_size (^^const V4) == 4);\n+static_assert (variant_alternative (0, ^^V4) == ^^long);\n+static_assert (variant_alternative (1, ^^V4) == ^^long);\n+static_assert (variant_alternative (2, ^^V4) == ^^void *);\n+static_assert (variant_alternative (3, ^^V4) == ^^double);\n+// cv-qualification on the variant type propagates to the extracted alternative type.\n+static_assert (variant_alternative (0, ^^const V4) == ^^const long);\n+static_assert (variant_alternative (1, ^^const V4) == ^^const long);\n+static_assert (variant_alternative (2, ^^const V4) == ^^void *const);\n+static_assert (variant_alternative (3, ^^const V4) == ^^const double);\n+\n+using mytype1 = float;\n+using mytype2 = mytype1 *;\n+using V2 = std::variant;\n+static_assert (variant_size (^^V2) == 2);\n+static_assert (variant_alternative (0, ^^V2) == ^^float);\n+static_assert (variant_alternative (1, ^^V2) == ^^float *);\ndiff --git a/gcc/testsuite/g++.dg/reflect/variant2.C b/gcc/testsuite/g++.dg/reflect/variant2.C\nnew file mode 100644\nindex 00000000000..4570aa71c98\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/variant2.C\n@@ -0,0 +1,19 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::meta::variant_{size,alternative}.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+constexpr auto s1 = variant_size (^^int); // { dg-error \"couldn't instantiate 'std::variant_size'\" }\n+int x;\n+constexpr auto s2 = variant_size (^^x); // { dg-error \"uncaught exception\" }\n+\n+constexpr auto r1 = variant_alternative (0, ^^std::variant<>); // { dg-error \"uncaught exception\" }\n+constexpr auto r2 = variant_alternative (0, ^^int); // { dg-error \"uncaught exception\" }\n+constexpr auto r3 = variant_alternative (0, ^^x); // { dg-error \"uncaught exception\" }\n+\n+// { dg-error \"static assertion failed\" \"\" { target *-*-* } 0 }\n+// { dg-error \"pack index .0.\" \"\" { target *-*-* } 0 }\ndiff --git a/gcc/testsuite/g++.dg/reflect/vector1.C b/gcc/testsuite/g++.dg/reflect/vector1.C\nnew file mode 100644\nindex 00000000000..179a056fd3e\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/vector1.C\n@@ -0,0 +1,28 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection\" }\n+// Test std::vector.\n+\n+#include \n+#include \n+\n+using namespace std::meta;\n+\n+void die ();\n+\n+consteval void\n+f ()\n+{\n+ constexpr auto e = std::vector{^^int}[0];\n+ typename [:e:] i = 42;\n+ auto f = std::vector{^^int}[0];\n+ std::vector v1 = { ^^int };\n+ auto v2 = std::vector{^^int};\n+ if (v1.size () != v2.size ())\n+ die ();\n+}\n+\n+void\n+g ()\n+{\n+ f ();\n+}\ndiff --git a/gcc/testsuite/g++.dg/reflect/visibility1.C b/gcc/testsuite/g++.dg/reflect/visibility1.C\nnew file mode 100644\nindex 00000000000..c47817b9b4e\n--- /dev/null\n+++ b/gcc/testsuite/g++.dg/reflect/visibility1.C\n@@ -0,0 +1,121 @@\n+// { dg-do compile { target c++26 } }\n+// { dg-additional-options \"-freflection -O0\" }\n+\n+#include \n+\n+template \n+void\n+foo ()\n+{\n+}\n+\n+struct A {};\n+\n+namespace\n+{\n+ void baz (int) {}\n+ struct B {};\n+ struct C : public A {};\n+ template \n+ struct G {};\n+}\n+\n+struct D : public B {};\n+\n+template \n+struct F {};\n+\n+struct H : public A {};\n+\n+static union { int au; };\n+int b;\n+static int c;\n+\n+constexpr auto ctx = std::meta::access_context::current ();\n+\n+static void\n+bar (int x)\n+{\n+ int v = 42;\n+ foo <100, ^^x> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi100EL\" } } - var in TU-local fn\n+ foo <101, ^^v> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi101EL\" } } - var in TU-local fn\n+ foo <102, parameters_of (^^baz)[0]> ();\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi102EL\" } } - param of TU-local fn\n+ foo <103, bases_of (^^C, ctx)[0]> ();\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi103EL\" } } - direct base relationship with TU-local derived\n+ foo <104, bases_of (^^D, ctx)[0]> ();\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi104EL\" } } - direct base relationship with TU-local base\n+ foo <105, data_member_spec (^^B, { .name = \"foo\" })> (); // { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi105EL\" } } - data member spec with TU-local type\n+}\n+\n+inline void\n+qux (int x)\n+{\n+ int v = 42;\n+ foo <106, ^^x> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi106EL\" } } - var in inline fn - TODO, shall this be exported?\n+ foo <107, ^^v> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi107EL\" } } - var in inline fn - TODO, shall this be exported?\n+}\n+\n+template \n+void\n+plugh (int x)\n+{\n+ int v = 42;\n+ foo <132, ^^x> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi132EL\" } } - var in public fn template instantiation - TODO, shall this be exported?\n+ foo <133, ^^v> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi133EL\" } } - var in public fn template instantiation - TODO, shall this be exported?\n+ foo <134, parameters_of (parent_of (^^v))[0]> (); // { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi134EL\" { target *-*-linux* } } } - fn parm of public fn template instantiation\n+}\n+\n+namespace {\n+template \n+void\n+garply (int x)\n+{\n+ int v = 42;\n+ foo <135, ^^x> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi135EL\" } } - var in TU-local fn template instantiation\n+ foo <136, ^^v> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi136EL\" } } - var in Tu-local fn template instantiation\n+ foo <137, parameters_of (parent_of (^^v))[0]> (); // { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi137EL\" } } - fn parm of TU-local fn template instantiation\n+}\n+}\n+\n+template \n+void\n+fred (int x)\n+{\n+ int v = 42;\n+ foo <138, ^^x> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi138EL\" } } - var in TU-local fn template instantiation\n+ foo <139, ^^v> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi139EL\" } } - var in Tu-local fn template instantiation\n+ foo <140, parameters_of (parent_of (^^v))[0]> (); // { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi140EL\" { xfail *-*-* } } } - fn parm of TU-local fn template instantiation - TODO, I think this shouldn't be exported and the mangling of these 3 doesn't include the template parameter\n+}\n+\n+[[=1]] void\n+xyzzy (int x)\n+{\n+ int v;\n+ struct E {};\n+ qux (x);\n+ foo <108, annotations_of (^^xyzzy)[0]> ();\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi108EL\" } } - annotations always TU-local\n+ foo <109, parameters_of (^^bar)[0]> ();\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi109EL\" } } - fn parm of TU-local fn\n+ foo <110, parameters_of (^^qux)[0]> ();\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi110EL\" { target *-*-linux* } } } - fn parm of inline fn\n+ foo <111, parameters_of (^^xyzzy)[0]> ();\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi111EL\" { target *-*-linux* } } } - fn parm of public fn\n+ foo <112, ^^B> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi112EL\" } } - TU-local class\n+ foo <113, ^^C> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi113EL\" } } - TU-local class\n+ foo <114, ^^D> ();\t\t\t\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi114EL\" { target *-*-linux* } } } - public class\n+ foo <115, ^^E> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi115EL\" } } - TU-local class\n+ foo <116, ^^au> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi116EL\" } } - anon union var at namespace scope\n+ foo <117, ^^F> ();\t\t\t\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi117EL\" { target *-*-linux* } } } - public template\n+ foo <118, ^^F > ();\t\t\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi118EL\" { target *-*-linux* } } } - specialization of public template\n+ foo <119, ^^F > ();\t\t\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi119EL\" { target *-*-linux* } } } - specialization of public template\n+ foo <120, ^^F > ();\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi120EL\" } } - specialization with TU-local parameter\n+ foo <121, ^^G> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi121EL\" } } - TU-local template\n+ foo <122, ^^G > ();\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi122EL\" } } - specialization of TU-local template\n+ foo <123, ^^G > ();\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi123EL\" } } - specialization of TU-local template\n+ foo <124, ^^G > ();\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi124EL\" } } - specialization of TU-local template\n+ foo <125, ^^x> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi125EL\" } } - var in public fn but non-comdat - TODO, shall this be exported?\n+ foo <126, ^^v> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi126EL\" } } - var in public fn but non-comdat - TODO, shall this be exported?\n+ foo <127, std::meta::info {}> ();\t\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi127EL\" { target *-*-linux* } } } - null reflection\n+ foo <128, ^^b> ();\t\t\t\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi128EL\" { target *-*-linux* } } } - public variable\n+ foo <129, ^^c> ();\t\t\t\t// { dg-final { scan-assembler-not \"\\t.weak\\t_Z3fooILi129EL\" } } - TU-local variable\n+ foo <130, data_member_spec (^^D, { .name = \"foo\" })> (); // { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi130EL\" { target *-*-linux* } } } - data member spec with public type\n+ foo <131, bases_of (^^H, ctx)[0]> ();\t\t// { dg-final { scan-assembler \"\\t.weak\\t_Z3fooILi131EL\" { target *-*-linux* } } } - direct base relationship with both types public\n+ plugh <42> (x);\n+ garply <42> (x);\n+ fred (x);\n+}\n","prefixes":["9/9","v2"]}