From f22a34cc61b9988f053a86820b27215a6b9f1776 Mon Sep 17 00:00:00 2001
From: "Daniel M. Katz" <katzdm@gmail.com>
Date: Fri, 6 Dec 2024 10:23:58 -0500
Subject: [PATCH] CWG updates. (#206)

---
 2996_reflection/p2996r8.html  | 5269 +++++++++++++++++++--------------
 2996_reflection/reflection.md | 1107 ++++---
 2 files changed, 3679 insertions(+), 2697 deletions(-)

diff --git a/2996_reflection/p2996r8.html b/2996_reflection/p2996r8.html
index 1a4f2a8b..062ffa27 100644
--- a/2996_reflection/p2996r8.html
+++ b/2996_reflection/p2996r8.html
@@ -4,7 +4,7 @@
   <meta charset="utf-8" />
   <meta name="generator" content="mpark/wg21" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
-  <meta name="dcterms.date" content="2024-11-27" />
+  <meta name="dcterms.date" content="2024-12-05" />
   <title>Reflection for C++26</title>
   <style>
       code{white-space: pre-wrap;}
@@ -565,7 +565,7 @@ <h1 class="title" style="text-align:center">Reflection for C++26</h1>
   </tr>
   <tr>
     <td>Date:</td>
-    <td>2024-11-27</td>
+    <td>2024-12-05</td>
   </tr>
   <tr>
     <td style="vertical-align:top">Project:</td>
@@ -574,7 +574,7 @@ <h1 class="title" style="text-align:center">Reflection for C++26</h1>
   <tr>
     <td style="vertical-align:top">Audience:</td>
     <td>
-      CWG, LEWG<br>
+      CWG, LEWG, LWG<br>
     </td>
   </tr>
   <tr>
@@ -753,12 +753,16 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#basic.def.odr-one-definition-rule" id="toc-basic.def.odr-one-definition-rule"><span>6.3
 <span>[basic.def.odr]</span></span> One-definition
 rule<span></span></a></li>
+<li><a href="#basic.lookup.general-general" id="toc-basic.lookup.general-general"><span>6.5.1
+<span>[basic.lookup.general]</span></span> General<span></span></a></li>
 <li><a href="#basic.lookup.argdep-argument-dependent-name-lookup" id="toc-basic.lookup.argdep-argument-dependent-name-lookup"><span>6.5.4
 <span>[basic.lookup.argdep]</span></span> Argument-dependent name
 lookup<span></span></a></li>
 <li><a href="#basic.lookup.qual.general-general" id="toc-basic.lookup.qual.general-general"><span>6.5.5.1
 <span>[basic.lookup.qual.general]</span></span>
 General<span></span></a></li>
+<li><a href="#basic.splice-splice-specifiers" id="toc-basic.splice-splice-specifiers">6.5+ [basic.splice] Splice
+specifiers<span></span></a></li>
 <li><a href="#basic.link-program-and-linkage" id="toc-basic.link-program-and-linkage"><span>6.6
 <span>[basic.link]</span></span> Program and
 Linkage<span></span></a></li>
@@ -767,14 +771,17 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#basic.fundamental-fundamental-types" id="toc-basic.fundamental-fundamental-types"><span>6.8.2
 <span>[basic.fundamental]</span></span> Fundamental
 types<span></span></a></li>
+<li><a href="#basic.lval-value-category" id="toc-basic.lval-value-category"><span>7.2.1
+<span>[basic.lval]</span></span> Value category<span></span></a></li>
+<li><a href="#expr.context-context-dependence" id="toc-expr.context-context-dependence"><span>7.2.3
+<span>[expr.context]</span></span> Context
+dependence<span></span></a></li>
 <li><a href="#expr.prim-primary-expressions" id="toc-expr.prim-primary-expressions"><span>7.5
 <span>[expr.prim]</span></span> Primary
 expressions<span></span></a></li>
-<li><a href="#expr.prim.id.splice-splice-specifiers" id="toc-expr.prim.id.splice-splice-specifiers">7.5.4.0*
-[expr.prim.id.splice] Splice specifiers<span></span></a></li>
-<li><a href="#expr.prim.id.general-general" id="toc-expr.prim.id.general-general"><span>7.5.5.1
+<li><a href="#expr.prim.id.general-general" id="toc-expr.prim.id.general-general"><span>7.5.4.1
 <span>[expr.prim.id.general]</span></span> General<span></span></a></li>
-<li><a href="#expr.prim.id.qual-qualified-names" id="toc-expr.prim.id.qual-qualified-names"><span>7.5.5.3
+<li><a href="#expr.prim.id.qual-qualified-names" id="toc-expr.prim.id.qual-qualified-names"><span>7.5.4.3
 <span>[expr.prim.id.qual]</span></span> Qualified
 names<span></span></a></li>
 <li><a href="#expr.prim.splice-expression-splicing" id="toc-expr.prim.splice-expression-splicing">7.5.8* [expr.prim.splice]
@@ -795,13 +802,11 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#expr.const-constant-expressions" id="toc-expr.const-constant-expressions"><span>7.7
 <span>[expr.const]</span></span> Constant
 Expressions<span></span></a></li>
-<li><a href="#dcl.typedef-the-typedef-specifier" id="toc-dcl.typedef-the-typedef-specifier"><span>9.2.4
-<span>[dcl.typedef]</span></span> The
-<code class="sourceCode cpp"><span class="kw">typedef</span></code>
-specifier<span></span></a></li>
 <li><a href="#dcl.type.simple-simple-type-specifiers" id="toc-dcl.type.simple-simple-type-specifiers"><span>9.2.9.3
 <span>[dcl.type.simple]</span></span> Simple type
 specifiers<span></span></a></li>
+<li><a href="#dcl.type.splice-type-splicing" id="toc-dcl.type.splice-type-splicing">[dcl.type.splice] Type
+splicing<span></span></a></li>
 <li><a href="#dcl.init.general-initializers-general" id="toc-dcl.init.general-initializers-general"><span>9.4.1
 <span>[dcl.init.general]</span></span> Initializers
 (General)<span></span></a></li>
@@ -822,15 +827,20 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#dcl.attr.grammar-attribute-syntax-and-semantics" id="toc-dcl.attr.grammar-attribute-syntax-and-semantics"><span>9.12.1
 <span>[dcl.attr.grammar]</span></span> Attribute syntax and
 semantics<span></span></a></li>
-<li><a href="#module.global.frag-global-module-fragment" id="toc-module.global.frag-global-module-fragment">[module.global.frag]
-Global module fragment<span></span></a></li>
+<li><a href="#module.global.frag-global-module-fragment" id="toc-module.global.frag-global-module-fragment"><span>10.4
+<span>[module.global.frag]</span></span> Global module
+fragment<span></span></a></li>
 <li><a href="#module.reach-reachability" id="toc-module.reach-reachability"><span>10.7
 <span>[module.reach]</span></span> Reachability<span></span></a></li>
-<li><a href="#class.pre-preamble" id="toc-class.pre-preamble">[class.pre] Preamble<span></span></a></li>
-<li><a href="#class.name-class-names" id="toc-class.name-class-names">[class.name] Class
-names<span></span></a></li>
 <li><a href="#class.mem.general-general" id="toc-class.mem.general-general"><span>11.4.1
 <span>[class.mem.general]</span></span> General<span></span></a></li>
+<li><a href="#over.pre-preamble" id="toc-over.pre-preamble">[over.pre]
+Preamble<span></span></a></li>
+<li><a href="#over.match.general-general" id="toc-over.match.general-general"><span>12.2.1
+<span>[over.match.general]</span></span> General<span></span></a></li>
+<li><a href="#over.call.func-call-to-named-function" id="toc-over.call.func-call-to-named-function"><span>12.2.2.2.2
+<span>[over.call.func]</span></span> Call to named
+function<span></span></a></li>
 <li><a href="#over.match.class.deduct-class-template-argument-deduction" id="toc-over.match.class.deduct-class-template-argument-deduction"><span>12.2.2.9
 <span>[over.match.class.deduct]</span></span> Class template argument
 deduction<span></span></a></li>
@@ -859,16 +869,34 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#temp.deduct.guide-deduction-guides" id="toc-temp.deduct.guide-deduction-guides"><span>13.7.2.3
 <span>[temp.deduct.guide]</span></span> Deduction
 guides<span></span></a></li>
+<li><a href="#temp.mem-member-templates" id="toc-temp.mem-member-templates"><span>13.7.3
+<span>[temp.mem]</span></span> Member templates<span></span></a></li>
 <li><a href="#temp.alias-alias-templates" id="toc-temp.alias-alias-templates"><span>13.7.8
 <span>[temp.alias]</span></span> Alias templates<span></span></a></li>
 <li><a href="#temp.res.general-general" id="toc-temp.res.general-general"><span>13.8.1
 <span>[temp.res.general]</span></span> General<span></span></a></li>
+<li><a href="#temp.dep.type-dependent-types" id="toc-temp.dep.type-dependent-types"><span>13.8.3.2
+<span>[temp.dep.type]</span></span> Dependent
+types<span></span></a></li>
 <li><a href="#temp.dep.expr-type-dependent-expressions" id="toc-temp.dep.expr-type-dependent-expressions"><span>13.8.3.3
 <span>[temp.dep.expr]</span></span> Type-dependent
 expressions<span></span></a></li>
 <li><a href="#temp.dep.constexpr-value-dependent-expressions" id="toc-temp.dep.constexpr-value-dependent-expressions"><span>13.8.3.4
 <span>[temp.dep.constexpr]</span></span> Value-dependent
 expressions<span></span></a></li>
+<li><a href="#temp.dep.splice-dependent-splice-specifiers" id="toc-temp.dep.splice-dependent-splice-specifiers">13.8.3.4+
+[temp.dep.splice] Dependent splice specifiers<span></span></a></li>
+<li><a href="#temp.expl.spec-explicit-specialization" id="toc-temp.expl.spec-explicit-specialization"><span>13.9.4
+<span>[temp.expl.spec]</span></span> Explicit
+specialization<span></span></a></li>
+<li><a href="#temp.deduct.general-general" id="toc-temp.deduct.general-general"><span>13.10.3.1
+<span>[temp.deduct.general]</span></span> General<span></span></a></li>
+<li><a href="#temp.deduct.call-deducing-template-arguments-from-a-function-call" id="toc-temp.deduct.call-deducing-template-arguments-from-a-function-call"><span>13.10.3.2
+<span>[temp.deduct.call]</span></span> Deducing template arguments from
+a function call<span></span></a></li>
+<li><a href="#temp.deduct.type-deducing-template-arguments-from-a-type" id="toc-temp.deduct.type-deducing-template-arguments-from-a-type"><span>13.10.3.6
+<span>[temp.deduct.type]</span></span> Deducing template arguments from
+a type<span></span></a></li>
 <li><a href="#cpp.cond-conditional-inclusion" id="toc-cpp.cond-conditional-inclusion"><span>15.2
 <span>[cpp.cond]</span></span> Conditional
 inclusion<span></span></a></li>
@@ -3207,9 +3235,9 @@ <h3 data-number="4.4.1" id="constant-evaluation-order"><span class="header-secti
 translation time.</p>
 <p>Second, we sequence plainly constant-evaluated expressions and
 conversions within the lexical order. Specifically, we require that the
-evaluation of a plainly constant-evaluated expression or conversion
-occurs before the implementation checks the validity of source
-constructs lexically following that expression or conversion.</p>
+evaluation of a non-dependent plainly constant-evaluated expression or
+conversion occurs before the implementation checks the validity of
+source constructs lexically following that expression or conversion.</p>
 <p>Those constraints are mostly intuitive, but they are a significant
 change to the underlying principles of the current standard in this
 respect.</p>
@@ -4890,7 +4918,9 @@ <h3 class="unnumbered" id="lex.phases-phases-of-translation"><span>5.2
 <p><span class="ednote" style="color: #0000ff">[ Editor&#39;s note: In
 addition to changes necessary for this proposal, we are applying the
 “drive-by fix” of merging phases 7/8, in order to clarify that template
-instantiation is interleaved with translation. ]</span></p>
+instantiation is interleaved with translation. In so doing, we replace
+the notion of “instantiation units” with a partial ordering among all
+program constructs in a translation unit. ]</span></p>
 <p>Modify the wording for phases 7-8 of <span>5.2 <a href="https://wg21.link/lex.phases">[lex.phases]</a></span> as
 follows:</p>
 <div class="std">
@@ -4899,16 +4929,7 @@ <h3 class="unnumbered" id="lex.phases-phases-of-translation"><span>5.2
 Whitespace characters separating tokens are no longer significant. Each
 preprocessing token is converted into a token (<span>5.6 <a href="https://wg21.link/lex.token">[lex.token]</a></span>). The
 resulting tokens constitute a translation unit and are syntactically and
-semantically analyzed and translated <span class="addu">alongside any
-instantiation units (see below) that are produced</span>. <span class="addu">During this process, non-dependent plainly
-constant-evaluated expressions ([expr.const]) are evaluated in lexical
-order. Diagnosable rules (<span>4.1.1 <a href="https://wg21.link/intro.compliance.general">[intro.compliance.general]</a></span>)
-that apply to constructs whose syntactic end point occurs lexically
-after the syntactic end point of a non-dependent plainly
-constant-evaluated expression
-<code class="sourceCode cpp"><em>X</em></code> are considered in a
-context where <code class="sourceCode cpp"><em>X</em></code> has been
-evaluated exactly once.</span></p>
+semantically analyzed and translated.</p>
 <p><span class="note3"><span>[ <em>Note 3:</em> </span>The process of
 analyzing and translating the tokens can occasionally result in one
 token being replaced by a sequence of other tokens ([temp.names])<span>
@@ -4924,9 +4945,6 @@ <h3 class="unnumbered" id="lex.phases-phases-of-translation"><span>5.2
 between these entities and any external representation. The description
 is conceptual only, and does not specify any particular
 implementation.<span> — <em>end note</em> ]</span></span></p>
-<p><span class="addu">While the tokens constituting translation units
-are being analyzed and translated, a collection of required
-instantiations is produced.</span></p>
 <p><span class="rm" style="color: #bf0303"><del>Translated translation
 units and instantiation units are combined as follows:</del></span></p>
 <p><span class="rm" style="color: #bf0303"><del><span class="note5"><span>[ <em>Note 5:</em> </span>Some or all of these can
@@ -4935,56 +4953,105 @@ <h3 class="unnumbered" id="lex.phases-phases-of-translation"><span>5.2
 <p><span class="rm" style="color: #bf0303"><del>Each translated
 translation unit is examined to produce a list of required
 instantiations.</del></span></p>
+<p><span class="addu">While the tokens constituting translation units
+are being analyzed and translated, a collection of required
+instantiations is produced.</span></p>
 <p><span class="note5"><span>[ <em>Note 5:</em> </span>This can include
 instantiations which have been explicitly requested
 ([temp.explicit]).<span> — <em>end note</em> ]</span></span></p>
+<p><span class="addu">The contexts from which instantiations may be
+performed are determined by their respective points of instantiation
+(<span>13.8.4.1 <a href="https://wg21.link/temp.point">[temp.point]</a></span>).</span></p>
+<p><span class="addu"><span class="note"><span>[ <em>Note 6:</em>
+</span>Other requirements in this document can further constrain the
+context from which an instantiation can be performed. For example, a
+constexpr function template specialization might have a point of
+instantation at the end of a translation unit, but its use in certain
+constant expressions could require that it be instantiated from an
+earlier point ([temp.inst]).<span> — <em>end
+note</em> ]</span></span></span></p>
 <p>The definitions of the required templates are located. It is
 implementation-defined whether the source of the translation units
 containing these definitions is required to be available.</p>
-<p><span class="rm" style="color: #bf0303"><del><span class="note"><span>[ <em>Note 6:</em> </span>An implementation can
+<p><span class="rm" style="color: #bf0303"><del><span class="note"><span>[ <em>Note 7:</em> </span>An implementation can
 choose to encode sufficient information into the translated translation
 unit so as to ensure the source is not required here.<span> — <em>end
 note</em> ]</span></span></del></span></p>
-<p>All required instantiations are perfomed to produce <em>instantiation
-units</em>.</p>
-<p><span class="note"><span>[ <em>Note 7:</em> </span>These are similar
-to translated translation units, but contain no references to
+<p><span class="rm" style="color: #bf0303"><del>All required
+instantiations are perfomed to produce <em>instantiation
+units</em>.</del></span></p>
+<p><span class="rm" style="color: #bf0303"><del><span class="note"><span>[ <em>Note 8:</em> </span>These are similar to
+translated translation units, but contain no references to
 uninstantiated templates and no template definitions.<span> — <em>end
-note</em> ]</span></span></p>
-<p><span class="addu">The contexts from which instantiations may be
-performed are determined by their respective points of instantiation
-([temp.point]), and may be further constrained by other requirements in
-this document.</span></p>
-<p><span class="addu"><span class="note"><span>[ <em>Note 8:</em>
-</span>For example, a constexpr function template specialization might
-have a point of instantation at the end of a translation unit, but its
-use in certain constant expressions could require that it be
-instantiated from an earlier point ([temp.inst]).<span> — <em>end
-note</em> ]</span></span></span></p>
-<p><span class="addu">During this process, plainly constant-evaluated
-expressions appearing in the same instantiation unit are evaluated in
-lexical order as part of the instantiation process. Diagnosable rules
+note</em> ]</span></span></del></span></p>
+<p><span class="addu">Each instantiation results in new program
+constructs.</span> The program is ill-formed if any instantiation
+fails.</p>
+<p><span class="addu">Instantiation confers a partition over the program
+constructs, and the tokens comprising the translation unit furthermore
+endow the partitioned constructs with a partial order. Two constructs
+are <em>instantiation-sequenced</em> if the tokens by which they are
+described belong to the same translation unit and if either both
+constructs result from the same instantiation or if neither results from
+any instantiation. Given two instantiation-sequenced program constructs,
+whether one <em>semantically follows</em> the other is determined as
+follows:</span></p>
+<ul>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_6" id="pnum_6">(7.8-1)</a></span>
+If both constructs are within the
+<code class="sourceCode cpp"><em>member-specification</em></code> of a
+class <code class="sourceCode cpp">C</code> (<span>11.4.1 <a href="https://wg21.link/class.mem.general">[class.mem.general]</a></span>)
+and one such construct (call it
+<code class="sourceCode cpp"><em>X</em></code>) is in a complete-class
+context of <code class="sourceCode cpp">C</code> but the other (call it
+<code class="sourceCode cpp"><em>Y</em></code>) is not, then
+<code class="sourceCode cpp"><em>X</em></code> semantically follows
+<code class="sourceCode cpp"><em>Y</em></code>.</span></li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_7" id="pnum_7">(7-8.1)</a></span>
+Otherwise, if the syntactic endpoint of the tokens that describe one
+such construct (call it <code class="sourceCode cpp"><em>X</em></code>)
+occurs lexically after the syntactic endpoint of the tokens that
+describe the other (call it
+<code class="sourceCode cpp"><em>Y</em></code>), then
+<code class="sourceCode cpp"><em>X</em></code> semantically follows
+<code class="sourceCode cpp"><em>Y</em></code>.</span></li>
+</ul>
+<p><span class="addu">During the analysis and translation of tokens and
+instantiations, certain expressions are evaluated. Diagnosable rules
 (<span>4.1.1 <a href="https://wg21.link/intro.compliance.general">[intro.compliance.general]</a></span>)
-that apply to constructs whose syntactic end point occurs lexically
-after the syntactic end point of a plainly constant-evaluated expression
-<code class="sourceCode cpp"><em>X</em></code> in the same instantiation
-unit are considered in a context where
-<code class="sourceCode cpp"><em>X</em></code> has been evaluated
+that apply to constructs that semantically follow a plainly
+constant-evaluated expression
+<code class="sourceCode cpp"><em>P</em></code> (<span>7.7 <a href="https://wg21.link/expr.const">[expr.const]</a></span>) are
+considered in a context where
+<code class="sourceCode cpp"><em>P</em></code> has been evaluated
 exactly once.</span></p>
-<p>The program is ill-formed if any instantiation fails.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_6" id="pnum_6">8</a></span>
+<p><span class="addu"><span class="note"><span>[ <em>Note 9:</em>
+</span>Other requirements in this document can further constrain the
+contexts from which expressions are evaluated. For example, a
+declaration that lexically follows all points from which a given
+instantiation can be perfomed will be considered in a context where all
+plainly constant-evaluated expressions resulting from that instantiation
+have been evaluated exactly once.<span> — <em>end
+note</em> ]</span></span></span></p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_8" id="pnum_8">8</a></span>
 All external entity references are resolved. […]</p>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="lex.pptoken-preprocessing-tokens"><span>5.4
 <a href="https://wg21.link/lex.pptoken">[lex.pptoken]</a></span>
 Preprocessing tokens<a href="#lex.pptoken-preprocessing-tokens" class="self-link"></a></h3>
-<p>Add a bullet after <span>5.4 <a href="https://wg21.link/lex.pptoken">[lex.pptoken]</a></span> bullet
-(3.2):</p>
+<p>Add a bullet after bullet (4.2):</p>
 <div class="std">
 <blockquote>
-<p>…</p>
-<p>— Otherwise, if the next three characters are
+<ul>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_9" id="pnum_9">4</a></span>
+If the input stream has been parsed into preprocessing tokens up to a
+given character:</p>
+<ul>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_10" id="pnum_10">(4.1)</a></span>
+…</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_11" id="pnum_11">(4.2)</a></span>
+Otherwise, if the next three characters are
 <code class="sourceCode cpp"><span class="op">&lt;::</span></code> and
 the subsequent character is neither
 <code class="sourceCode cpp"><span class="op">:</span></code> nor
@@ -4992,20 +5059,28 @@ <h3 class="unnumbered" id="lex.pptoken-preprocessing-tokens"><span>5.4
 <code class="sourceCode cpp"><span class="op">&lt;</span></code> is
 treated as a preprocessing token by itself and not as the first
 character of the alternative token
-<code class="sourceCode cpp"><span class="op">&lt;:</span></code>.</p>
-<div class="addu">
-<p>— Otherwise, if the next three characters are
+<code class="sourceCode cpp"><span class="op">&lt;:</span></code>.</p></li>
+<li><p><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_12" id="pnum_12">(4.3)</a></span>
+Otherwise, if the next three characters are
 <code class="sourceCode cpp"><span class="op">[::</span></code> and the
 subsequent character is not
-<code class="sourceCode cpp"><span class="op">:</span></code> or if the
+<code class="sourceCode cpp"><span class="op">:</span></code>, or if the
 next three characters are
 <code class="sourceCode cpp"><span class="op">[:&gt;</span></code>, the
 <code class="sourceCode cpp"><span class="op">[</span></code> is treated
 as a preprocessing token by itself and not as the first character of the
 preprocessing token
-<code class="sourceCode cpp"><span class="op">[:</span></code>.</p>
-</div>
-<p>…</p>
+<code class="sourceCode cpp"><span class="op">[:</span></code>.</span></p>
+<p><span class="addu"><span class="note"><span>[ <em>Note 1:</em>
+</span>The tokens
+<code class="sourceCode cpp"><span class="op">[:</span></code> and
+<code class="sourceCode cpp"><span class="op">:]</span></code> cannot be
+composed from digraphs.<span> — <em>end
+note</em> ]</span></span></span></p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_13" id="pnum_13">(4.4)</a></span>
+…</p></li>
+</ul></li>
+</ul>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="lex.operators-operators-and-punctuators"><span>5.12 <a href="https://wg21.link/lex.operators">[lex.operators]</a></span>
@@ -5013,7 +5088,9 @@ <h3 class="unnumbered" id="lex.operators-operators-and-punctuators"><span>5.12 <
 <p>Change the grammar for
 <code class="sourceCode cpp"><em>operator-or-punctuator</em></code> in
 paragraph 1 of <span>5.12 <a href="https://wg21.link/lex.operators">[lex.operators]</a></span> to
-include splicer delimiters:</p>
+include the reflection operator and the
+<code class="sourceCode cpp"><em>splice-specifier</em></code>
+delimiters:</p>
 <div class="std">
 <blockquote>
 <div class="sourceCode" id="cb103"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb103-1"><a href="#cb103-1" aria-hidden="true" tabindex="-1"></a>  <em>operator-or-punctuator</em>: <em>one of</em></span>
@@ -5031,30 +5108,12 @@ <h3 class="unnumbered" id="lex.operators-operators-and-punctuators"><span>5.12 <
 <h3 class="unnumbered" id="basic.def.odr-one-definition-rule"><span>6.3
 <a href="https://wg21.link/basic.def.odr">[basic.def.odr]</a></span>
 One-definition rule<a href="#basic.def.odr-one-definition-rule" class="self-link"></a></h3>
-<p>Modify paragraph 4.1 to cover splicing of functions:</p>
-<div class="std">
-<blockquote>
-<ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_7" id="pnum_7">(4.1)</a></span>
-A function is named by an expression or conversion if it is the selected
-member of an overload set ([basic.lookup], [over.match], [over.over]) in
-an overload resolution performed as part of forming that expression or
-conversion, <span class="addu">or if it is designated by a
-<code class="sourceCode cpp"><em>splice-expression</em></code>
-([expr.prim.splice]),</span> unless it is a pure virtual function and
-either the expression is not an
-<code class="sourceCode cpp"><em>id-expression</em></code> naming the
-function with an explicitly qualified name or the expression forms a
-pointer to member ([expr.unary.op]).</li>
-</ul>
-</blockquote>
-</div>
 <p>Modify the first sentence of paragraph 5 to cover splicing of
 variables:</p>
 <div class="std">
 <blockquote>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_8" id="pnum_8">5</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_14" id="pnum_14">5</a></span>
 A variable is named by an expression if the expression is an
 <code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or
 <code class="sourceCode cpp"><em>splice-expression</em></code>
@@ -5066,12 +5125,14 @@ <h3 class="unnumbered" id="basic.def.odr-one-definition-rule"><span>6.3
 <div class="std">
 <blockquote>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_9" id="pnum_9">6</a></span>
-A structured binding is odr-used if it appears as a
-potentially-evaluated expression<span class="addu">, or if a reflection
-representing it is the operand of a potentially-evaluated
-<code class="sourceCode cpp"><em>splice-expression</em></code>
-([expr.prim.splice])</span>.</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_15" id="pnum_15">6</a></span>
+A structured binding is <span class="rm" style="color: #bf0303"><del>odr-used if it appears as a
+potentially-evaluated</del></span> <span class="addu">named by an</span>
+expression <span class="addu">if that expression is either an</span>
+<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or a
+<code class="sourceCode cpp"><em>splice-expression</em></code> that
+designates that structured binding. A structured binding is odr-used if
+it is named by a potentially-evaluated expression.</span></li>
 </ul>
 </blockquote>
 </div>
@@ -5079,18 +5140,81 @@ <h3 class="unnumbered" id="basic.def.odr-one-definition-rule"><span>6.3
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_10" id="pnum_10">15pre</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_16" id="pnum_16">15pre</a></span>
 If a class <code class="sourceCode cpp">C</code> is defined in a
-translation unit with a call to a specialization of <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>define_aggregate</code>,
-every definition of that class shall be the result of a call to the same
-specialization; and for every reflection in the range of reflections
-describing its class members and unnamed bit-fields, every other such
-call shall have a corresponding value, occupying the same position in
-its respective range, to which the reflection compares equal.</p>
+translation unit as a result of a call to a specialization of <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>define_aggregate</code>
+and another translation unit contains a definition of
+<code class="sourceCode cpp">C</code> that is not a result of calling
+the same specialization with the same function arguments, the program is
+ill-formed; a diagnostic is required only if
+<code class="sourceCode cpp">C</code> is attached to a named module and
+a prior definition is reachable at the point where a later definition
+occurs.</p>
+</div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_17" id="pnum_17">15</a></span>
+For any <span class="addu">other</span> definable item
+<code class="sourceCode cpp">D</code> with definitions in multiple
+translation units,</p>
+<ul>
+<li>if <code class="sourceCode cpp">D</code> is a non-inline
+non-templated function or variable, or</li>
+<li>if the definitions in different translation units do not satisfy the
+following requirements,</li>
+</ul>
+<p>the program is ill-formed; a diagnostic is required only if the
+definable item is attached to a named module and a prior definition is
+reachable at the point where a later definition occurs. […]</p>
+</blockquote>
 </div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_11" id="pnum_11">15</a></span>
-<span class="addu">Otherwise, for</span> <span class="rm" style="color: #bf0303"><del>For</del></span> any definable item D with
-definitions …</p>
+<p>Clarify in bullet 15.11 that default template-arguments in
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s
+also factor into ODR.</p>
+<div class="std">
+<blockquote>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_18" id="pnum_18">(15.10)</a></span>
+In each such definition, the overloaded operators referred to, the
+implicit calls to conversion functions, constructors, operator new
+functions and operator delete functions, shall refer to the same
+function.</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_19" id="pnum_19">(15.11)</a></span>
+In each such definition, a default argument used by an (implicit or
+explicit) function call or a default template argument used by an
+(implicit or explicit)
+<code class="sourceCode cpp"><em>template-id</em></code><span class="addu">,</span> <span class="rm" style="color: #bf0303"><del>or</del></span>
+<code class="sourceCode cpp"><em>simple-template-id</em></code><span class="addu">, or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+is treated as if its token sequence were present in the definition of
+<code class="sourceCode cpp"><em>D</em></code>; that is, the default
+argument or default template argument is subject to the requirements
+described in this paragraph (recursively).</li>
+</ul>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="basic.lookup.general-general"><span>6.5.1 <a href="https://wg21.link/basic.lookup.general">[basic.lookup.general]</a></span>
+General<a href="#basic.lookup.general-general" class="self-link"></a></h3>
+<p>Modify paragraph 1 to cross-reference to the new definition of
+“overload set” given in [over.pre], rather than define it here.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_20" id="pnum_20">1</a></span>
+[…] If the declarations found by name lookup all denote functions or
+function templates, the declarations <span class="rm" style="color: #bf0303"><del>are said to</del></span> form an <span class="rm" style="color: #bf0303"><del><em>overload
+set</em></del></span> <span class="addu">overload set (<span>12.1 <a href="https://wg21.link/over.pre">[over.pre]</a></span>)</span>.
+Otherwise, […]</p>
+</blockquote>
+</div>
+<p>Adjust the definition in p2 of when a program point follows a
+declaration to account for the removal of instantiation units.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_21" id="pnum_21">2</a></span>
+A program point <code class="sourceCode cpp"><em>P</em></code> is said
+to follow any declaration <span class="addu">with which it is
+instantiation-sequenced (<span>5.2 <a href="https://wg21.link/lex.phases">[lex.phases]</a></span>)</span>
+<span class="rm" style="color: #bf0303"><del>in the same translation
+unit</del></span> whose locus (<span>6.4.2 <a href="https://wg21.link/basic.scope.pdecl">[basic.scope.pdecl]</a></span>)
+is before <code class="sourceCode cpp"><em>P</em></code>.</p>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="basic.lookup.argdep-argument-dependent-name-lookup"><span>6.5.4 <a href="https://wg21.link/basic.lookup.argdep">[basic.lookup.argdep]</a></span>
@@ -5099,21 +5223,29 @@ <h3 class="unnumbered" id="basic.lookup.argdep-argument-dependent-name-lookup"><
 as follows:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_12" id="pnum_12">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_22" id="pnum_22">3</a></span>
 … Any <code class="sourceCode cpp"><em>typedef-name</em></code>s and
 <code class="sourceCode cpp"><em>using-declaration</em></code>s used to
 specify the types do not contribute to this set. The set of entities is
 determined in the following way:</p>
 <ul>
-<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_13" id="pnum_13">(3.1)</a></span>
-If <code class="sourceCode cpp">T</code> is <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,
-its associated set of entities is the singleton containing the function
-<code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>is_type</code>.</span>
+<li><p><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_23" id="pnum_23">(3.1)</a></span>
+If <code class="sourceCode cpp">T</code> is <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>
+([meta.reflection.synop]), its associated set of entities is the
+singleton containing the enumeration type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>operators</code>
+([meta.reflection.operators]).</span></p>
+<p><span class="addu"><span class="note"><span>[ <em>Note 1:</em>
+</span>The <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>
+type is a type alias, so an explicit rule is needed to associate calls
+whose arguments are reflections with the namespace
+<code class="sourceCode cpp">std<span class="op">::</span>meta</code>.<span>
+— <em>end note</em> ]</span></span></span></p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_24" id="pnum_24">(3.2)</a></span>
 If <code class="sourceCode cpp">T</code> is <span class="rm" style="color: #bf0303"><del>a</del></span> <span class="addu">any
 other</span> fundamental type, its associated set of entities is
-empty.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_14" id="pnum_14">(3.2)</a></span>
-If <code class="sourceCode cpp">T</code> is a class type …</li>
+empty.</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_25" id="pnum_25">(3.3)</a></span>
+If <code class="sourceCode cpp">T</code> is a class type …</p></li>
 </ul>
 </blockquote>
 </div>
@@ -5123,56 +5255,121 @@ <h3 class="unnumbered" id="basic.lookup.qual.general-general"><span>6.5.5.1 <a h
 <code class="sourceCode cpp"><em>splice-specifier</em></code>s:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_15" id="pnum_15">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_26" id="pnum_26">1</a></span>
 Lookup of an <em>identifier</em> followed by a
 <code class="sourceCode cpp"><span class="op">::</span></code> scope
 resolution operator considers only namespaces, types, and templates
 whose specializations are types. If a name,
-<code class="sourceCode cpp"><em>template-id</em></code>, <span class="addu"><code class="sourceCode cpp"><em>splice-specifier</em></code>,</span>
+<code class="sourceCode cpp"><em>template-id</em></code>, <span class="addu"><code class="sourceCode cpp"><em>splice-scope-specifier</em></code>,</span>
 or <code class="sourceCode cpp"><em>computed-type-specifier</em></code>
 is followed by a
 <code class="sourceCode cpp"><span class="op">::</span></code>, it shall
-designate a namespace, class, enumeration, <span class="addu">dependent
-<code class="sourceCode cpp"><em>splice-specifier</em></code>,</span> or
-dependent type, and the
+<span class="addu">either be a dependent
+<code class="sourceCode cpp"><em>splice-scope-specifier</em></code>
+([temp.dep.splice]) or it shall</span> designate a namespace, class,
+enumeration, or dependent type, and the
 <code class="sourceCode cpp"><span class="op">::</span></code> is never
 interpreted as a complete nested-name-specifier.</p>
 </blockquote>
 </div>
+<h3 class="unnumbered" id="basic.splice-splice-specifiers">6.5+
+[basic.splice] Splice specifiers<a href="#basic.splice-splice-specifiers" class="self-link"></a></h3>
+<p>Add a new subsection after <span>6.5 <a href="https://wg21.link/basic.lookup">[basic.lookup]</a></span>, and
+renumber accordingly:</p>
+<div class="std">
+<blockquote>
+<div class="addu">
+<p><strong>Splice specifiers [basic.splice]</strong></p>
+<div class="sourceCode" id="cb104"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb104-1"><a href="#cb104-1" aria-hidden="true" tabindex="-1"></a><em>splice-specifier</em>:</span>
+<span id="cb104-2"><a href="#cb104-2" aria-hidden="true" tabindex="-1"></a>  [: <em>constant-expression</em> :]</span>
+<span id="cb104-3"><a href="#cb104-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-4"><a href="#cb104-4" aria-hidden="true" tabindex="-1"></a><em>splice-specialization-specifier</em>:</span>
+<span id="cb104-5"><a href="#cb104-5" aria-hidden="true" tabindex="-1"></a>  <em>splice-specifier</em> &lt; <em>template-argument-list</em><sub><em>opt</em></sub> &gt;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_27" id="pnum_27">1</a></span>
+The <code class="sourceCode cpp"><em>constant-expression</em></code> of
+a <code class="sourceCode cpp"><em>splice-specifier</em></code> shall be
+a converted constant expression ([expr.const]) contextually convertible
+to <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>.
+A <code class="sourceCode cpp"><em>splice-specifier</em></code>
+<em>designates</em> the construct represented by the converted
+<code class="sourceCode cpp"><em>constant-expression</em></code>.</p>
+<p><span class="note"><span>[ <em>Note 1:</em> </span>A
+<code class="sourceCode cpp"><em>splice-specifier</em></code> is
+dependent if the converted
+<code class="sourceCode cpp"><em>constant-expression</em></code> is
+value-dependent ([temp.dep.splice]).<span> — <em>end
+note</em> ]</span></span></p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_28" id="pnum_28">2</a></span>
+The <code class="sourceCode cpp"><em>splice-specifier</em></code> of a
+non-dependent
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+shall designate a template.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_29" id="pnum_29">3</a></span>
+<span class="note"><span>[ <em>Note 2:</em> </span>A
+<code class="sourceCode cpp"><span class="op">&lt;</span></code>
+following a
+<code class="sourceCode cpp"><em>splice-specifier</em></code> is
+interpreted as the delimiter of a
+<code class="sourceCode cpp"><em>template-argument-list</em></code> when
+the <code class="sourceCode cpp"><em>splice-specifier</em></code> is
+preceded by
+<code class="sourceCode cpp"><span class="kw">typename</span></code> or
+<code class="sourceCode cpp"><span class="kw">template</span></code>, or
+when it appears in a type-only context (<span>13.3 <a href="https://wg21.link/temp.names">[temp.names]</a></span>).<span>
+— <em>end note</em> ]</span></span></p>
+<div class="example">
+<span>[ <em>Example 1:</em> </span>
+<div class="sourceCode" id="cb105"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb105-1"><a href="#cb105-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> v <span class="op">=</span> <span class="dv">1</span>;</span>
+<span id="cb105-2"><a href="#cb105-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="dt">int</span> V<span class="op">&gt;</span> <span class="kw">struct</span> TCls <span class="op">{</span></span>
+<span id="cb105-3"><a href="#cb105-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> s <span class="op">=</span> V <span class="op">+</span> <span class="dv">1</span>;</span>
+<span id="cb105-4"><a href="#cb105-4" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
+<span id="cb105-5"><a href="#cb105-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb105-6"><a href="#cb105-6" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> alias <span class="op">=</span> <span class="op">[:^^</span>TCls<span class="op">:]&lt;[:^^</span>v<span class="op">:]&gt;</span>;</span>
+<span id="cb105-7"><a href="#cb105-7" aria-hidden="true" tabindex="-1"></a>  <span class="co">// OK, a splice-specialization-specifier with a splice-specifier</span></span>
+<span id="cb105-8"><a href="#cb105-8" aria-hidden="true" tabindex="-1"></a>  <span class="co">// as a template argument</span></span>
+<span id="cb105-9"><a href="#cb105-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb105-10"><a href="#cb105-10" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>alias<span class="op">::</span>s <span class="op">==</span> <span class="dv">2</span><span class="op">)</span>;</span></code></pre></div>
+<span> — <em>end example</em> ]</span>
+</div>
+</div>
+</blockquote>
+</div>
 <h3 class="unnumbered" id="basic.link-program-and-linkage"><span>6.6 <a href="https://wg21.link/basic.link">[basic.link]</a></span> Program and
 Linkage<a href="#basic.link-program-and-linkage" class="self-link"></a></h3>
 <p>Add a bullet to paragraph 13:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_16" id="pnum_16">13</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_30" id="pnum_30">13</a></span>
 A declaration <code class="sourceCode cpp"><em>D</em></code>
 <em>names</em> an entity <code class="sourceCode cpp"><em>E</em></code>
 if</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_17" id="pnum_17">(13.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_31" id="pnum_31">(13.1)</a></span>
 <code class="sourceCode cpp"><em>D</em></code> contains a
 <code class="sourceCode cpp"><em>lambda-expression</em></code> whose
 closure type is <code class="sourceCode cpp"><em>E</em></code>,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_18" id="pnum_18">(13.1+)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_32" id="pnum_32">(13.1+)</a></span>
 <span class="addu"><code class="sourceCode cpp"><em>D</em></code>
-contains a reflection that represents either
-<code class="sourceCode cpp"><em>E</em></code> or a
-<code class="sourceCode cpp"><em>typedef-name</em></code> or
-<code class="sourceCode cpp"><em>namespace-alias</em></code> that
-denotes <code class="sourceCode cpp"><em>E</em></code>,</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_19" id="pnum_19">(13.2)</a></span>
+contains an expression of type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>
+that represents either <code class="sourceCode cpp"><em>E</em></code> or
+a type alias or namespace alias that denotes
+<code class="sourceCode cpp"><em>E</em></code>,</span></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_33" id="pnum_33">(13.2)</a></span>
 <code class="sourceCode cpp"><em>E</em></code> is not a function or
 function template and <code class="sourceCode cpp"><em>D</em></code>
-contains an <em>id-expression</em>, <em>type-specifier</em>,
-<em>nested-name-specifier</em>, <em>template-name</em>, or
-<em>concept-name denoting</em>
+contains an <code class="sourceCode cpp"><em>id-expression</em></code>,
+<code class="sourceCode cpp"><em>type-specifier</em></code>,
+<code class="sourceCode cpp"><em>nested-name-specifier</em></code>,
+<code class="sourceCode cpp"><em>template-name</em></code>, or
+<code class="sourceCode cpp"><em>concept-name</em></code> denoting
 <code class="sourceCode cpp"><em>E</em></code>, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_20" id="pnum_20">(13.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_34" id="pnum_34">(13.3)</a></span>
 <code class="sourceCode cpp"><em>E</em></code> is a function or function
 template and <code class="sourceCode cpp"><em>D</em></code> contains an
 expression that names <code class="sourceCode cpp"><em>E</em></code>
-([basic.def.odr]) or an <em>id-expression</em> that refers to a set of
-overloads that contains
+([basic.def.odr]) or an
+<code class="sourceCode cpp"><em>id-expression</em></code> that refers
+to a set of overloads that contains
 <code class="sourceCode cpp"><em>E</em></code>.</li>
 </ul>
 </blockquote>
@@ -5181,27 +5378,27 @@ <h3 class="unnumbered" id="basic.link-program-and-linkage"><span>6.6 <a href="ht
 below addition of “value or object of a TU-local type” is in part a
 drive-by fix to make sure that enumerators in a TU-local enumeration are
 also TU-local ]</span></p>
-<p>Extend the definition of <em>TU-local</em> values and objects to
-include reflections:</p>
+<p>Extend the definition of <em>TU-local</em> values and objects in p16
+to include reflections:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_21" id="pnum_21">16</a></span>
-A value or object is <em>TU-local</em> if either</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_35" id="pnum_35">16</a></span>
+A value or object is <em>TU-local</em> if</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_22" id="pnum_22">(16.1)</a></span>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_36" id="pnum_36">(16.0)</a></span>
+it is of TU-local type,</span></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_37" id="pnum_37">(16.1)</a></span>
 it is, or is a pointer to, a TU-local function or the object associated
 with a TU-local variable, <span class="rm" style="color: #bf0303"><del>or</del></span></li>
 </ul>
 <div class="addu">
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_23" id="pnum_23">(16.1a)</a></span>
-it is a value or object of a TU-local type,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_24" id="pnum_24">(16.1b)</a></span>
-it is a reflection representing
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_38" id="pnum_38">(16.1+)</a></span>
+it is a reflection representing either
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_25" id="pnum_25">(16.1b.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_39" id="pnum_39">(16.1+.1)</a></span>
 a TU-local value or object, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_26" id="pnum_26">(16.1b.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_40" id="pnum_40">(16.1+.2)</a></span>
 a <code class="sourceCode cpp"><em>typedef-name</em></code>,
 <code class="sourceCode cpp"><em>namespace-alias</em></code>, or
 <code class="sourceCode cpp"><em>base-specifier</em></code> introduced
@@ -5210,7 +5407,7 @@ <h3 class="unnumbered" id="basic.link-program-and-linkage"><span>6.6 <a href="ht
 </ul>
 </div>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_27" id="pnum_27">(16.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_41" id="pnum_41">(16.2)</a></span>
 it is an object of class or array type and any of its subobjects or any
 of the objects or functions to which its non-static data members of
 reference type refer is TU-local and is usable in constant
@@ -5224,12 +5421,14 @@ <h3 class="unnumbered" id="basic.types.general-general"><span>6.8.1 <a href="htt
 as follows:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_28" id="pnum_28">9</a></span>
-Arithmetic types (6.8.2), enumeration types, pointer types,
-pointer-to-member types (6.8.4), <span class="addu"><code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,</span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_42" id="pnum_42">9</a></span>
+Arithmetic types (<span>6.8.2 <a href="https://wg21.link/basic.fundamental">[basic.fundamental]</a></span>),
+enumeration types, pointer types, pointer-to-member types (<span>6.8.4
+<a href="https://wg21.link/basic.compound">[basic.compound]</a></span>),
+<span class="addu"><code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,</span>
 <code class="sourceCode cpp">std<span class="op">::</span>nullptr_t</code>,
-and cv-qualified (6.8.5) versions of these types are collectively called
-scalar types.</p>
+and cv-qualified versions of these types are collectively called scalar
+types. …</p>
 </blockquote>
 </div>
 <p>Add a new paragraph at the end of <span>6.8.1 <a href="https://wg21.link/basic.types.general">[basic.types.general]</a></span>
@@ -5237,39 +5436,18 @@ <h3 class="unnumbered" id="basic.types.general-general"><span>6.8.1 <a href="htt
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_29" id="pnum_29">12</a></span>
-A <em>consteval-only type</em> is one of the following:</p>
-<ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_30" id="pnum_30">(12.1)</a></span>
-<code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,
-or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_31" id="pnum_31">(12.2)</a></span>
-a pointer or reference to a consteval-only type,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_32" id="pnum_32">(12.3)</a></span>
-a (possibly multi-dimensional) array of a consteval-only type,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_33" id="pnum_33">(12.4)</a></span>
-a class type with a base class or non-static data member of
-consteval-only type,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_34" id="pnum_34">(12.5)</a></span>
-a function type with a return type or parameter type of consteval-only
-type, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_35" id="pnum_35">(12.6)</a></span>
-a pointer-to-member type to a class
-<code class="sourceCode cpp">C</code> of type
-<code class="sourceCode cpp">M</code> where either
-<code class="sourceCode cpp">C</code> or
-<code class="sourceCode cpp">M</code> is a consteval-only type.</li>
-</ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_36" id="pnum_36">13</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_43" id="pnum_43">12</a></span>
+A type is <em>consteval-only</em> if it is either <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>
+or a type compounded from a consteval-only type ([basic.compound]).
 Every object of consteval-only type shall be</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_37" id="pnum_37">(13.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_44" id="pnum_44">(12.1)</a></span>
 the object associated with a constexpr variable or a subobject
 thereof,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_38" id="pnum_38">(13.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_45" id="pnum_45">(12.2)</a></span>
 a template parameter object (<span>13.2 <a href="https://wg21.link/temp.param">[temp.param]</a></span>) or a
 subobject thereof, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_39" id="pnum_39">(13.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_46" id="pnum_46">(12.3)</a></span>
 an object whose lifetime begins and ends during the evaluation of a
 manifestly constant-evaluated expression.</li>
 </ul>
@@ -5283,41 +5461,121 @@ <h3 class="unnumbered" id="basic.fundamental-fundamental-types"><span>6.8.2 <a h
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_40" id="pnum_40">17 - 1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_47" id="pnum_47">17 - 1</a></span>
 A value of type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>
 is called a <em>reflection</em>. There exists a unique <em>null
 reflection</em>; every other reflection is a representation of</p>
 <ul>
-<li>a value with structural type ([temp.param]),</li>
+<li>a value of structural type (<span>13.2 <a href="https://wg21.link/temp.param">[temp.param]</a></span>),</li>
 <li>an object with static storage duration,</li>
 <li>a variable,</li>
 <li>a structured binding,</li>
 <li>a function,</li>
 <li>an enumerator,</li>
-<li>a type or
-<code class="sourceCode cpp"><em>typedef-name</em></code>,</li>
+<li>a <code class="sourceCode cpp"><em>typedef-name</em></code>,</li>
+<li>a type,</li>
 <li>a class member,</li>
-<li>a bit-field,</li>
-<li>a primary class template, function template, primary variable
-template, alias template, or concept,</li>
-<li>a namespace or
-<code class="sourceCode cpp"><em>namespace-alias</em></code>,</li>
-<li>a <code class="sourceCode cpp"><em>base-specifier</em></code>,</li>
-<li>a description of a declaration of a non-static data member, or</li>
-<li>an implementation-defined construct not otherwise specified by this
-document.</li>
+<li>an unnamed bit-field,</li>
+<li>a primary class template,</li>
+<li>a function template,</li>
+<li>a primary variable template,</li>
+<li>an alias template,</li>
+<li>a concept,</li>
+<li>a <code class="sourceCode cpp"><em>namespace-alias</em></code>,</li>
+<li>a namespace,</li>
+<li>a <code class="sourceCode cpp"><em>base-specifier</em></code>,
+or</li>
+<li>a description of a declaration of a non-static data member
+([meta.reflection.define.aggregate]).</li>
 </ul>
 <p>An expression convertible to a reflection is said to
 <em>represent</em> the corresponding construct. <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span></code>
 shall be equal to <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">(</span><span class="dt">void</span><span class="op">*)</span></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_41" id="pnum_41">17 - 2</a></span>
-<em>Recommended practice</em>: Implementations are discouraged from
-representing any constructs described by this document that are not
-explicitly enumerated in the list above (e.g., partial template
-specializations, attributes, placeholder types, statements).</p>
+<div class="example">
+<span>[ <em>Example 1:</em> </span>
+<div class="sourceCode" id="cb106"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb106-1"><a href="#cb106-1" aria-hidden="true" tabindex="-1"></a><span class="dt">int</span> arr<span class="op">[]</span> <span class="op">=</span> <span class="op">{</span><span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span><span class="op">}</span>;</span>
+<span id="cb106-2"><a href="#cb106-2" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> <span class="op">[</span>a1, a2, a3<span class="op">]</span> <span class="op">=</span> arr;</span>
+<span id="cb106-3"><a href="#cb106-3" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> fn<span class="op">()</span>;</span>
+<span id="cb106-4"><a href="#cb106-4" aria-hidden="true" tabindex="-1"></a><span class="kw">enum</span> Enum <span class="op">{</span> A <span class="op">}</span>;</span>
+<span id="cb106-5"><a href="#cb106-5" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> Alias <span class="op">=</span> <span class="dt">int</span>;</span>
+<span id="cb106-6"><a href="#cb106-6" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> B <span class="op">{}</span>;</span>
+<span id="cb106-7"><a href="#cb106-7" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> S <span class="op">:</span> B <span class="op">{</span></span>
+<span id="cb106-8"><a href="#cb106-8" aria-hidden="true" tabindex="-1"></a>  <span class="dt">int</span> mem;</span>
+<span id="cb106-9"><a href="#cb106-9" aria-hidden="true" tabindex="-1"></a>  <span class="dt">int</span> <span class="op">:</span> <span class="dv">0</span>;</span>
+<span id="cb106-10"><a href="#cb106-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
+<span id="cb106-11"><a href="#cb106-11" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span><span class="op">&gt;</span> <span class="kw">struct</span> TCls <span class="op">{}</span>;</span>
+<span id="cb106-12"><a href="#cb106-12" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span><span class="op">&gt;</span> <span class="dt">void</span> TFn<span class="op">()</span>;</span>
+<span id="cb106-13"><a href="#cb106-13" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span><span class="op">&gt;</span> <span class="dt">int</span> TVar;</span>
+<span id="cb106-14"><a href="#cb106-14" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span><span class="op">&gt;</span> <span class="kw">concept</span> Concept <span class="op">=</span> <span class="kw">requires</span> <span class="op">{</span> <span class="kw">true</span>; <span class="op">}</span>;</span>
+<span id="cb106-15"><a href="#cb106-15" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> NS <span class="op">{}</span>;</span>
+<span id="cb106-16"><a href="#cb106-16" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> NSAlias <span class="op">=</span> NS;</span>
+<span id="cb106-17"><a href="#cb106-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-18"><a href="#cb106-18" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r1 <span class="op">=</span> std<span class="op">::</span>meta<span class="op">::</span>reflect_value<span class="op">(</span><span class="dv">42</span><span class="op">)</span>;  <span class="co">// represents int value of 42</span></span>
+<span id="cb106-19"><a href="#cb106-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-20"><a href="#cb106-20" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r2 <span class="op">=</span> std<span class="op">::</span>meta<span class="op">::</span>reflect_object<span class="op">(</span>arr<span class="op">[</span><span class="dv">1</span><span class="op">])</span>;  <span class="co">// represents int object</span></span>
+<span id="cb106-21"><a href="#cb106-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-22"><a href="#cb106-22" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r3 <span class="op">=</span> <span class="op">^^</span>arr;      <span class="co">// represents a variable</span></span>
+<span id="cb106-23"><a href="#cb106-23" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r4 <span class="op">=</span> <span class="op">^^</span>a3;       <span class="co">// represents a structured binding</span></span>
+<span id="cb106-24"><a href="#cb106-24" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r5 <span class="op">=</span> <span class="op">^^</span>fn;       <span class="co">// represents a function</span></span>
+<span id="cb106-25"><a href="#cb106-25" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r6 <span class="op">=</span> <span class="op">^^</span>Enum<span class="op">::</span>A;  <span class="co">// represents an enumerator</span></span>
+<span id="cb106-26"><a href="#cb106-26" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r7 <span class="op">=</span> <span class="op">^^</span>Alias;    <span class="co">// represents a typedef-name</span></span>
+<span id="cb106-27"><a href="#cb106-27" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r8 <span class="op">=</span> <span class="op">^^</span>S;        <span class="co">// represents a type</span></span>
+<span id="cb106-28"><a href="#cb106-28" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r9 <span class="op">=</span> <span class="op">^^</span>S<span class="op">::</span>mem;   <span class="co">// represents a class member</span></span>
+<span id="cb106-29"><a href="#cb106-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-30"><a href="#cb106-30" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r10 <span class="op">=</span> std<span class="op">::</span>meta<span class="op">::</span>members_of<span class="op">(^^</span>S<span class="op">)[</span><span class="dv">1</span><span class="op">]</span>;</span>
+<span id="cb106-31"><a href="#cb106-31" aria-hidden="true" tabindex="-1"></a>    <span class="co">// represents an unnamed bit-field</span></span>
+<span id="cb106-32"><a href="#cb106-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-33"><a href="#cb106-33" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r11 <span class="op">=</span> <span class="op">^^</span>TCls;     <span class="co">// represents a class template</span></span>
+<span id="cb106-34"><a href="#cb106-34" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r12 <span class="op">=</span> <span class="op">^^</span>TFn;      <span class="co">// represents a function template</span></span>
+<span id="cb106-35"><a href="#cb106-35" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r13 <span class="op">=</span> <span class="op">^^</span>TVar;     <span class="co">// represents a variable template</span></span>
+<span id="cb106-36"><a href="#cb106-36" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r14 <span class="op">=</span> <span class="op">^^</span>Concept;  <span class="co">// represents a concept</span></span>
+<span id="cb106-37"><a href="#cb106-37" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r15 <span class="op">=</span> <span class="op">^^</span>NSAlias;  <span class="co">// represents a namespace-alias</span></span>
+<span id="cb106-38"><a href="#cb106-38" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r16 <span class="op">=</span> <span class="op">^^</span>NS;       <span class="co">// represents a namespace</span></span>
+<span id="cb106-39"><a href="#cb106-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-40"><a href="#cb106-40" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r17 <span class="op">=</span> std<span class="op">::</span>meta<span class="op">::</span>bases_of<span class="op">(^^</span>S<span class="op">)[</span><span class="dv">0</span><span class="op">]</span>;</span>
+<span id="cb106-41"><a href="#cb106-41" aria-hidden="true" tabindex="-1"></a>    <span class="co">// represents a base-specifier</span></span>
+<span id="cb106-42"><a href="#cb106-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-43"><a href="#cb106-43" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r18 <span class="op">=</span> std<span class="op">::</span>meta<span class="op">::</span>data_member_spec<span class="op">(^^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">&quot;member&quot;</span><span class="op">})</span>;</span>
+<span id="cb106-44"><a href="#cb106-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">// represents a description of a declaration of a non-static data member.</span></span></code></pre></div>
+<span> — <em>end example</em> ]</span>
+</div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_48" id="pnum_48">17 - 2</a></span>
+<span class="note"><span>[ <em>Note 1:</em> </span>Implementations are
+discouraged from representing any constructs described by this document
+that are not explicitly enumerated in the list above (e.g., partial
+template specializations, attributes, placeholder types, statements).
+Constructs not described by this document can also be represented.<span>
+— <em>end note</em> ]</span></span></p>
 </div>
 </blockquote>
 </div>
+<h3 class="unnumbered" id="basic.lval-value-category"><span>7.2.1 <a href="https://wg21.link/basic.lval">[basic.lval]</a></span> Value
+category<a href="#basic.lval-value-category" class="self-link"></a></h3>
+<p>Apply a drive-by fix to bullet 1.1 clarifying that a glvalue can also
+determine the identity of a non-static data member.</p>
+<div class="std">
+<blockquote>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_49" id="pnum_49">(1.1)</a></span>
+A <em>glvalue</em> is an expression whose evaluation determines the
+identity of an object<span class="addu">,</span> <span class="rm" style="color: #bf0303"><del>or</del></span> function<span class="addu">,
+or non-static data member</span>.</li>
+</ul>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="expr.context-context-dependence"><span>7.2.3
+<a href="https://wg21.link/expr.context">[expr.context]</a></span>
+Context dependence<a href="#expr.context-context-dependence" class="self-link"></a></h3>
+<p>Add <code class="sourceCode cpp"><em>reflect-expression</em></code>s
+to the list of unevaluated operands in paragraph 1.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_50" id="pnum_50">1</a></span>
+In some contexts, <em>unevaluated operands</em> appear ([expr.prim.req],
+[expr.typeid], [expr.sizeof], [expr.unary.noexcept], <span class="addu">[expr.reflect],</span> [temp.pre], [temp.concept]). An
+unevaluated operand is not evaluated.</p>
+</blockquote>
+</div>
 <h3 class="unnumbered" id="expr.prim-primary-expressions"><span>7.5 <a href="https://wg21.link/expr.prim">[expr.prim]</a></span> Primary
 expressions<a href="#expr.prim-primary-expressions" class="self-link"></a></h3>
 <p>Change the grammar for
@@ -5327,205 +5585,122 @@ <h3 class="unnumbered" id="expr.prim-primary-expressions"><span>7.5 <a href="htt
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb104"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb104-1"><a href="#cb104-1" aria-hidden="true" tabindex="-1"></a>  <em>primary-expression</em>:</span>
-<span id="cb104-2"><a href="#cb104-2" aria-hidden="true" tabindex="-1"></a>     <em>literal</em></span>
-<span id="cb104-3"><a href="#cb104-3" aria-hidden="true" tabindex="-1"></a>     this</span>
-<span id="cb104-4"><a href="#cb104-4" aria-hidden="true" tabindex="-1"></a>     ( <em>expression</em> )</span>
-<span id="cb104-5"><a href="#cb104-5" aria-hidden="true" tabindex="-1"></a>     <em>id-expression</em></span>
-<span id="cb104-6"><a href="#cb104-6" aria-hidden="true" tabindex="-1"></a>     <em>lambda-expression</em></span>
-<span id="cb104-7"><a href="#cb104-7" aria-hidden="true" tabindex="-1"></a>     <em>fold-expression</em></span>
-<span id="cb104-8"><a href="#cb104-8" aria-hidden="true" tabindex="-1"></a>     <em>requires-expression</em></span>
-<span id="cb104-9"><a href="#cb104-9" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>splice-expression</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb107"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb107-1"><a href="#cb107-1" aria-hidden="true" tabindex="-1"></a>  <em>primary-expression</em>:</span>
+<span id="cb107-2"><a href="#cb107-2" aria-hidden="true" tabindex="-1"></a>     <em>literal</em></span>
+<span id="cb107-3"><a href="#cb107-3" aria-hidden="true" tabindex="-1"></a>     this</span>
+<span id="cb107-4"><a href="#cb107-4" aria-hidden="true" tabindex="-1"></a>     ( <em>expression</em> )</span>
+<span id="cb107-5"><a href="#cb107-5" aria-hidden="true" tabindex="-1"></a>     <em>id-expression</em></span>
+<span id="cb107-6"><a href="#cb107-6" aria-hidden="true" tabindex="-1"></a>     <em>lambda-expression</em></span>
+<span id="cb107-7"><a href="#cb107-7" aria-hidden="true" tabindex="-1"></a>     <em>fold-expression</em></span>
+<span id="cb107-8"><a href="#cb107-8" aria-hidden="true" tabindex="-1"></a>     <em>requires-expression</em></span>
+<span id="cb107-9"><a href="#cb107-9" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>splice-expression</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
-<h3 class="unnumbered" id="expr.prim.id.splice-splice-specifiers">7.5.4.0*
-[expr.prim.id.splice] Splice specifiers<a href="#expr.prim.id.splice-splice-specifiers" class="self-link"></a></h3>
-<p>Add a new vocabulary of nonterminals for various forms of
-splicers:</p>
-<div class="std">
-<blockquote>
-<div class="addu">
-<div class="sourceCode" id="cb105"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb105-1"><a href="#cb105-1" aria-hidden="true" tabindex="-1"></a><em>splice-specifier</em>:</span>
-<span id="cb105-2"><a href="#cb105-2" aria-hidden="true" tabindex="-1"></a>  [: <em>constant-expression</em> :]</span>
-<span id="cb105-3"><a href="#cb105-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb105-4"><a href="#cb105-4" aria-hidden="true" tabindex="-1"></a><em>splice-expr-template-specifier</em>:</span>
-<span id="cb105-5"><a href="#cb105-5" aria-hidden="true" tabindex="-1"></a>    template <em>splice-specifier</em></span>
-<span id="cb105-6"><a href="#cb105-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb105-7"><a href="#cb105-7" aria-hidden="true" tabindex="-1"></a><em>splice-type-specifier</em>:</span>
-<span id="cb105-8"><a href="#cb105-8" aria-hidden="true" tabindex="-1"></a>    typename<sub><em>opt</em></sub> template<sub><em>opt</em></sub> <em>splice-specifier</em></span></code></pre></div>
-<p>The term <em>splicer</em> generically refers to a
-<code class="sourceCode cpp"><em>splice-specifier</em></code>, a
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>,
-or a
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_42" id="pnum_42">1</a></span>
-The <code class="sourceCode cpp"><em>constant-expression</em></code> of
-a <code class="sourceCode cpp"><em>splice-specifier</em></code> shall be
-a converted constant expression ([expr.const]) contextually convertible
-to <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>.
-A <code class="sourceCode cpp"><em>splice-specifier</em></code>
-designates the construct represented by the converted
-<code class="sourceCode cpp"><em>constant-expression</em></code>, and is
-dependent if the converted
-<code class="sourceCode cpp"><em>constant-expression</em></code> is
-value-dependent.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_43" id="pnum_43">2</a></span>
-A
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>
-or <code class="sourceCode cpp"><em>splice-type-specifier</em></code>
-designates the construct designated by the
-<code class="sourceCode cpp"><em>splice-specifier</em></code>. A
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>
-designates either a function template a primary variable template, or a
-concept. A
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>
-designates either a type,
-<code class="sourceCode cpp"><em>typedef-name</em></code>, primary class
-template, alias template, or concept.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_44" id="pnum_44">3</a></span>
-The form <code class="sourceCode cpp"><span class="kw">template</span> <em>splice-specifier</em></code>
-is interpreted as a
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>
-when</p>
-<ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_45" id="pnum_45">(3.1)</a></span>
-it is preceded by
-<code class="sourceCode cpp"><span class="kw">typename</span></code>,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_46" id="pnum_46">(3.2)</a></span>
-it is within a type-only context,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_47" id="pnum_47">(3.3)</a></span>
-it is followed by
-<code class="sourceCode cpp"><span class="kw">auto</span></code> or
-<code class="sourceCode cpp"><span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span></code>,
-or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_48" id="pnum_48">(3.4)</a></span>
-the <code class="sourceCode cpp"><em>splice-specifier</em></code> is not
-dependent and designates a primary class template or alias
-template.</li>
-</ul>
-<p>In all other cases, it is interpreted as a
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_49" id="pnum_49">4</a></span>
-The <code class="sourceCode cpp"><span class="kw">typename</span></code>
-in a <code class="sourceCode cpp"><em>splice-type-specifier</em></code>
-may only be omitted in a type-only context, or when the
-<code class="sourceCode cpp"><em>splice-specifier</em></code> is
-preceded by
-<code class="sourceCode cpp"><span class="kw">template</span></code>.</p>
-<div class="example">
-<span>[ <em>Example 1:</em> </span>
-<div class="sourceCode" id="cb106"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb106-1"><a href="#cb106-1" aria-hidden="true" tabindex="-1"></a><span class="dt">int</span> var;</span>
-<span id="cb106-2"><a href="#cb106-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> cls <span class="op">{}</span>;</span>
-<span id="cb106-3"><a href="#cb106-3" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> <span class="dt">int</span> t_var <span class="op">=</span> <span class="dv">0</span>;</span>
-<span id="cb106-4"><a href="#cb106-4" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> <span class="kw">struct</span> t_cls <span class="op">{</span> <span class="op">}</span>;</span>
-<span id="cb106-5"><a href="#cb106-5" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span><span class="op">&gt;</span> <span class="kw">concept</span> always_true <span class="op">=</span> <span class="kw">requires</span> <span class="op">{</span> <span class="kw">true</span>; <span class="op">}</span>;</span>
-<span id="cb106-6"><a href="#cb106-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-7"><a href="#cb106-7" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span> Var, <span class="kw">auto</span> Cls, <span class="kw">auto</span> TVar, <span class="kw">auto</span> TCls, <span class="kw">auto</span> Concept<span class="op">&gt;</span></span>
-<span id="cb106-8"><a href="#cb106-8" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> dependent<span class="op">()</span> <span class="op">{</span></span>
-<span id="cb106-9"><a href="#cb106-9" aria-hidden="true" tabindex="-1"></a>  <span class="op">[:</span>Var<span class="op">:]</span> <span class="op">*</span>var;                      <span class="co">// OK, multiplication of &#39;var * var&#39;</span></span>
-<span id="cb106-10"><a href="#cb106-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-11"><a href="#cb106-11" aria-hidden="true" tabindex="-1"></a>  <span class="kw">typename</span> <span class="op">[:</span>Cls<span class="op">:]</span> <span class="op">*</span>a;               <span class="co">// OK, declaration of &#39;cls *a&#39;</span></span>
-<span id="cb106-12"><a href="#cb106-12" aria-hidden="true" tabindex="-1"></a>  <span class="kw">template</span> <span class="op">[:</span>TVar<span class="op">:]&lt;</span><span class="dv">0</span><span class="op">&gt;</span> <span class="op">*</span>var;         <span class="co">// OK, multiplication of &#39;t_var&lt;0&gt; * var&#39;</span></span>
-<span id="cb106-13"><a href="#cb106-13" aria-hidden="true" tabindex="-1"></a>  <span class="kw">template</span> <span class="op">[:</span>TCls<span class="op">:]&lt;</span><span class="dv">0</span><span class="op">&gt;</span> <span class="op">*</span>var;         <span class="co">// error: cannot splice type as expression</span></span>
-<span id="cb106-14"><a href="#cb106-14" aria-hidden="true" tabindex="-1"></a>  <span class="kw">typename</span> <span class="op">[:</span>TCls<span class="op">:]&lt;</span><span class="dv">0</span><span class="op">&gt;</span> <span class="op">*</span>b;           <span class="co">// OK, declaration of &#39;t_cls&lt;0&gt; *b&#39;</span></span>
-<span id="cb106-15"><a href="#cb106-15" aria-hidden="true" tabindex="-1"></a>  <span class="kw">typename</span> <span class="kw">template</span> <span class="op">[:</span>TCls<span class="op">:]&lt;</span><span class="dv">0</span><span class="op">&gt;</span> <span class="op">*</span>c;  <span class="co">// OK</span></span>
-<span id="cb106-16"><a href="#cb106-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-17"><a href="#cb106-17" aria-hidden="true" tabindex="-1"></a>  <span class="kw">template</span> <span class="op">[:</span>Concept<span class="op">:]</span> <span class="kw">auto</span> d <span class="op">=</span> <span class="dv">0</span>;   <span class="co">// OK, deduced placeholder type</span></span>
-<span id="cb106-18"><a href="#cb106-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-19"><a href="#cb106-19" aria-hidden="true" tabindex="-1"></a>  <span class="op">[:</span>Cls<span class="op">:]::</span>k <span class="op">=</span> <span class="dv">1</span>;                    <span class="co">// OK</span></span>
-<span id="cb106-20"><a href="#cb106-20" aria-hidden="true" tabindex="-1"></a>  <span class="kw">typename</span> <span class="op">[:</span>TCls<span class="op">:]&lt;</span><span class="dv">1</span><span class="op">&gt;::</span>type var;    <span class="co">// OK, &#39;typename&#39; binds to &#39;type&#39;.</span></span>
-<span id="cb106-21"><a href="#cb106-21" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
-<span id="cb106-22"><a href="#cb106-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-23"><a href="#cb106-23" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> non_dependent<span class="op">()</span> <span class="op">{</span></span>
-<span id="cb106-24"><a href="#cb106-24" aria-hidden="true" tabindex="-1"></a>  dependent<span class="op">&lt;^^</span>var, <span class="op">^^</span>cls, <span class="op">^^</span>t_var, <span class="op">^^</span>t_cls, <span class="op">^^</span>always_true<span class="op">&gt;()</span>;</span>
-<span id="cb106-25"><a href="#cb106-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-26"><a href="#cb106-26" aria-hidden="true" tabindex="-1"></a>  <span class="kw">template</span> <span class="op">[:^^</span>t_cls<span class="op">:]&lt;</span><span class="dv">0</span><span class="op">&gt;</span> <span class="op">*</span>var1;  <span class="co">// OK, non-dependent context</span></span>
-<span id="cb106-27"><a href="#cb106-27" aria-hidden="true" tabindex="-1"></a>  <span class="op">[:^^</span>t_cls<span class="op">:]&lt;</span><span class="dv">0</span><span class="op">&gt;</span> <span class="op">*</span>var2;           <span class="co">// error: interpreted as multiplication.</span></span>
-<span id="cb106-28"><a href="#cb106-28" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
-<span> — <em>end example</em> ]</span>
-</div>
-</div>
-</blockquote>
-</div>
-<h3 class="unnumbered" id="expr.prim.id.general-general"><span>7.5.5.1
+<h3 class="unnumbered" id="expr.prim.id.general-general"><span>7.5.4.1
 <a href="https://wg21.link/expr.prim.id.general">[expr.prim.id.general]</a></span>
 General<a href="#expr.prim.id.general-general" class="self-link"></a></h3>
-<p>Add a carve-out for reflection in <span>7.5.5.1 <a href="https://wg21.link/expr.prim.id.general">[expr.prim.id.general]</a></span>/4.
-Adjust the wording to reflect the fact that a
-<code class="sourceCode cpp"><em>reflect-expression</em></code> operand
-is not formally an
-<code class="sourceCode cpp"><em>id-expression</em></code>:</p>
-<div class="std">
-<blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_50" id="pnum_50">4</a></span>
-<span class="rm" style="color: #bf0303"><del>An
-<span><code class="sourceCode default"><em>id-expression</em></code></span>
-that denotes a</del></span> <span class="addu">A</span> non-static data
-member or implicit object member function of a class can only be <span class="rm" style="color: #bf0303"><del>used</del></span> <span class="addu">denoted</span>:</p>
-<ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_51" id="pnum_51">(4.1)</a></span>
-as part of a class member access (after any implicit transformation (see
-above)) in which the object expression refers to the member’s class or a
-class derived from that class, or</li>
-</ul>
-<div class="addu">
+<p>Modify paragraph 2 to avoid transforming non-static members into
+implicit member accesses when named as operands to
+<code class="sourceCode cpp"><em>reflect-expression</em></code>s.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_51" id="pnum_51">2</a></span>
+If an <code class="sourceCode cpp"><em>id-expression</em></code>
+<code class="sourceCode cpp"><em>E</em></code> denotes a non-static
+non-type member of some class <code class="sourceCode cpp">C</code> at a
+point where the current class (<span>7.5.2 <a href="https://wg21.link/expr.prim.this">[expr.prim.this]</a></span>) is
+<code class="sourceCode cpp">X</code> and</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_52" id="pnum_52">(4.2)</a></span>
-by the operand of a
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_52" id="pnum_52">(2.1)</a></span>
+<code class="sourceCode cpp"><em>E</em></code> is potentially evaluated
+or <code class="sourceCode cpp">C</code> is
+<code class="sourceCode cpp">X</code> or a base class of
+<code class="sourceCode cpp">X</code>, and</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_53" id="pnum_53">(2.2)</a></span>
+<code class="sourceCode cpp"><em>E</em></code> is not the
+<code class="sourceCode cpp"><em>id-expression</em></code> of a class
+member access expression (<span>7.6.1.5 <a href="https://wg21.link/expr.ref">[expr.ref]</a></span>), and</li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_54" id="pnum_54">(2.3)</a></span>
+<code class="sourceCode cpp"><em>E</em></code> is not the
+<code class="sourceCode cpp"><em>id-expression</em></code> of a
 <code class="sourceCode cpp"><em>reflect-expression</em></code>
-([expr.reflect]), or</li>
-</ul>
-</div>
-<ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_53" id="pnum_53">(4.3)</a></span>
-to form a pointer to member ([expr.unary.op]), or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_54" id="pnum_54">(4.4)</a></span>
-<span class="rm" style="color: #bf0303"><del>if that</del></span> <span class="addu">by an</span>
-<code class="sourceCode cpp"><em>id-expression</em></code> <span class="rm" style="color: #bf0303"><del>denotes</del></span> <span class="addu">denoting</span> a non-static data member <span class="rm" style="color: #bf0303"><del>and it appears</del></span> in an
-unevaluated operand.</li>
+([expr.reflect]), and</span></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_55" id="pnum_55">(2.4)</a></span>
+if <code class="sourceCode cpp"><em>E</em></code> is a
+<code class="sourceCode cpp"><em>qualified-id</em></code>,
+<code class="sourceCode cpp"><em>E</em></code> is not the
+un-parenthesized operand of the unary
+<code class="sourceCode cpp"><span class="op">&amp;</span></code>
+operator (<span>7.6.2.2 <a href="https://wg21.link/expr.unary.op">[expr.unary.op]</a></span>),</li>
 </ul>
+<p>the <code class="sourceCode cpp"><em>id-expression</em></code> is
+transformed into a class member access expression using <code class="sourceCode cpp"><span class="op">(*</span><span class="kw">this</span><span class="op">)</span></code>
+as the object expression.</p>
 </blockquote>
 </div>
-<h3 class="unnumbered" id="expr.prim.id.qual-qualified-names"><span>7.5.5.3 <a href="https://wg21.link/expr.prim.id.qual">[expr.prim.id.qual]</a></span>
+<h3 class="unnumbered" id="expr.prim.id.qual-qualified-names"><span>7.5.4.3 <a href="https://wg21.link/expr.prim.id.qual">[expr.prim.id.qual]</a></span>
 Qualified names<a href="#expr.prim.id.qual-qualified-names" class="self-link"></a></h3>
-<p>Add a production to the grammar for
+<p>Extend the grammar for
 <code class="sourceCode cpp"><em>nested-name-specifier</em></code> as
 follows:</p>
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb107"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb107-1"><a href="#cb107-1" aria-hidden="true" tabindex="-1"></a>  <em>nested-name-specifier</em>:</span>
-<span id="cb107-2"><a href="#cb107-2" aria-hidden="true" tabindex="-1"></a>      ::</span>
-<span id="cb107-3"><a href="#cb107-3" aria-hidden="true" tabindex="-1"></a>      <em>type-name</em> ::</span>
-<span id="cb107-4"><a href="#cb107-4" aria-hidden="true" tabindex="-1"></a>      <em>namespace-name</em> ::</span>
-<span id="cb107-5"><a href="#cb107-5" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-specifier</em> ::</span></span>
-<span id="cb107-6"><a href="#cb107-6" aria-hidden="true" tabindex="-1"></a>      <em>computed-type-specifier</em> ::</span>
-<span id="cb107-7"><a href="#cb107-7" aria-hidden="true" tabindex="-1"></a>      <em>nested-name-specifier</em> <em>identifier</em> ::</span>
-<span id="cb107-8"><a href="#cb107-8" aria-hidden="true" tabindex="-1"></a>      <em>nested-name-specifier</em> template<sub><em>opt</em></sub> <em>simple-template-id</em> ::</span></code></pre></div>
+<div class="sourceCode" id="cb108"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb108-1"><a href="#cb108-1" aria-hidden="true" tabindex="-1"></a>  <em>nested-name-specifier</em>:</span>
+<span id="cb108-2"><a href="#cb108-2" aria-hidden="true" tabindex="-1"></a>      ::</span>
+<span id="cb108-3"><a href="#cb108-3" aria-hidden="true" tabindex="-1"></a>      <em>type-name</em> ::</span>
+<span id="cb108-4"><a href="#cb108-4" aria-hidden="true" tabindex="-1"></a>      <em>namespace-name</em> ::</span>
+<span id="cb108-5"><a href="#cb108-5" aria-hidden="true" tabindex="-1"></a>      <em>computed-type-specifier</em> ::</span>
+<span id="cb108-6"><a href="#cb108-6" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-scope-specifier</em> ::</span></span>
+<span id="cb108-7"><a href="#cb108-7" aria-hidden="true" tabindex="-1"></a>      <em>nested-name-specifier</em> <em>identifier</em> ::</span>
+<span id="cb108-8"><a href="#cb108-8" aria-hidden="true" tabindex="-1"></a>      <em>nested-name-specifier</em> template<sub><em>opt</em></sub> <em>simple-template-id</em> ::</span>
+<span id="cb108-9"><a href="#cb108-9" aria-hidden="true" tabindex="-1"></a><span class="va">+</span></span>
+<span id="cb108-10"><a href="#cb108-10" aria-hidden="true" tabindex="-1"></a><span class="va">+  <em>splice-scope-specifier</em>:</span></span>
+<span id="cb108-11"><a href="#cb108-11" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-specifier</em></span></span>
+<span id="cb108-12"><a href="#cb108-12" aria-hidden="true" tabindex="-1"></a><span class="va">+     template<sub><em>opt</em></sub> <em>splice-specialization-specifier</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
-<p>Add a new paragraph restricting
-<code class="sourceCode cpp"><em>splice-specifier</em></code>, and
-renumber accordingly:</p>
+<p>Add a paragraph after paragraph 1 specifying the rules for parsing a
+<code class="sourceCode cpp"><em>splice-scope-specifier</em></code>, as
+well as an example:</p>
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_55" id="pnum_55">0</a></span>
-The <code class="sourceCode cpp"><em>splice-specifier</em></code> of a
-<code class="sourceCode cpp"><em>nested-name-specifier</em></code>, if
-any, shall either be dependent or designate a class, a
-<code class="sourceCode cpp"><em>typedef-name</em></code> denoting a
-class, a namespace, or a
-<code class="sourceCode cpp"><em>namespace-alias</em></code>.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_56" id="pnum_56">1+</a></span>
+A <code class="sourceCode cpp"><em>splice-specifier</em></code> or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+that is not followed by
+<code class="sourceCode cpp"><span class="op">::</span></code> is never
+interpreted as part of a
+<code class="sourceCode cpp"><em>splice-scope-specifier</em></code>. The
+<code class="sourceCode cpp"><span class="kw">template</span></code> may
+only be omitted from the form <code class="sourceCode cpp">template<sub><em>opt</em></sub> <em>splice-specialization-specifier</em> <span class="op">::</span></code>
+when the
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+is preceded by
+<code class="sourceCode cpp"><span class="kw">typename</span></code>.</p>
+<div class="example">
+<span>[ <em>Example 1:</em> </span>
+<div class="sourceCode" id="cb109"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb109-1"><a href="#cb109-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="dt">int</span> V<span class="op">&gt;</span></span>
+<span id="cb109-2"><a href="#cb109-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> TCls <span class="op">{</span></span>
+<span id="cb109-3"><a href="#cb109-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> s <span class="op">=</span> V;</span>
+<span id="cb109-4"><a href="#cb109-4" aria-hidden="true" tabindex="-1"></a>  <span class="kw">using</span> type <span class="op">=</span> <span class="dt">int</span>;</span>
+<span id="cb109-5"><a href="#cb109-5" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
+<span id="cb109-6"><a href="#cb109-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb109-7"><a href="#cb109-7" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> v1 <span class="op">=</span> <span class="op">[:^^</span>TCls<span class="op">&lt;</span><span class="dv">1</span><span class="op">&gt;:]::</span>s;</span>
+<span id="cb109-8"><a href="#cb109-8" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> v2 <span class="op">=</span> <span class="kw">template</span> <span class="op">[:^^</span>TCls<span class="op">:]&lt;</span><span class="dv">2</span><span class="op">&gt;::</span>s;</span>
+<span id="cb109-9"><a href="#cb109-9" aria-hidden="true" tabindex="-1"></a>  <span class="co">// OK, template binds to splice-scope-specifier</span></span>
+<span id="cb109-10"><a href="#cb109-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb109-11"><a href="#cb109-11" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">typename</span> <span class="op">[:^^</span>TCls<span class="op">:]&lt;</span><span class="dv">3</span><span class="op">&gt;::</span>type v3 <span class="op">=</span> <span class="dv">3</span>;</span>
+<span id="cb109-12"><a href="#cb109-12" aria-hidden="true" tabindex="-1"></a>  <span class="co">// OK, typename binds to the qualified name</span></span></code></pre></div>
+<span> — <em>end example</em> ]</span>
+</div>
 </div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_56" id="pnum_56">1</a></span>
-The component names of a
-<code class="sourceCode cpp"><em>qualified-id</em></code> are […]</p>
 </blockquote>
 </div>
-<p>Clarify that a splice cannot appear in a declarative
+<p>Clarify in paragraph 2 that a splice cannot appear in a declarative
 <code class="sourceCode cpp"><em>nested-name-specifier</em></code>:</p>
 <div class="std">
 <blockquote>
@@ -5546,102 +5721,243 @@ <h3 class="unnumbered" id="expr.prim.id.qual-qualified-names"><span>7.5.5.3 <a h
 not have a
 <code class="sourceCode cpp"><em>computed-type-specifier</em></code>
 <span class="addu">or a
-<code class="sourceCode cpp"><em>splice-specifier</em></code></span>. A
-declaration that uses a declarative
+<code class="sourceCode cpp"><em>splice-scope-specifier</em></code></span>.
+A declaration that uses a declarative
 <code class="sourceCode cpp"><em>nested-name-specifier</em></code> shall
 be a friend declaration or inhabit a scope that contains the entity
 being redeclared or specialized.</p>
 </blockquote>
 </div>
-<p>Extend the next paragraph to also cover splices, and prefer the verb
-“designate” over “nominate”:</p>
+<p>Break the next paragraph into a bulleted list, extend it to also
+cover splices, and prefer the verb “designate” over “nominate”:</p>
 <div class="std">
 <blockquote>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_58" id="pnum_58">3</a></span>
+<span class="addu">The entity designated by a
+<code class="sourceCode cpp"><em>nested-name-specifier</em></code> is
+determined as follows:</span></p>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_59" id="pnum_59">(3.1)</a></span>
 The <code class="sourceCode cpp"><em>nested-name-specifier</em></code>
-<code class="sourceCode cpp"><span class="op">::</span></code> <span class="rm" style="color: #bf0303"><del>nominates</del></span> <span class="addu">designates</span> the global namespace. A
-<code class="sourceCode cpp"><em>nested-name-specifier</em></code> with
-a <code class="sourceCode cpp"><em>computed-type-specifier</em></code>
+<code class="sourceCode cpp"><span class="op">::</span></code> <span class="rm" style="color: #bf0303"><del>nominates</del></span> <span class="addu">designates</span> the global namespace.<span class="addu"> </span></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_60" id="pnum_60">(3.2)</a></span>
+A <code class="sourceCode cpp"><em>nested-name-specifier</em></code>
+with a
+<code class="sourceCode cpp"><em>computed-type-specifier</em></code>
 <span class="rm" style="color: #bf0303"><del>nominates</del></span>
-<span class="addu">designates</span> the type denoted by the
+<span class="addu">designates</span> the <span class="addu">same</span>
+type <span class="rm" style="color: #bf0303"><del>denoted</del></span>
+<span class="addu">designated</span> by the
 <code class="sourceCode cpp"><em>computed-type-specifier</em></code>,
-which shall be a class or enumeration type. <span class="addu">A
-<code class="sourceCode cpp"><em>nested-name-specifier</em></code> with
-a <code class="sourceCode cpp"><em>splice-specifier</em></code> that
-designates an entity itself designates the same entity. A
-<code class="sourceCode cpp"><em>nested-name-specifier</em></code> with
-a <code class="sourceCode cpp"><em>splice-specifier</em></code> that
-designates a name itself designates the entity nominated by that
-name.</span> If a
+which shall be a class or enumeration type.<span class="addu"> </span></li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_61" id="pnum_61">(3.3)</a></span>
+For a <code class="sourceCode cpp"><em>nested-name-specifier</em></code>
+of the form <code class="sourceCode cpp"><em>splice-specifier</em> <span class="op">::</span></code>,
+the <code class="sourceCode cpp"><em>splice-specifier</em></code> shall
+designate a class or enumeration type, a type alias denoting such a
+type, a namespace, or a namespace alias. If the
+<code class="sourceCode cpp"><em>splice-specifier</em></code> designates
+a type alias or a namespace alias, the
+<code class="sourceCode cpp"><em>nested-names-specifier</em></code>
+designates the type or namespace denoted by that entity. Otherwise, the
+<code class="sourceCode cpp"><em>nested-name-specifier</em></code>
+designates the same entity as the
+<code class="sourceCode cpp"><em>splice-specifier</em></code>.</span></li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_62" id="pnum_62">(3.4)</a></span>
+For a <code class="sourceCode cpp"><em>nested-name-specifier</em></code>
+of the form <code class="sourceCode cpp">template<sub><em>opt</em></sub> <em>splice-specialization-specifier</em> <span class="op">::</span></code>,
+the <code class="sourceCode cpp"><em>splice-specifier</em></code> of the
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+shall designate a primary class template or an alias template
+<code class="sourceCode cpp"><em>T</em></code>. Letting
+<code class="sourceCode cpp"><em>S</em></code> be the specialization of
+<code class="sourceCode cpp"><em>T</em></code> corresponding to the
+<code class="sourceCode cpp"><em>template-argument-list</em></code> (if
+any) of the
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>,
+<code class="sourceCode cpp"><em>S</em></code> shall either be a class
+template specialization or an alias template specialization that denotes
+a class or enumeration type. The
 <code class="sourceCode cpp"><em>nested-name-specifier</em></code>
+designates <code class="sourceCode cpp"><em>S</em></code> if
+<code class="sourceCode cpp"><em>T</em></code> is a class template or
+the type denoted by <code class="sourceCode cpp"><em>S</em></code> if
+<code class="sourceCode cpp"><em>T</em></code> is an alias
+template.</span></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_63" id="pnum_63">(3.5)</a></span>
+If a <code class="sourceCode cpp"><em>nested-name-specifier</em></code>
 <em>N</em> is declarative and has a
 <code class="sourceCode cpp"><em>simple-template-id</em></code> with a
 template argument list <em>A</em> that involves a template parameter,
 let <em>T</em> be the template <span class="rm" style="color: #bf0303"><del>nominated</del></span> <span class="addu">designated</span> by <em>N</em> without <em>A</em>.
-<em>T</em> shall be a class template.</p>
-<p>…</p>
+<em>T</em> shall be a class template.
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_64" id="pnum_64">(3.5.1)</a></span>
+If <code class="sourceCode cpp"><em>A</em></code> is the template
+argument list (<span>13.4 <a href="https://wg21.link/temp.arg">[temp.arg]</a></span>) of the
+corresponding <code class="sourceCode cpp"><em>template-head</em></code>
+<code class="sourceCode cpp"><em>H</em></code> (<span>13.7.3 <a href="https://wg21.link/temp.mem">[temp.mem]</a></span>),
+<code class="sourceCode cpp"><em>N</em></code> nominates the primary
+template of <code class="sourceCode cpp"><em>T</em></code>;
+<code class="sourceCode cpp"><em>H</em></code> shall be equivalent to
+the <code class="sourceCode cpp"><em>template-head</em></code> of
+<code class="sourceCode cpp"><em>T</em></code> (<span>13.7.7.2 <a href="https://wg21.link/temp.over.link">[temp.over.link]</a></span>).</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_65" id="pnum_65">(3.5.2)</a></span>
+Otherwise, <code class="sourceCode cpp"><em>N</em></code> nominates the
+partial specialization (<span>13.7.6 <a href="https://wg21.link/temp.spec.partial">[temp.spec.partial]</a></span>)
+of <code class="sourceCode cpp"><em>T</em></code> whose template
+argument list is equivalent to
+<code class="sourceCode cpp"><em>A</em></code> (<span>13.7.7.2 <a href="https://wg21.link/temp.over.link">[temp.over.link]</a></span>);
+the program is ill-formed if no such partial specialization exists.</li>
+</ul></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_66" id="pnum_66">(3.6)</a></span>
+Any other
+<code class="sourceCode cpp"><em>nested-name-specifier</em></code> <span class="rm" style="color: #bf0303"><del>nominates</del></span> <span class="addu">designates</span> the <span class="addu">same</span> entity
+<span class="rm" style="color: #bf0303"><del>denoted</del></span> <span class="addu">designated</span> by its
+<code class="sourceCode cpp"><em>type-name</em></code>,
+<code class="sourceCode cpp"><em>namespace-name</em></code>,
+<code class="sourceCode cpp"><em>identifier</em></code>, or
+<code class="sourceCode cpp"><em>simple-template-id</em></code>. If the
+<code class="sourceCode cpp"><em>nested-name-specifier</em></code> is
+not declarative, the entity shall not be a template.</li>
+</ul>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="expr.prim.splice-expression-splicing">7.5.8*
 [expr.prim.splice] Expression splicing<a href="#expr.prim.splice-expression-splicing" class="self-link"></a></h3>
 <p>Add a new subsection of <span>7.5 <a href="https://wg21.link/expr.prim">[expr.prim]</a></span> following
-<span>7.5.8 <a href="https://wg21.link/expr.prim.req">[expr.prim.req]</a></span></p>
+<span>7.5.7 <a href="https://wg21.link/expr.prim.req">[expr.prim.req]</a></span></p>
 <div class="std">
 <blockquote>
 <div class="addu">
 <p><strong>Expression Splicing [expr.prim.splice]</strong></p>
-<div class="sourceCode" id="cb108"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb108-1"><a href="#cb108-1" aria-hidden="true" tabindex="-1"></a><em>splice-expression</em>:</span>
-<span id="cb108-2"><a href="#cb108-2" aria-hidden="true" tabindex="-1"></a>   <em>splice-specifier</em></span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_59" id="pnum_59">1</a></span>
-The <code class="sourceCode cpp"><em>splice-specifier</em></code> shall
-designate either</p>
-<ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_60" id="pnum_60">(1.1)</a></span>
-a value or object,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_61" id="pnum_61">(1.2)</a></span>
-a variable,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_62" id="pnum_62">(1.3)</a></span>
-a structured binding,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_63" id="pnum_63">(1.4)</a></span>
-a function other than a constructor or destructor,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_64" id="pnum_64">(1.5)</a></span>
-an enumerator, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_65" id="pnum_65">(1.6)</a></span>
-a non-static data member.</li>
-</ul>
-<p><span class="note"><span>[ <em>Note 1:</em> </span>Unnamed bit-fields
-are not class members ([class.bit]), and cannot be spliced.<span>
-— <em>end note</em> ]</span></span></p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_66" id="pnum_66">2</a></span>
-Let <code class="sourceCode cpp"><em>E</em></code> be the construct
+<div class="sourceCode" id="cb110"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb110-1"><a href="#cb110-1" aria-hidden="true" tabindex="-1"></a><em>splice-expression</em>:</span>
+<span id="cb110-2"><a href="#cb110-2" aria-hidden="true" tabindex="-1"></a>   <em>splice-specifier</em></span>
+<span id="cb110-3"><a href="#cb110-3" aria-hidden="true" tabindex="-1"></a>   template <em>splice-specialization-specifier</em></span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_67" id="pnum_67">1</a></span>
+A <code class="sourceCode cpp"><em>splice-specifier</em></code> or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+immediately followed by
+<code class="sourceCode cpp"><span class="op">::</span></code> or
+preceded by
+<code class="sourceCode cpp"><span class="kw">typename</span></code> is
+never interpreted as part of a
+<code class="sourceCode cpp"><em>splice-expression</em></code>.</p>
+<div class="example">
+<span>[ <em>Example 1:</em> </span>
+<div class="sourceCode" id="cb111"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb111-1"><a href="#cb111-1" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> S <span class="op">{</span> <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> a <span class="op">=</span> <span class="dv">1</span>; <span class="op">}</span>;</span>
+<span id="cb111-2"><a href="#cb111-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span><span class="op">&gt;</span> <span class="kw">struct</span> TCls <span class="op">{</span> <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> b <span class="op">=</span> <span class="dv">2</span>; <span class="op">}</span>;</span>
+<span id="cb111-3"><a href="#cb111-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb111-4"><a href="#cb111-4" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> c <span class="op">=</span> <span class="op">[:^^</span>S<span class="op">:]::</span>a;                   <span class="co">// [:^^S:] is not an expression</span></span>
+<span id="cb111-5"><a href="#cb111-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb111-6"><a href="#cb111-6" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> d <span class="op">=</span> <span class="kw">template</span> <span class="op">[:^^</span>TCls<span class="op">:]&lt;</span><span class="dt">int</span><span class="op">&gt;::</span>b;  <span class="co">// template [:^^TCls:]&lt;int&gt; is not</span></span>
+<span id="cb111-7"><a href="#cb111-7" aria-hidden="true" tabindex="-1"></a>                                                <span class="co">// an expression</span></span>
+<span id="cb111-8"><a href="#cb111-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb111-9"><a href="#cb111-9" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span> V<span class="op">&gt;</span> <span class="kw">constexpr</span> <span class="dt">int</span> e <span class="op">=</span> <span class="op">[:</span>V<span class="op">:]</span>;   <span class="co">// splice-expression</span></span>
+<span id="cb111-10"><a href="#cb111-10" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> f <span class="op">=</span> <span class="kw">template</span> <span class="op">[:^^</span>e<span class="op">:]&lt;^^</span>S<span class="op">::</span>a<span class="op">&gt;</span>;  <span class="co">// splice-expression</span></span></code></pre></div>
+<span> — <em>end example</em> ]</span>
+</div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_68" id="pnum_68">2</a></span>
+For a <code class="sourceCode cpp"><em>splice-expression</em></code> of
+the form <code class="sourceCode cpp"><em>splice-specifier</em></code>,
+let <code class="sourceCode cpp"><em>S</em></code> be the construct
 designated by
 <code class="sourceCode cpp"><em>splice-specifier</em></code>.</p>
 <ul>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_67" id="pnum_67">(2.1)</a></span>
-If <code class="sourceCode cpp"><em>E</em></code> is an object, a
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_69" id="pnum_69">(2.1)</a></span>
+If <code class="sourceCode cpp"><em>S</em></code> is an object, a
 function, or a non-static data member, the expression is an lvalue
-designating <code class="sourceCode cpp"><em>E</em></code>. The
+designating <code class="sourceCode cpp"><em>S</em></code>. The
 expression has the same type as
-<code class="sourceCode cpp"><em>E</em></code>, and is a bit-field if
-and only if <code class="sourceCode cpp"><em>E</em></code> is a
+<code class="sourceCode cpp"><em>S</em></code>, and is a bit-field if
+and only if <code class="sourceCode cpp"><em>S</em></code> is a
 bit-field.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_68" id="pnum_68">(2.2)</a></span>
-Otherwise, if <code class="sourceCode cpp"><em>E</em></code> is a
-variable or a structured binding, the expression is an lvalue
-designating the object associated with
-<code class="sourceCode cpp"><em>E</em></code>. The expression has the
-same type as <code class="sourceCode cpp"><em>E</em></code>, and is a
-bit-field if and only if <code class="sourceCode cpp"><em>E</em></code>
-is a bit-field.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_69" id="pnum_69">(2.3)</a></span>
-Otherwise, <code class="sourceCode cpp"><em>E</em></code> shall be a
-value or an enumerator. The expression is a prvalue whose evaluation
-computes <code class="sourceCode cpp"><em>E</em></code> and whose type
-is the same as <code class="sourceCode cpp"><em>E</em></code>.</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_70" id="pnum_70">(2.2)</a></span>
+Otherwise, if <code class="sourceCode cpp"><em>S</em></code> is a
+variable or a structured binding,
+<code class="sourceCode cpp"><em>S</em></code> shall either have static
+or thread storage duration or shall inhabit a scope enclosing the
+expression. The expression is an lvalue referring to the object or
+function <code class="sourceCode cpp"><em>X</em></code> associated with
+or referenced by <code class="sourceCode cpp"><em>S</em></code>, has the
+same type as <code class="sourceCode cpp"><em>S</em></code>, and is a
+bit-field if and only if <code class="sourceCode cpp"><em>X</em></code>
+is a bit-field.</p>
+<p><span class="note"><span>[ <em>Note 1:</em> </span>The type of a
+<code class="sourceCode cpp"><em>splice-expression</em></code>
+designating a variable or structured binding of reference type will be
+adjusted to a non-reference type (<span>7.2.2 <a href="https://wg21.link/expr.type">[expr.type]</a></span>).<span>
+— <em>end note</em> ]</span></span></p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_71" id="pnum_71">(2.3)</a></span>
+Otherwise, if <code class="sourceCode cpp"><em>S</em></code> is a value
+or an enumerator, the expression is a prvalue that computes
+<code class="sourceCode cpp"><em>S</em></code> and whose type is the
+same as <code class="sourceCode cpp"><em>S</em></code>.</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_72" id="pnum_72">(2.4)</a></span>
+Otherwise, the expression is ill-formed.</p></li>
+</ul>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_73" id="pnum_73">3</a></span>
+For a <code class="sourceCode cpp"><em>splice-expression</em></code> of
+the form <code class="sourceCode cpp"><span class="kw">template</span> <em>splice-specialization-specifier</em></code>,
+the <code class="sourceCode cpp"><em>splice-specifier</em></code> of the
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+shall designate a template. Let
+<code class="sourceCode cpp"><em>T</em></code> be that template and let
+<code class="sourceCode cpp"><em>S</em></code> be the specialization of
+<code class="sourceCode cpp"><em>T</em></code> corresponding to the
+<code class="sourceCode cpp"><em>template-argument-list</em></code> (if
+any) of the
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>.</p>
+<ul>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_74" id="pnum_74">(3.1)</a></span>
+If <code class="sourceCode cpp"><em>T</em></code> is a primary variable
+template or function template, the expression is an lvalue referring to
+the same object or function associated with
+<code class="sourceCode cpp"><em>S</em></code>. The expression has the
+same type as <code class="sourceCode cpp"><em>S</em></code>.</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_75" id="pnum_75">(3.2)</a></span>
+Otherwise, if <code class="sourceCode cpp"><em>T</em></code> is a
+concept, the expression is a prvalue that computes the same boolean
+value as the <code class="sourceCode cpp"><em>concept-id</em></code>
+formed by <code class="sourceCode cpp"><em>S</em></code>.</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_76" id="pnum_76">(3.3)</a></span>
+Otherwise, the expression is ill-formed.</p></li>
 </ul>
 <p><span class="note"><span>[ <em>Note 2:</em> </span>Access checking of
 class members occurs during lookup, and therefore does not pertain to
 splicing.<span> — <em>end note</em> ]</span></span></p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_77" id="pnum_77">4</a></span>
+A <code class="sourceCode cpp"><em>splice-expression</em></code> that
+designates a non-static data member or implicit object member function
+of a class can only be used:</p>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_78" id="pnum_78">(4.1)</a></span>
+as part of a class member access in which the object expression refers
+to the member’s class or a class derived from that class,</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_79" id="pnum_79">(4.2)</a></span>
+to form a pointer to member (<span>7.6.2.2 <a href="https://wg21.link/expr.unary.op">[expr.unary.op]</a></span>),
+or</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_80" id="pnum_80">(4.3)</a></span>
+if that <code class="sourceCode cpp"><em>splice-expression</em></code>
+denotes a non-static data member and it appears in an unevaluated
+operand.</li>
+</ul>
+<p><span class="note"><span>[ <em>Note 3:</em> </span>The implicit
+transformation (<span>7.5.4 <a href="https://wg21.link/expr.prim.id">[expr.prim.id]</a></span>) whereby
+an <code class="sourceCode cpp"><em>id-expression</em></code> denoting a
+non-static member becomes a class member access does not apply to a
+<code class="sourceCode cpp"><em>splice-expression</em></code>.<span>
+— <em>end note</em> ]</span></span></p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_81" id="pnum_81">5</a></span>
+For a <code class="sourceCode cpp"><em>splice-expression</em></code>
+that designates a function or function template, overload resolution is
+performed (<span>12.2 <a href="https://wg21.link/over.match">[over.match]</a></span>,
+<span>13.10.4 <a href="https://wg21.link/temp.over">[temp.over]</a></span>) from an
+initial set of candidate functions containing only that entity
+designated by the
+<code class="sourceCode cpp"><em>splice-expression</em></code>. The best
+viable function selected by overload resolution is considered to be
+designated in a manner exempt from access rules.</p>
 </div>
 </blockquote>
 </div>
@@ -5653,15 +5969,13 @@ <h3 class="unnumbered" id="expr.post.general-general"><span>7.6.1.1 <a href="htt
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb109"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb109-1"><a href="#cb109-1" aria-hidden="true" tabindex="-1"></a>[1]{.pnum} Postfix expressions group left-to-right.</span>
-<span id="cb109-2"><a href="#cb109-2" aria-hidden="true" tabindex="-1"></a>  <em>postfix-expression</em>:</span>
-<span id="cb109-3"><a href="#cb109-3" aria-hidden="true" tabindex="-1"></a>    ...</span>
-<span id="cb109-4"><a href="#cb109-4" aria-hidden="true" tabindex="-1"></a>    <em>postfix-expression</em> . <em>template</em><sub><em>opt</em></sub> <em>id-expression</em></span>
-<span id="cb109-5"><a href="#cb109-5" aria-hidden="true" tabindex="-1"></a><span class="va">+   <em>postfix-expression</em> . <em>splice-expression</em></span></span>
-<span id="cb109-6"><a href="#cb109-6" aria-hidden="true" tabindex="-1"></a><span class="va">+   <em>postfix-expression</em> . <em>splice-expr-template-specifier</em></span></span>
-<span id="cb109-7"><a href="#cb109-7" aria-hidden="true" tabindex="-1"></a>    <em>postfix-expression</em> -&gt; <em>template</em><sub><em>opt</em></sub> <em>id-expression</em></span>
-<span id="cb109-8"><a href="#cb109-8" aria-hidden="true" tabindex="-1"></a><span class="va">+   <em>postfix-expression</em> -&gt; <em>splice-expression</em></span></span>
-<span id="cb109-9"><a href="#cb109-9" aria-hidden="true" tabindex="-1"></a><span class="va">+   <em>postfix-expression</em> -&gt; <em>splice-expr-template-specifier</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb112"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb112-1"><a href="#cb112-1" aria-hidden="true" tabindex="-1"></a>[1]{.pnum} Postfix expressions group left-to-right.</span>
+<span id="cb112-2"><a href="#cb112-2" aria-hidden="true" tabindex="-1"></a>  <em>postfix-expression</em>:</span>
+<span id="cb112-3"><a href="#cb112-3" aria-hidden="true" tabindex="-1"></a>    ...</span>
+<span id="cb112-4"><a href="#cb112-4" aria-hidden="true" tabindex="-1"></a>    <em>postfix-expression</em> . <em>template</em><sub><em>opt</em></sub> <em>id-expression</em></span>
+<span id="cb112-5"><a href="#cb112-5" aria-hidden="true" tabindex="-1"></a><span class="va">+   <em>postfix-expression</em> . <em>splice-expression</em></span></span>
+<span id="cb112-6"><a href="#cb112-6" aria-hidden="true" tabindex="-1"></a>    <em>postfix-expression</em> -&gt; <em>template</em><sub><em>opt</em></sub> <em>id-expression</em></span>
+<span id="cb112-7"><a href="#cb112-7" aria-hidden="true" tabindex="-1"></a><span class="va">+   <em>postfix-expression</em> -&gt; <em>splice-expression</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -5669,21 +5983,19 @@ <h3 class="unnumbered" id="expr.ref-class-member-access"><span>7.6.1.5
 <a href="https://wg21.link/expr.ref">[expr.ref]</a></span> Class member
 access<a href="#expr.ref-class-member-access" class="self-link"></a></h3>
 <p>Modify paragraph 1 to account for splices in member access
-expressions. Prefer the word “possibly” to “optionally” since
-<code class="sourceCode cpp"><span class="kw">template</span></code>
-cannot precede a <code class="sourceCode cpp">splice<span class="op">-</span>expression</code>:</p>
+expressions:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_70" id="pnum_70">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_82" id="pnum_82">1</a></span>
 A postfix expression followed by a dot
 <code class="sourceCode cpp"><span class="op">.</span></code> or an
 arrow <code class="sourceCode cpp"><span class="op">-&gt;</span></code>,
-<span class="rm" style="color: #bf0303"><del>optionally</del></span>
-<span class="addu">possibly</span> followed by the keyword
+optionally followed by the keyword
 <code class="sourceCode cpp"><span class="kw">template</span></code>,
 and then followed by an
-<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or a splicer designating a class member</span>, is a
-postfix expression.</p>
+<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or a
+<code class="sourceCode cpp"><em>splice-expression</em></code></span>,
+is a postfix expression.</p>
 <p><span class="note"><span>[ <em>Note 1:</em> </span>If the keyword
 <code class="sourceCode cpp"><span class="kw">template</span></code> is
 used, the following unqualified name is considered to refer to a
@@ -5700,57 +6012,61 @@ <h3 class="unnumbered" id="expr.ref-class-member-access"><span>7.6.1.5
 expressions:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_71" id="pnum_71">2</a></span>
-<span class="rm" style="color: #bf0303"><del>For the first
-option,</del></span> <span class="rm" style="color: #bf0303"><del>if</del></span><span class="addu">If</span>
-the <span class="addu">dot is followed by an</span>
-<code class="sourceCode cpp"><em>id-expression</em></code> <span class="rm" style="color: #bf0303"><del>names</del></span> <span class="addu">or splicer designating</span> a static member or an
-enumerator, the first expression is a discarded-value expression
-([expr.context]); if the
-<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or splicer designates</span> <span class="rm" style="color: #bf0303"><del>names</del></span> a non-static data member,
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_83" id="pnum_83">2</a></span>
+For <span class="rm" style="color: #bf0303"><del>the first option, if
+the</del></span> <span class="addu">a dot that is followed by an</span>
+<code class="sourceCode cpp"><em>id-expression</em></code> <span class="rm" style="color: #bf0303"><del>names</del></span> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-expression</em></code> that
+designates</span> a static member or an enumerator, the first expression
+is a discarded-value expression (<span>7.2.3 <a href="https://wg21.link/expr.context">[expr.context]</a></span>); if the
+<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-expression</em></code>
+designates</span> <span class="rm" style="color: #bf0303"><del>names</del></span> a non-static data member,
 the first expression shall be a glvalue. <span class="rm" style="color: #bf0303"><del>For the second option (arrow), the first
-expression</del></span> <span class="addu">A postfix expression followed
-by an arrow</span> shall be a prvalue having pointer type. The
+expression</del></span> <span class="addu">A postfix expression that is
+followed by an arrow</span> shall be a prvalue having pointer type. The
 expression
 <code class="sourceCode cpp">E1<span class="op">-&gt;</span>E2</code> is
 converted to the equivalent form <code class="sourceCode cpp"><span class="op">(*(</span>E1<span class="op">)).</span>E2</code>;
-the remainder of [expr.ref] will address only <span class="rm" style="color: #bf0303"><del>the first option (dot)</del></span> <span class="addu">expressions containing a dot</span>.</p>
+the remainder of [expr.ref] will address only <span class="rm" style="color: #bf0303"><del>the first option (dot)</del></span> <span class="addu">the form using a dot</span>.</p>
 </blockquote>
 </div>
 <p>Modify paragraph 3 to account for splices in member access
 expressions:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_72" id="pnum_72">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_84" id="pnum_84">3</a></span>
 The postfix expression before the dot is evaluated; the result of that
 evaluation, together with the
-<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or splicer</span>, determines the result of the entire
-postfix expression.</p>
+<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-expression</em></code></span>,
+determines the result of the entire postfix expression.</p>
 </blockquote>
 </div>
 <p>Modify paragraph 4 to account for splices in member access
 expressions:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_73" id="pnum_73">4</a></span>
-Abbreviating <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default"><em>postfix-expression</em></code></span>.<span><code class="sourceCode default"><em>id-expression</em></code></span></del></span>
-<span class="addu"><code class="sourceCode cpp"><em>postfix-expression</em><span class="op">.</span>EXPR</code>,
-where <code class="sourceCode cpp">EXPR</code> is the
-<code class="sourceCode cpp"><em>id-expression</em></code> or splicer
-following the dot,</span> as
-<code class="sourceCode cpp">E1<span class="op">.</span>E2</code>,
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_85" id="pnum_85">4</a></span>
+Abbreviating
+<code class="sourceCode cpp"><em>postfix-expression</em></code>.<code class="sourceCode cpp"><em>id-expression</em></code>
+<span class="addu">or <code class="sourceCode cpp"><em>postfix-expression</em><span class="op">.</span><em>splice-expression</em></code></span>
+as <code class="sourceCode cpp">E1<span class="op">.</span>E2</code>,
 <code class="sourceCode cpp">E1</code> is called the
 <code class="sourceCode cpp"><em>object expression</em></code>. […]</p>
 </blockquote>
 </div>
-<p>Adjust the language in paragraphs 6-9 to account for splicers.</p>
+<p>Adjust the language in paragraphs 6-9 to account for
+<code class="sourceCode cpp"><em>splice-expression</em></code>s.
+Explicitly add a fallback to paragraph 7 that makes other cases
+ill-formed.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_74" id="pnum_74">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_86" id="pnum_86">6</a></span>
 If <code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a bit-field,
 <code class="sourceCode cpp">E1<span class="op">.</span>E2</code> is a
 bit-field. […]</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_75" id="pnum_75">7</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_87" id="pnum_87">7</a></span>
 If <span class="addu">the entity designated by</span>
 <code class="sourceCode cpp">E2</code> is declared to have type
 “reference to <code class="sourceCode cpp">T</code>”, then
@@ -5765,14 +6081,15 @@ <h3 class="unnumbered" id="expr.ref-class-member-access"><span>7.6.1.5
 member of <code class="sourceCode cpp">E1</code> is bound. Otherwise,
 one of the following rules applies.</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_76" id="pnum_76">(7.1)</a></span>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_88" id="pnum_88">(7.1)</a></span>
 If <code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a static data member and the type of
 <code class="sourceCode cpp">E2</code> is
 <code class="sourceCode cpp">T</code>, then
 <code class="sourceCode cpp">E1<span class="op">.</span>E2</code> is an
-lvalue; […]</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_77" id="pnum_77">(7.2)</a></span>
-If <code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a non-static data member and the type of
+lvalue; […]</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_89" id="pnum_89">(7.2)</a></span>
+<span class="addu">Otherwise, if</span> <span class="rm" style="color: #bf0303"><del>If</del></span>
+<code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a non-static data member and the type of
 <code class="sourceCode cpp">E1</code> is “<em>cq1</em> <em>vq1</em>
 <code class="sourceCode cpp">X</code>”, and the type of
 <code class="sourceCode cpp">E2</code> is “<em>cq2 vq2</em>
@@ -5788,30 +6105,35 @@ <h3 class="unnumbered" id="expr.ref-class-member-access"><span>7.6.1.5
 member, then the type of
 <code class="sourceCode cpp">E1<span class="op">.</span>E2</code> is
 “<em>cq12</em> <em>vq12</em>
-<code class="sourceCode cpp">T</code>”.</li>
-</ul>
-<p>[…]</p>
-<ul>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_78" id="pnum_78">(7.4)</a></span>
-If <code class="sourceCode cpp">E</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a nested type, the expression
+<code class="sourceCode cpp">T</code>”.</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_90" id="pnum_90">(7.3)</a></span>
+<span class="addu">Otherwise, if</span> <span class="rm" style="color: #bf0303"><del>If</del></span>
+<code class="sourceCode cpp">E2</code> is an overload set, […]</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_91" id="pnum_91">(7.4)</a></span>
+<span class="addu">Otherwise, if</span> <span class="rm" style="color: #bf0303"><del>If</del></span>
+<code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a nested type, the expression
 <code class="sourceCode cpp">E1<span class="op">.</span>E2</code> is
 ill-formed.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_79" id="pnum_79">(7.5)</a></span>
-If <code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a member enumerator and the type of
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_92" id="pnum_92">(7.5)</a></span>
+<span class="addu">Otherwise, if</span> <span class="rm" style="color: #bf0303"><del>If</del></span>
+<code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a member enumerator and the type of
 <code class="sourceCode cpp">E2</code> is
 <code class="sourceCode cpp">T</code>, the expression
 <code class="sourceCode cpp">E1<span class="op">.</span>E2</code> is a
 prvalue of type <code class="sourceCode cpp">T</code> whose value is the
 value of the enumerator.</p></li>
+<li><p><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_93" id="pnum_93">(7.6)</a></span>
+Otherwise, the program is ill-formed.</span></p></li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_80" id="pnum_80">8</a></span>
-If <code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> <span class="addu">designates</span> a non-static member <span class="addu"><code class="sourceCode cpp"><em>M</em></code></span>, the
-program is ill-formed if the class of which <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default">E2</code></span></del></span>
-<span class="addu"><code class="sourceCode cpp"><em>M</em></code></span>
-is directly a member is an ambiguous base ([class.member.lookup]) of the
-naming class ([class.access.base]) of <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default">E2</code></span></del></span>
-<span class="addu"><code class="sourceCode cpp"><em>M</em></code></span>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_81" id="pnum_81">9</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_94" id="pnum_94">8</a></span>
+If <code class="sourceCode cpp">E2</code> is <span class="addu">an
+<code class="sourceCode cpp"><em>id-expression</em></code>
+denoting</span> a non-static member, the program is ill-formed if the
+class of which <code class="sourceCode cpp">E2</code> <span class="rm" style="color: #bf0303"><del>is</del></span> directly <span class="addu">denotes</span> a member is an ambiguous base (<span>6.5.2
+<a href="https://wg21.link/class.member.lookup">[class.member.lookup]</a></span>)
+of the naming class (<span>11.8.3 <a href="https://wg21.link/class.access.base">[class.access.base]</a></span>)
+of <code class="sourceCode cpp">E2</code>.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_95" id="pnum_95">9</a></span>
 If <span class="addu">the entity designated by</span>
 <code class="sourceCode cpp">E2</code> is a non-static member and the
 result of <code class="sourceCode cpp">E1</code> is an object whose type
@@ -5821,17 +6143,19 @@ <h3 class="unnumbered" id="expr.ref-class-member-access"><span>7.6.1.5
 </div>
 <h3 class="unnumbered" id="expr.unary.general-general"><span>7.6.2.1 <a href="https://wg21.link/expr.unary.general">[expr.unary.general]</a></span>
 General<a href="#expr.unary.general-general" class="self-link"></a></h3>
-<p>Change <span>7.6.2.1 <a href="https://wg21.link/expr.unary.general">[expr.unary.general]</a></span>
-paragraph 1 to add productions for the new operator:</p>
+<p>Add <code class="sourceCode cpp"><em>reflect-expression</em></code>
+to the grammar for
+<code class="sourceCode cpp"><em>unary-expression</em></code> in
+paragraph 1:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_82" id="pnum_82">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_96" id="pnum_96">1</a></span>
 Expressions with unary operators group right-to-left.</p>
 <div>
-<div class="sourceCode" id="cb110"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb110-1"><a href="#cb110-1" aria-hidden="true" tabindex="-1"></a>  <em>unary-expression</em>:</span>
-<span id="cb110-2"><a href="#cb110-2" aria-hidden="true" tabindex="-1"></a>     ...</span>
-<span id="cb110-3"><a href="#cb110-3" aria-hidden="true" tabindex="-1"></a>     <em>delete-expression</em></span>
-<span id="cb110-4"><a href="#cb110-4" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>reflect-expression</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb113"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb113-1"><a href="#cb113-1" aria-hidden="true" tabindex="-1"></a>  <em>unary-expression</em>:</span>
+<span id="cb113-2"><a href="#cb113-2" aria-hidden="true" tabindex="-1"></a>     ...</span>
+<span id="cb113-3"><a href="#cb113-3" aria-hidden="true" tabindex="-1"></a>     <em>delete-expression</em></span>
+<span id="cb113-4"><a href="#cb113-4" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>reflect-expression</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -5842,13 +6166,13 @@ <h3 class="unnumbered" id="expr.unary.op-unary-operators"><span>7.6.2.2
 a splice.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_83" id="pnum_83">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_97" id="pnum_97">3</a></span>
 The operand of the unary
 <code class="sourceCode cpp"><span class="op">&amp;</span></code>
 operator shall be an lvalue of some type
 <code class="sourceCode cpp">T</code>.</p>
 <ul>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_84" id="pnum_84">(3.1)</a></span>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_98" id="pnum_98">(3.1)</a></span>
 If the operand is a
 <code class="sourceCode cpp"><em>qualified-id</em></code> <span class="addu">or
 <code class="sourceCode cpp"><em>splice-expression</em></code></span>
@@ -5858,7 +6182,7 @@ <h3 class="unnumbered" id="expr.unary.op-unary-operators"><span>7.6.2.2
 <code class="sourceCode cpp">C</code> of type
 <code class="sourceCode cpp">T</code>” and designates
 <code class="sourceCode cpp">C<span class="op">::</span>m</code>.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_85" id="pnum_85">(3.2)</a></span>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_99" id="pnum_99">(3.2)</a></span>
 Otherwise, the result has type “pointer to
 <code class="sourceCode cpp">T</code>” and points to the designated
 object (<span>6.7.1 <a href="https://wg21.link/intro.memory">[intro.memory]</a></span>) or
@@ -5869,7 +6193,7 @@ <h3 class="unnumbered" id="expr.unary.op-unary-operators"><span>7.6.2.2
 <span class="addu">or a
 <code class="sourceCode cpp"><em>splice-expression</em></code></span>.</p></li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_86" id="pnum_86">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_100" id="pnum_100">4</a></span>
 A pointer to member is only formed when an explicit
 <code class="sourceCode cpp"><span class="op">&amp;</span></code> is
 used and its operand is a
@@ -5886,126 +6210,138 @@ <h3 class="unnumbered" id="expr.reflect-the-reflection-operator">7.6.2.10* [expr
 <blockquote>
 <div class="addu">
 <p><strong>The reflection operator [expr.reflect]</strong></p>
-<p><span class="ednote" style="color: #0000ff">[ Editor&#39;s note: The
-following grammar avoids use of
-<code class="sourceCode default"><em>id-expression</em></code>, even
-though any operand to an
-<code class="sourceCode default"><em>id-expression</em></code> can be an
-operand to a
-<code class="sourceCode default"><em>reflect-expression</em></code>. The
-reason is that the operand of a
-<code class="sourceCode default"><em>reflect-expression</em></code> is
-not necessarily an expression, as it could name a namespace, class
-template, type, etc. ]</span></p>
-<div class="sourceCode" id="cb111"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb111-1"><a href="#cb111-1" aria-hidden="true" tabindex="-1"></a><em>reflect-expression</em>:</span>
-<span id="cb111-2"><a href="#cb111-2" aria-hidden="true" tabindex="-1"></a>   ^^ ::</span>
-<span id="cb111-3"><a href="#cb111-3" aria-hidden="true" tabindex="-1"></a>   ^^ <em>unqualified-id</em></span>
-<span id="cb111-4"><a href="#cb111-4" aria-hidden="true" tabindex="-1"></a>   ^^ <em>qualified-id</em></span>
-<span id="cb111-5"><a href="#cb111-5" aria-hidden="true" tabindex="-1"></a>   ^^ <em>type-id</em></span>
-<span id="cb111-6"><a href="#cb111-6" aria-hidden="true" tabindex="-1"></a>   ^^ <em>pack-index-expression</em></span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_87" id="pnum_87">1</a></span>
+<div class="sourceCode" id="cb114"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb114-1"><a href="#cb114-1" aria-hidden="true" tabindex="-1"></a><em>reflect-expression</em>:</span>
+<span id="cb114-2"><a href="#cb114-2" aria-hidden="true" tabindex="-1"></a>   ^^ ::</span>
+<span id="cb114-3"><a href="#cb114-3" aria-hidden="true" tabindex="-1"></a>   ^^ <em>qualified-namespace-specifier</em></span>
+<span id="cb114-4"><a href="#cb114-4" aria-hidden="true" tabindex="-1"></a>   ^^ <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>template-name</em></span>
+<span id="cb114-5"><a href="#cb114-5" aria-hidden="true" tabindex="-1"></a>   ^^ <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>concept-name</em></span>
+<span id="cb114-6"><a href="#cb114-6" aria-hidden="true" tabindex="-1"></a>   ^^ <em>type-id</em></span>
+<span id="cb114-7"><a href="#cb114-7" aria-hidden="true" tabindex="-1"></a>   ^^ <em>id-expression</em></span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_101" id="pnum_101">1</a></span>
 The unary <code class="sourceCode cpp"><span class="op">^^</span></code>
 operator, called the <em>reflection operator</em>, yields a prvalue of
 type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>
 (<span>6.8.2 <a href="https://wg21.link/basic.fundamental">[basic.fundamental]</a></span>).</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_88" id="pnum_88">2</a></span>
+<p><span class="note"><span>[ <em>Note 1:</em> </span>Constructs not
+described by this document can also be represented by reflections, and
+can appear as operands of
+<code class="sourceCode cpp"><em>reflect-expression</em></code>s.<span>
+— <em>end note</em> ]</span></span></p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_102" id="pnum_102">2</a></span>
 A <code class="sourceCode cpp"><em>reflect-expression</em></code> is
 parsed as the longest possible sequence of tokens that could
 syntactically form a
 <code class="sourceCode cpp"><em>reflect-expression</em></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_89" id="pnum_89">3</a></span></p>
 <div class="example">
 <span>[ <em>Example 1:</em> </span>
-<div class="sourceCode" id="cb112"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb112-1"><a href="#cb112-1" aria-hidden="true" tabindex="-1"></a>static_assert(is_type(^^int()));    // ^^ applies to the type-id &quot;int()&quot;</span>
-<span id="cb112-2"><a href="#cb112-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-3"><a href="#cb112-3" aria-hidden="true" tabindex="-1"></a>template&lt;bool&gt; struct X {};</span>
-<span id="cb112-4"><a href="#cb112-4" aria-hidden="true" tabindex="-1"></a>bool operator&lt;(std::meta::info, X&lt;false&gt;);</span>
-<span id="cb112-5"><a href="#cb112-5" aria-hidden="true" tabindex="-1"></a>consteval void g(std::meta::info r, X&lt;false&gt; xv) {</span>
-<span id="cb112-6"><a href="#cb112-6" aria-hidden="true" tabindex="-1"></a>  r == ^^int &amp;&amp; true;    // error: ^^ applies to the type-id &quot;int&amp;&amp;&quot;</span>
-<span id="cb112-7"><a href="#cb112-7" aria-hidden="true" tabindex="-1"></a>  r == ^^int &amp; true;     // error: ^^ applies to the type-id &quot;int&amp;&quot;</span>
-<span id="cb112-8"><a href="#cb112-8" aria-hidden="true" tabindex="-1"></a>  r == (^^int) &amp;&amp; true;  // OK</span>
-<span id="cb112-9"><a href="#cb112-9" aria-hidden="true" tabindex="-1"></a>  r == ^^int &amp;&amp;&amp;&amp; true;  // OK</span>
-<span id="cb112-10"><a href="#cb112-10" aria-hidden="true" tabindex="-1"></a>  ^^X &lt; xv;              // error: &lt; starts template argument list</span>
-<span id="cb112-11"><a href="#cb112-11" aria-hidden="true" tabindex="-1"></a>  (^^X) &lt; xv;            // OK</span>
-<span id="cb112-12"><a href="#cb112-12" aria-hidden="true" tabindex="-1"></a>}</span>
-<span id="cb112-13"><a href="#cb112-13" aria-hidden="true" tabindex="-1"></a></span></code></pre></div>
+<div class="sourceCode" id="cb115"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb115-1"><a href="#cb115-1" aria-hidden="true" tabindex="-1"></a>static_assert(std::meta::is_type(^^int()));  // ^^ applies to the type-id &quot;int()&quot;</span>
+<span id="cb115-2"><a href="#cb115-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb115-3"><a href="#cb115-3" aria-hidden="true" tabindex="-1"></a>template&lt;bool&gt; struct X {};</span>
+<span id="cb115-4"><a href="#cb115-4" aria-hidden="true" tabindex="-1"></a>bool operator&lt;(std::meta::info, X&lt;false&gt;);</span>
+<span id="cb115-5"><a href="#cb115-5" aria-hidden="true" tabindex="-1"></a>consteval void g(std::meta::info r, X&lt;false&gt; xv) {</span>
+<span id="cb115-6"><a href="#cb115-6" aria-hidden="true" tabindex="-1"></a>  r == ^^int &amp;&amp; true;    // error: ^^ applies to the type-id &quot;int&amp;&amp;&quot;</span>
+<span id="cb115-7"><a href="#cb115-7" aria-hidden="true" tabindex="-1"></a>  r == ^^int &amp; true;     // error: ^^ applies to the type-id &quot;int&amp;&quot;</span>
+<span id="cb115-8"><a href="#cb115-8" aria-hidden="true" tabindex="-1"></a>  r == (^^int) &amp;&amp; true;  // OK</span>
+<span id="cb115-9"><a href="#cb115-9" aria-hidden="true" tabindex="-1"></a>  r == ^^int &amp;&amp;&amp;&amp; true;  // error: &#39;int &amp;&amp;&amp;&amp;&#39; is not a valid type</span>
+<span id="cb115-10"><a href="#cb115-10" aria-hidden="true" tabindex="-1"></a>  ^^X &lt; xv;              // OK</span>
+<span id="cb115-11"><a href="#cb115-11" aria-hidden="true" tabindex="-1"></a>  (^^X) &lt; xv;            // OK</span>
+<span id="cb115-12"><a href="#cb115-12" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_90" id="pnum_90">4</a></span>
-A <code class="sourceCode cpp"><em>reflect-expression</em></code> having
-the form <code class="sourceCode cpp"><span class="op">^^</span> <span class="op">::</span></code>
-computes a reflection of the global namespace.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_91" id="pnum_91">5</a></span>
-A <code class="sourceCode cpp"><em>reflect-expression</em></code> having
-the form <code class="sourceCode cpp"><span class="op">^^</span> <em>unqualified-id</em></code>
-or <code class="sourceCode cpp"><span class="op">^^</span> <em>qualified-id</em></code>
-performs name lookup for the operand following
-<code class="sourceCode cpp"><span class="op">^^</span></code> and
-computes a result as follows:</p>
-<ul>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_92" id="pnum_92">(5.1)</a></span>
-If the lookup finds an overload set
-<code class="sourceCode cpp"><em>S</em></code> such that the
-initialization of an invented variable of type <code class="sourceCode cpp"><span class="kw">const</span> <span class="kw">auto</span></code>
-(<span>9.2.9.7.2 <a href="https://wg21.link/dcl.type.auto.deduct">[dcl.type.auto.deduct]</a></span>)
-with
-<code class="sourceCode cpp"><span class="op">&amp;</span><em>S</em></code>
-would select a unique candidate function
-<code class="sourceCode cpp"><em>F</em></code> from
-<code class="sourceCode cpp"><em>S</em></code>, then the result is a
-reflection of <code class="sourceCode cpp"><em>F</em></code>. If the
-lookup finds any other overload set, the program is ill-formed.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_93" id="pnum_93">(5.2)</a></span>
-Otherwise, if the lookup finds a
-<code class="sourceCode cpp"><em>typedef-name</em></code> or a
-<code class="sourceCode cpp"><em>namespace-alias</em></code>, then the
-result is a reflection of the indicated name.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_94" id="pnum_94">(5.3)</a></span>
-Otherwise, if the lookup finds a non-type template parameter, then the
-result is a reflection of the result computed by an
-<code class="sourceCode cpp"><em>id-expression</em></code> naming the
-parameter.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_95" id="pnum_95">(5.4)</a></span>
-Otherwise, if the lookup finds a variable, structured binding, function,
-enumerator, type, non-static member, template, or namespace, then the
-result is a reflection of the denoted entity.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_96" id="pnum_96">(5.5)</a></span>
-Otherwise, if the lookup finds an implementation-defined construct not
-otherwise specified by this document, then the implementation may
-compute a reflection of the denoted construct.</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_97" id="pnum_97">(5.6)</a></span>
-Otherwise, the program is ill-formed.</p></li>
-</ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_98" id="pnum_98">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_103" id="pnum_103">3</a></span>
+A <code class="sourceCode cpp"><em>reflect-expression</em></code> that
+could be validly interpreted as <code class="sourceCode cpp"><span class="op">^^</span> <em>template-name</em></code>
+is never interpreted as <code class="sourceCode cpp"><span class="op">^^</span> <em>id-expression</em></code>,
+and is interpreted as
+<code class="sourceCode cpp"><span class="op">^^</span> <em>type-id</em></code>
+if and only if the operand refers to the current instantiation
+([temp.dep.type]).</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_104" id="pnum_104">4</a></span>
+A <code class="sourceCode cpp"><em>reflect-expression</em></code> of the
+form <code class="sourceCode cpp"><span class="op">^^</span> <span class="op">::</span></code>
+represents the global namespace. A
+<code class="sourceCode cpp"><em>reflect-expression</em></code> of the
+form <code class="sourceCode cpp"><span class="op">^^</span> <em>qualified-namespace-specifier</em></code>
+represents the denoted namespace or namespace alias.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_105" id="pnum_105">5</a></span>
+A <code class="sourceCode cpp"><em>reflect-expression</em></code> of the
+form <code class="sourceCode cpp"><span class="op">^^</span> <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>template-name</em></code>
+represents the primary class template, function template, primary
+variable template, or alias template denoted by
+<code class="sourceCode cpp"><em>template-name</em></code>.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_106" id="pnum_106">6</a></span>
+A <code class="sourceCode cpp"><em>reflect-expression</em></code> of the
+form <code class="sourceCode cpp"><span class="op">^^</span> <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>concept-name</em></code>
+represents the concept denoted by
+<code class="sourceCode cpp"><em>concept-name</em></code>.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_107" id="pnum_107">7</a></span>
 A <code class="sourceCode cpp"><em>reflect-expression</em></code> of the
 form
 <code class="sourceCode cpp"><span class="op">^^</span> <em>type-id</em></code>
-computes a reflection of the denoted type. A
-<code class="sourceCode cpp"><em>reflect-expression</em></code> that
-could be validly interpreted as either <code class="sourceCode cpp"><span class="op">^^</span> <em>unqualified-id</em></code>
-or
-<code class="sourceCode cpp"><span class="op">^^</span> <em>type-id</em></code>
-is interpreted as <code class="sourceCode cpp"><span class="op">^^</span> <em>unqualified-id</em></code>,
-and a <code class="sourceCode cpp"><em>reflect-expression</em></code>
-that could be validly interpreted as <code class="sourceCode cpp"><span class="op">^^</span> <em>qualified-id</em></code>
-or
-<code class="sourceCode cpp"><span class="op">^^</span> <em>type-id</em></code>
-is interpreted as <code class="sourceCode cpp"><span class="op">^^</span> <em>qualified-id</em></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_99" id="pnum_99">7</a></span>
-A <code class="sourceCode cpp"><em>reflect-expression</em></code> having
-the form <code class="sourceCode cpp"><span class="op">^^</span> <em>pack-index-expression</em></code>
-computes a reflection of the result computed by the
-<code class="sourceCode cpp"><em>pack-index-expression</em></code>.</p>
+is interpreted as follows:</p>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_108" id="pnum_108">(7.1)</a></span>
+If <code class="sourceCode cpp"><em>type-id</em></code> denotes a type
+alias that was introduced by the declaration of a type template
+parameter, the
+<code class="sourceCode cpp"><em>reflect-expression</em></code>
+represents the type denoted by that type alias.</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_109" id="pnum_109">(7.2)</a></span>
+Otherwise, the
+<code class="sourceCode cpp"><em>reflect-expression</em></code>
+represents the type or type alias denoted by
+<code class="sourceCode cpp"><em>type-id</em></code>.</li>
+</ul>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_110" id="pnum_110">8</a></span>
+A <code class="sourceCode cpp"><em>reflect-expression</em></code> of the
+form <code class="sourceCode cpp"><span class="op">^^</span> <em>id-expression</em></code>
+is interpreted as follows:</p>
+<ul>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_111" id="pnum_111">(8.1)</a></span>
+If <code class="sourceCode cpp"><em>id-expression</em></code> denotes an
+overload set <code class="sourceCode cpp"><em>S</em></code> and overload
+resolution for the expression
+<code class="sourceCode cpp"><span class="op">&amp;</span><em>S</em></code>
+determines a unique function
+<code class="sourceCode cpp"><em>F</em></code> (<span>12.3 <a href="https://wg21.link/over.over">[over.over]</a></span>), the
+<code class="sourceCode cpp"><em>reflect-expression</em></code>
+represents <code class="sourceCode cpp"><em>F</em></code>.</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_112" id="pnum_112">(8.2)</a></span>
+Otherwise, if <code class="sourceCode cpp"><em>id-expression</em></code>
+denotes a variable, structured binding, enumerator, or non-static data
+member or member function, the
+<code class="sourceCode cpp"><em>reflect-expression</em></code>
+represents that entity.</p></li>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_113" id="pnum_113">(8.3)</a></span>
+Otherwise, the
+<code class="sourceCode cpp"><em>reflect-expression</em></code> is
+ill-formed. <span class="note"><span>[ <em>Note 2:</em> </span>This
+includes
+<code class="sourceCode cpp"><em>pack-index-expression</em></code>s and
+non-type template parameters.<span> — <em>end
+note</em> ]</span></span></p></li>
+</ul>
+<p>The <code class="sourceCode cpp"><em>id-expression</em></code> of a
+<code class="sourceCode cpp"><em>reflect-expression</em></code> is an
+unevaluated operand (<span>7.2.3 <a href="https://wg21.link/expr.context">[expr.context]</a></span>).</p>
 <div class="example">
 <span>[ <em>Example 2:</em> </span>
-<div class="sourceCode" id="cb113"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb113-1"><a href="#cb113-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(^^</span>T <span class="op">!=</span> <span class="op">^^</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb113-2"><a href="#cb113-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(^^</span>T <span class="op">==</span> <span class="op">^^</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb113-3"><a href="#cb113-3" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">(</span>T<span class="op">)</span> <span class="op">==</span> <span class="kw">sizeof</span><span class="op">(</span><span class="dt">int</span><span class="op">))</span>;</span>
-<span id="cb113-4"><a href="#cb113-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb113-5"><a href="#cb113-5" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> R <span class="op">=</span> <span class="op">^^</span>fn<span class="op">&lt;</span><span class="dt">char</span><span class="op">&gt;</span>;     <span class="co">// OK</span></span>
-<span id="cb113-6"><a href="#cb113-6" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> S <span class="op">=</span> <span class="op">^^</span>fn<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span>;      <span class="co">// error: cannot reflect an overload set</span></span>
-<span id="cb113-7"><a href="#cb113-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb113-8"><a href="#cb113-8" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r <span class="op">=</span> <span class="op">^^</span>std<span class="op">::</span>vector;  <span class="co">// OK</span></span></code></pre></div>
+<div class="sourceCode" id="cb116"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb116-1"><a href="#cb116-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(^^</span>T <span class="op">!=</span> <span class="op">^^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb116-2"><a href="#cb116-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(^^</span>T <span class="op">==</span> <span class="op">^^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb116-3"><a href="#cb116-3" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">(</span>T<span class="op">)</span> <span class="op">==</span> <span class="kw">sizeof</span><span class="op">(</span><span class="dt">int</span><span class="op">))</span>;</span>
+<span id="cb116-4"><a href="#cb116-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb116-5"><a href="#cb116-5" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> x <span class="op">=</span> <span class="op">^^</span>fn<span class="op">&lt;</span><span class="dt">char</span><span class="op">&gt;</span>;     <span class="co">// OK</span></span>
+<span id="cb116-6"><a href="#cb116-6" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> y <span class="op">=</span> <span class="op">^^</span>fn<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span>;      <span class="co">// error: ambiguous</span></span>
+<span id="cb116-7"><a href="#cb116-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb116-8"><a href="#cb116-8" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> z <span class="op">=</span> <span class="op">^^</span>std<span class="op">::</span>vector;  <span class="co">// OK</span></span>
+<span id="cb116-9"><a href="#cb116-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb116-10"><a href="#cb116-10" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb116-11"><a href="#cb116-11" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> S <span class="op">{</span></span>
+<span id="cb116-12"><a href="#cb116-12" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="kw">auto</span> r <span class="op">=</span> <span class="op">^^</span>T;</span>
+<span id="cb116-13"><a href="#cb116-13" aria-hidden="true" tabindex="-1"></a>  <span class="kw">using</span> type <span class="op">=</span> T;</span>
+<span id="cb116-14"><a href="#cb116-14" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb116-15"><a href="#cb116-15" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>S<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;::</span>r <span class="op">==</span> <span class="op">^^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb116-16"><a href="#cb116-16" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>S<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;::</span>type <span class="op">!=</span> <span class="op">^^</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
 </div>
@@ -6013,11 +6349,10 @@ <h3 class="unnumbered" id="expr.reflect-the-reflection-operator">7.6.2.10* [expr
 </div>
 <h3 class="unnumbered" id="expr.eq-equality-operators"><span>7.6.10 <a href="https://wg21.link/expr.eq">[expr.eq]</a></span> Equality
 Operators<a href="#expr.eq-equality-operators" class="self-link"></a></h3>
-<p>Extend <span>7.6.10 <a href="https://wg21.link/expr.eq">[expr.eq]</a></span>/2 to also handle
-<code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>:</p>
+<p>Extend paragraph 2 to also handle <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_100" id="pnum_100">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_114" id="pnum_114">2</a></span>
 The converted operands shall have arithmetic, enumeration, pointer, or
 pointer-to-member type, <span class="addu">type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,</span>
 or type <code class="sourceCode cpp">std<span class="op">::</span>nullptr_t</code>.
@@ -6032,29 +6367,30 @@ <h3 class="unnumbered" id="expr.eq-equality-operators"><span>7.6.10 <a href="htt
 specified conversions have been applied.</p>
 </blockquote>
 </div>
-<p>Add a new paragraph between <span>7.6.10 <a href="https://wg21.link/expr.eq">[expr.eq]</a></span>/5 and /6:</p>
+<p>Add a new paragraph between paragraphs 5 and 6:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_101" id="pnum_101">5</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_115" id="pnum_115">5</a></span>
 Two operands of type <code class="sourceCode cpp">std<span class="op">::</span>nullptr_t</code> or
 one operand of type <code class="sourceCode cpp">std<span class="op">::</span>nullptr_t</code> and
 the other a null pointer constant compare equal.</p>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_102" id="pnum_102">*</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_116" id="pnum_116">5+</a></span>
 If both operands are of type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,
 comparison is defined as follows:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_103" id="pnum_103">(*.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_117" id="pnum_117">(5+.1)</a></span>
 If one operand is a null reflection value, then they compare equal if
 and only if the other operand is also a null reflection value.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_104" id="pnum_104">(*.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_118" id="pnum_118">(5+.2)</a></span>
 Otherwise, if one operand represents a
-<code class="sourceCode cpp"><em>template-id</em></code> referring to a
-specialization of an alias template, then they compare equal if and only
-if the other operand represents the same
-<code class="sourceCode cpp"><em>template-id</em></code>
-([temp.type]).</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_105" id="pnum_105">(*.3)</a></span>
+<code class="sourceCode cpp"><em>typedef-name</em></code> that is a
+<code class="sourceCode cpp"><em>simple-template-id</em></code>, then
+they compare equal if and only if the other operand represents a
+<code class="sourceCode cpp"><em>typedef-name</em></code> that is the
+same <code class="sourceCode cpp"><em>simple-template-id</em></code>
+(<span>13.6 <a href="https://wg21.link/temp.type">[temp.type]</a></span>).</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_119" id="pnum_119">(5+.3)</a></span>
 Otherwise, if one operand represents a
 <code class="sourceCode cpp"><em>namespace-alias</em></code> or a
 <code class="sourceCode cpp"><em>typedef-name</em></code>, then they
@@ -6062,22 +6398,22 @@ <h3 class="unnumbered" id="expr.eq-equality-operators"><span>7.6.10 <a href="htt
 operand represents the same kind of construct, shares the same name, is
 declared within the same enclosing scope, and aliases the same
 underlying entity.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_106" id="pnum_106">(*.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_120" id="pnum_120">(5+.4)</a></span>
 Otherwise, if one operand represents a value, then they compare equal if
-and only if the other operand represents a template-argument-equivalent
-value (<span>13.6 <a href="https://wg21.link/temp.type">[temp.type]</a></span>).</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_107" id="pnum_107">(*.5)</a></span>
+and only if the other operand represents a value that is
+template-argument-equivalent (<span>13.6 <a href="https://wg21.link/temp.type">[temp.type]</a></span>).</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_121" id="pnum_121">(5+.5)</a></span>
 Otherwise, if one operand represents an object, then they compare equal
 if and only if the other operand represents the same object.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_108" id="pnum_108">(*.6)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_122" id="pnum_122">(5+.6)</a></span>
 Otherwise, if one operand represents an entity, then they compare equal
 if and only if the other operand represents the same entity.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_109" id="pnum_109">(*.7)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_123" id="pnum_123">(5+.7)</a></span>
 Otherwise, if one operand represents a
 <code class="sourceCode cpp"><em>base-specifier</em></code>, then they
 compare equal if and only if the other operand represents the same
 <code class="sourceCode cpp"><em>base-specifier</em></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_110" id="pnum_110">(*.8)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_124" id="pnum_124">(5+.8)</a></span>
 Otherwise, both operands
 <code class="sourceCode cpp">O<sub><em>1</em></sub></code> and
 <code class="sourceCode cpp">O<sub><em>2</em></sub></code> represent
@@ -6093,11 +6429,11 @@ <h3 class="unnumbered" id="expr.eq-equality-operators"><span>7.6.10 <a href="htt
 <code class="sourceCode cpp">C<sub><em>2</em></sub></code> would be
 declared with the same type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>, name (if
-any), <code class="sourceCode cpp"><em>alignment-specifiers</em></code>
+any), <code class="sourceCode cpp"><em>alignment-specifier</em></code>s
 (if any), width, and attributes.</li>
 </ul>
 </div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_111" id="pnum_111">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_125" id="pnum_125">6</a></span>
 If two operands compare equal, the result is
 <code class="sourceCode cpp"><span class="kw">true</span></code> for the
 <code class="sourceCode cpp"><span class="op">==</span></code> operator
@@ -6118,104 +6454,114 @@ <h3 class="unnumbered" id="expr.const-constant-expressions"><span>7.7 <a href="h
 and references to consteval-only objects from constant expressions.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_112" id="pnum_112">15</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_126" id="pnum_126">15</a></span>
 A <em>constant expression</em> is either a glvalue core constant
-expression that <span class="addu"> </span></p>
+expression <span class="addu"><code class="sourceCode cpp"><em>E</em></code></span> that
+<span class="addu"> </span></p>
 <ul>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_113" id="pnum_113">(15.1)</a></span>
-refers to an entity that is a permitted result of a constant
-expression<span class="addu">, and</span></p></li>
-<li><p><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_114" id="pnum_114">(15.2)</a></span>
-is of consteval-only type if the entity designated by the expression is
-of consteval-only type,</span></p>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_127" id="pnum_127">(15.1)</a></span>
+refers to an <span class="rm" style="color: #bf0303"><del>entity</del></span> <span class="addu">object or function</span> that is a permitted result of a
+constant expression<span class="addu">, and</span></p></li>
+<li><p><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_128" id="pnum_128">(15.2)</a></span>
+if <code class="sourceCode cpp"><em>E</em></code> designates a function
+of consteval-only type (<span>6.8.1 <a href="https://wg21.link/basic.types.general">[basic.types.general]</a></span>)
+or an object whose complete object is of consteval-only type, then
+<code class="sourceCode cpp"><em>E</em></code> is also of consteval-only
+type,</span></p>
 <div class="addu">
-<div class="note">
-<p><span>[ <em>Note 1:</em> </span>For example, given the function</p>
-<div class="sourceCode" id="cb114"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb114-1"><a href="#cb114-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> Base<span class="op">&amp;</span> fn<span class="op">(</span><span class="kw">const</span> Derived<span class="op">&amp;</span> derived<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb114-2"><a href="#cb114-2" aria-hidden="true" tabindex="-1"></a>  <span class="cf">return</span> derived;</span>
-<span id="cb114-3"><a href="#cb114-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
-<p>where <code class="sourceCode cpp">Derived</code> is a consteval-only
-type, if <code class="sourceCode cpp">Base</code> is not also a
-consteval-only type then <code class="sourceCode cpp">fn<span class="op">(</span>derived<span class="op">)</span></code>
-is never a constant expression.<span> — <em>end note</em> ]</span></p>
+<div class="example">
+<span>[ <em>Example 1:</em> </span>
+<div class="sourceCode" id="cb117"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb117-1"><a href="#cb117-1" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> Base <span class="op">{</span> <span class="op">}</span>;</span>
+<span id="cb117-2"><a href="#cb117-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> Derived <span class="op">:</span> Base <span class="op">{</span> std<span class="op">::</span>meta<span class="op">::</span>info r; <span class="op">}</span>;</span>
+<span id="cb117-3"><a href="#cb117-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-4"><a href="#cb117-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="kw">const</span> Base<span class="op">&amp;</span> fn<span class="op">(</span><span class="kw">const</span> Derived<span class="op">&amp;</span> derived<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> derived; <span class="op">}</span></span>
+<span id="cb117-5"><a href="#cb117-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-6"><a href="#cb117-6" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> obj <span class="op">=</span> Derived<span class="op">{^^::}</span>; <span class="co">// OK</span></span>
+<span id="cb117-7"><a href="#cb117-7" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">const</span><span class="op">&amp;</span> d <span class="op">=</span> obj; <span class="co">// OK</span></span>
+<span id="cb117-8"><a href="#cb117-8" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">const</span><span class="op">&amp;</span> b <span class="op">=</span> fn<span class="op">(</span>obj<span class="op">)</span>; <span class="co">// error: not a constant expression</span></span>
+<span id="cb117-9"><a href="#cb117-9" aria-hidden="true" tabindex="-1"></a>  <span class="co">// because Derived is a consteval-only type but Base is not.</span></span></code></pre></div>
+<span> — <em>end example</em> ]</span>
 </div>
 </div></li>
 </ul>
 <p>or a prvalue core constant expression whose value satisfies the
 following constraints:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_115" id="pnum_115">(15.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_129" id="pnum_129">(15.3)</a></span>
 if the value is an object of class type, each non-static data member of
-reference type refers to an entity that is a permitted result of a
-constant expression <span class="addu">and has consteval-only type if
-that entity has consteval-only type</span>,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_116" id="pnum_116">(15.4)</a></span>
+reference type refers to an <span class="rm" style="color: #bf0303"><del>entity</del></span> <span class="addu">object or function</span> that is a permitted result of a
+constant expression, and if the <span class="addu">object or function is
+of consteval-only type, or is the subobject of such an object, then so
+is the value</span>,</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_130" id="pnum_130">(15.4)</a></span>
 if the value is an object of scalar type, it does not have an
-indeterminate or erroneous value ([basic.indet]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_117" id="pnum_117">(15.5)</a></span>
+indeterminate or erroneous value (<span>6.7.4 <a href="https://wg21.link/basic.indet">[basic.indet]</a></span>),</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_131" id="pnum_131">(15.5)</a></span>
 if the value is of pointer type, <span class="addu">then: </span>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_118" id="pnum_118">(15.5.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_132" id="pnum_132">(15.5.1)</a></span>
 it is a pointer to an object of static storage duration<span class="rm" style="color: #bf0303"><del>,</del></span> <span class="addu">or</span>
-a pointer past the end of such an object ([expr.add]), <span class="addu">such that if the type of that object is a consteval-only
-type then that pointer type is also a consteval-only type,
-or</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_119" id="pnum_119">(15.5.2)</a></span>
+a pointer past the end of such an object (<span>7.6.6 <a href="https://wg21.link/expr.add">[expr.add]</a></span>), <span class="addu">and if the complete object of that object is of
+consteval-only type then so is that pointer,</span></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_133" id="pnum_133">(15.5.2)</a></span>
 <span class="addu">it is</span> a pointer to a non-immediate function,
-or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_120" id="pnum_120">(15.5.3)</a></span>
+<span class="addu">and if that function is of consteval-only type then
+so is that pointer,</span> or</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_134" id="pnum_134">(15.5.3)</a></span>
 <span class="addu">it is</span> a null pointer value,</li>
 </ul></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_121" id="pnum_121">(15.6)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_135" id="pnum_135">(15.6)</a></span>
 if the value is of pointer-to-member-function type, it does not
-designate an immediate function, and</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_122" id="pnum_122">(15.7)</a></span>
+designate an immediate function, <span class="addu">and if that function
+is of consteval-only type then so is that value,</span> and</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_136" id="pnum_136">(15.7)</a></span>
 if the value is an object of class or array type, each subobject
 satisfies these constraints for the value.</li>
 </ul>
 </blockquote>
 </div>
 <p>Modify (and clean up) the definition of <em>immediate-escalating</em>
-to also apply to expressions of consteval-only type.</p>
+in paragraph 18 to also apply to expressions of consteval-only type.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_123" id="pnum_123">18</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_137" id="pnum_137">18</a></span>
 A<span class="rm" style="color: #bf0303"><del>n</del></span> <span class="addu">potentially-evaluated</span> expression or conversion is
 <em>immediate-escalating</em> if it is <span class="rm" style="color: #bf0303"><del>not</del></span> <span class="addu">neither</span> initially in an immediate function context
 <span class="addu">nor a subexpression of an immediate
-invocation,</span> and it <span class="rm" style="color: #bf0303"><del>is</del></span> either</p>
+invocation,</span> and it is <span class="rm" style="color: #bf0303"><del>either</del></span></p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_124" id="pnum_124">(18.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_138" id="pnum_138">(18.1)</a></span>
 <span class="rm" style="color: #bf0303"><del>a
-potentially-evaluated</del></span> <span class="addu">is an</span>
+potentially-evaluated</del></span> <span class="addu">an</span>
 <code class="sourceCode cpp"><em>id-expression</em></code> that denotes
 an immediate function<span class="addu">,</span> <span class="rm" style="color: #bf0303"><del>that is not a subexpression of an immediate
 invocation, or</del></span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_125" id="pnum_125">(18.2)</a></span>
-<span class="addu">is</span> an immediate invocation that is not a
-constant expression<span class="addu">, or</span> <span class="rm" style="color: #bf0303"><del>and is not a subexpression of an immediate
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_139" id="pnum_139">(18.2)</a></span>
+an immediate invocation that is not a constant expression<span class="addu">, or</span> <span class="rm" style="color: #bf0303"><del>and is not a subexpression of an immediate
 invocation.</del></span></li>
-<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_126" id="pnum_126">(18.3)</a></span>
-has consteval-only type ([basic.types.general]).</span></li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_140" id="pnum_140">(18.3)</a></span>
+of consteval-only type (<span>6.8.1 <a href="https://wg21.link/basic.types.general">[basic.types.general]</a></span>).</span></li>
 </ul>
 </blockquote>
 </div>
-<p>Add new paragraphs prior to the definition of <em>manifestly constant
-evaluated</em> (<span>7.7 <a href="https://wg21.link/expr.const">[expr.const]</a></span>/20), and
+<p>Add a new paragraphs prior to the definition of <em>manifestly
+constant evaluated</em> (<span>7.7 <a href="https://wg21.link/expr.const">[expr.const]</a></span>/21), and
 renumber accordingly:</p>
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_127" id="pnum_127">19</a></span>
-An expression or conversion is <em>plainly constant-evaluated</em> if it
-is</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_141" id="pnum_141">21pre</a></span>
+A non-dependent expression or conversion is <em>plainly
+constant-evaluated</em> if it is not in a complete-class context
+(<span>11.4.1 <a href="https://wg21.link/class.mem.general">[class.mem.general]</a></span>)
+and is either</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_128" id="pnum_128">(19.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_142" id="pnum_142">(21pre.1)</a></span>
 the <code class="sourceCode cpp"><em>constant-expression</em></code> of
 a <code class="sourceCode cpp"><em>static_assert-declaration</em></code>
 (<span>9.1 <a href="https://wg21.link/dcl.pre">[dcl.pre]</a></span>),
 or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_129" id="pnum_129">(19.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_143" id="pnum_143">(21pre.2)</a></span>
 an initializer of a
 <code class="sourceCode cpp"><span class="kw">constexpr</span></code>
 (<span>9.2.6 <a href="https://wg21.link/dcl.constexpr">[dcl.constexpr]</a></span>) or
@@ -6223,34 +6569,13 @@ <h3 class="unnumbered" id="expr.const-constant-expressions"><span>7.7 <a href="h
 (<span>9.2.7 <a href="https://wg21.link/dcl.constinit">[dcl.constinit]</a></span>)
 variable.</li>
 </ul>
-<p><span class="note"><span>[ <em>Note 2:</em> </span>A plainly
-constant-evaluated expression
-<code class="sourceCode cpp"><em>E</em></code> is evaluated exactly
-once, may produce injected declarations (see below), and any such
-declarations are reachable at a point immediately following
-<code class="sourceCode cpp"><em>E</em></code> (<span>5.2 <a href="https://wg21.link/lex.phases">[lex.phases]</a></span>).<span>
-— <em>end note</em> ]</span></span></p>
-<div class="example">
-<span>[ <em>Example 1:</em> </span>
-<div class="sourceCode" id="cb115"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb115-1"><a href="#cb115-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span><span class="op">&gt;</span> <span class="kw">struct</span> RV <span class="op">{}</span>;</span>
-<span id="cb115-2"><a href="#cb115-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-3"><a href="#cb115-3" aria-hidden="true" tabindex="-1"></a><span class="co">// instantiations of &#39;T::f(0)&#39; are not plainly constant-evaluated</span></span>
-<span id="cb115-4"><a href="#cb115-4" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> RV<span class="op">&lt;</span>T<span class="op">::</span>f<span class="op">(</span><span class="dv">0</span><span class="op">)&gt;</span> check<span class="op">(</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb115-5"><a href="#cb115-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-6"><a href="#cb115-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">int</span> cfn<span class="op">(</span><span class="dt">int</span><span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="dv">1</span>; <span class="op">}</span></span>
-<span id="cb115-7"><a href="#cb115-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-8"><a href="#cb115-8" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> b1 <span class="op">=</span> cfn<span class="op">(</span><span class="dv">1</span><span class="op">)</span>;            <span class="co">// &#39;cfn(1)&#39; is plainly constant-evaluated</span></span>
-<span id="cb115-9"><a href="#cb115-9" aria-hidden="true" tabindex="-1"></a><span class="kw">constinit</span> <span class="dt">int</span> b2 <span class="op">=</span> cfn<span class="op">(</span><span class="dv">2</span><span class="op">)</span>;            <span class="co">// &#39;cfn(2)&#39; is plainly constant-evaluated</span></span>
-<span id="cb115-10"><a href="#cb115-10" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> <span class="dt">int</span> b3 <span class="op">=</span> cfn<span class="op">(</span><span class="dv">3</span><span class="op">)</span>;                <span class="co">// &#39;cfn(3)&#39; is not plainly constant-evaluated</span></span>
-<span id="cb115-11"><a href="#cb115-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-12"><a href="#cb115-12" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>b1 <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span>;                <span class="co">// &#39;b1 &gt; 0&#39; is plainly constant-evaluated</span></span>
-<span id="cb115-13"><a href="#cb115-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-14"><a href="#cb115-14" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> Cls <span class="op">{</span></span>
-<span id="cb115-15"><a href="#cb115-15" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> var <span class="op">=</span> cfn<span class="op">(</span><span class="dv">4</span><span class="op">)</span>;  <span class="co">// &#39;cfn(4)&#39; is plainly constant-evaluated</span></span>
-<span id="cb115-16"><a href="#cb115-16" aria-hidden="true" tabindex="-1"></a>  <span class="dt">int</span> arr<span class="op">[</span>cfn<span class="op">(</span><span class="dv">5</span><span class="op">)]</span>;                    <span class="co">// &#39;cfn(5)&#39; is not plainly constant-evaluated</span></span>
-<span id="cb115-17"><a href="#cb115-17" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
-<span> — <em>end example</em> ]</span>
-</div>
+<p><span class="note"><span>[ <em>Note 1:</em> </span>The evaluation of
+a plainly constant-evaluated expression
+<code class="sourceCode cpp"><em>E</em></code> can produce injected
+declarations (see below) and happens exactly once (<span>5.2 <a href="https://wg21.link/lex.phases">[lex.phases]</a></span>). Any such
+declarations are reachable from a point that follows immediately after
+<code class="sourceCode cpp"><em>E</em></code>.<span> — <em>end
+note</em> ]</span></span></p>
 </div>
 </blockquote>
 </div>
@@ -6259,148 +6584,113 @@ <h3 class="unnumbered" id="expr.const-constant-expressions"><span>7.7 <a href="h
 constant-evaluated</em> expressions:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_130" id="pnum_130">20</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_144" id="pnum_144">21</a></span>
 An expression or conversion is <em>manifestly constant-evaluated</em> if
 it is:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_131" id="pnum_131">(20.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_145" id="pnum_145">(21.1)</a></span>
 a <code class="sourceCode cpp"><em>constant-expression</em></code>,
 or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_132" id="pnum_132">(20.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_146" id="pnum_146">(21.2)</a></span>
 the condition of a constexpr if statement (<span>8.5.2 <a href="https://wg21.link/stmt.if">[stmt.if]</a></span>), or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_133" id="pnum_133">(20.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_147" id="pnum_147">(21.3)</a></span>
 an immediate invocation, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_134" id="pnum_134">(20.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_148" id="pnum_148">(21.4)</a></span>
 the result of substitution into an atomic constraint expression to
 determine whether it is satisfied (<span>13.5.2.3 <a href="https://wg21.link/temp.constr.atomic">[temp.constr.atomic]</a></span>),
 or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_135" id="pnum_135">(20.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_149" id="pnum_149">(21.5)</a></span>
 the initializer for a variable that is usable in constant expressions or
 has constant initialization (<span>6.9.3.2 <a href="https://wg21.link/basic.start.static">[basic.start.static]</a></span>).</li>
 </ul>
 <div class="addu">
-<p><span class="note"><span>[ <em>Note 3:</em> </span>All plainly
+<p><span class="note"><span>[ <em>Note 2:</em> </span>All plainly
 constant-evaluated expressions are manifestly constant-evaluated, but
-some manifestly constant-evaluated expressions (e.g., initializers that
-can require trial evaluations) are not plainly constant-evaluated. Such
-expressions are still evaluated during translation, but (unlike plainly
-constant-evaluated expressions) may be evaluated multiple times, and
+some manifestly constant-evaluated expressions (e.g., template
+arguments) are not plainly constant-evaluated. Such expressions are
+still evaluated during translation, but (unlike plainly
+constant-evaluated expressions) can be evaluated multiple times, and
 there are no constraints on the relative order of their
 evaluation.<span> — <em>end note</em> ]</span></span></p>
 </div>
 </blockquote>
 </div>
-<p>Add new paragraphs defining <em>evaluation context</em>, <em>injected
-declaration</em>, and <em>injected point</em> after the example
-following the definition of <em>manifestly constant-evaluated</em>, and
-renumber accordingly:</p>
+<p>After the example following the definition of <em>manifestly
+constant-evaluated</em>, introduce new terminology and rules for
+injecting declarations and renumber accordingly:</p>
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_136" id="pnum_136">21</a></span>
-The evaluation of an expression
-<code class="sourceCode cpp"><em>E</em></code> can introduce an
-<em>injected declaration</em>. For each such declaration
-<code class="sourceCode cpp"><em>D</em></code>, the <em>injected
-point</em> is a corresponding program point which follows the last
-non-injected point in the translation unit containing
-<code class="sourceCode cpp"><em>D</em></code>. The evaluation of
-<code class="sourceCode cpp"><em>E</em></code> is said to
-<em>produce</em> the declaration
-<code class="sourceCode cpp"><em>D</em></code>.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_150" id="pnum_150">22</a></span>
+The evaluation of an expression can introduce one or more <em>injected
+declarations</em>. Each such declaration has an associated <em>injected
+point</em> which follows the last non-injected program point in the
+translation unit containing that declaration. The evaluation is said to
+<em>produce</em> the declaration.</p>
 <p><span class="note13"><span>[ <em>Note 13:</em> </span>Special rules
-concerning reachability apply to injected points ([module.reach]).<span>
+concerning reachability apply to injected points (<span>10.7 <a href="https://wg21.link/module.reach">[module.reach]</a></span>).<span>
 — <em>end note</em> ]</span></span></p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_137" id="pnum_137">22</a></span>
-The program is ill-formed if an injected declaration is produced by the
-evaluation of an expression
-<code class="sourceCode cpp"><em>E</em></code> that is</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_151" id="pnum_151">23</a></span>
+The program is ill-formed if the evaluation of a manifestly
+constant-evaluated expression
+<code class="sourceCode cpp"><em>M</em></code> produces an injected
+declaration <code class="sourceCode cpp"><em>D</em></code> and
+either</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_138" id="pnum_138">(22.1)</a></span>
-a manifestly constant-evaluated expression that is not plainly
-constant-evaluated, or</li>
-<li>within the body of an immediate-escalating function
-<code class="sourceCode cpp"><em>F</em></code>, unless
-<code class="sourceCode cpp"><em>E</em></code> is a plainly
-constant-evaluated expression or a subexpression thereof.</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_152" id="pnum_152">(23.1)</a></span>
+<code class="sourceCode cpp"><em>M</em></code> is not a plainly
+constant-evaluated expression, or</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_153" id="pnum_153">(23.2)</a></span>
+the target scope of <code class="sourceCode cpp"><em>D</em></code> is
+not instantiation-sequenced with
+<code class="sourceCode cpp"><em>M</em></code> ([lex.phases]).</li>
 </ul>
-<p><span class="note"><span>[ <em>Note 14:</em> </span>An immediate
-invocation within an immediate-escalating function is similar to a trial
-evaluation of a variable initializer: if it fails to be a constant
-expression, the implementation may be forced to evaluate it again. The
-above rule is intended to only permit evaluations to produce
-declarations when such evaluations can be guaranteed to only happen
-once.<span> — <em>end note</em> ]</span></span></p>
 <div class="example">
 <span>[ <em>Example 2:</em> </span>
-<div class="sourceCode" id="cb116"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb116-1"><a href="#cb116-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> make_decl<span class="op">(</span><span class="dt">int</span><span class="op">)</span>;      <span class="co">// calling &#39;make_decl(n)&#39; produces a declaration</span></span>
-<span id="cb116-2"><a href="#cb116-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-3"><a href="#cb116-3" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="dt">int</span> R<span class="op">&gt;</span> <span class="kw">requires</span> <span class="op">(</span>make_decl<span class="op">(</span>R<span class="op">))</span></span>
-<span id="cb116-4"><a href="#cb116-4" aria-hidden="true" tabindex="-1"></a>  <span class="dt">bool</span> tfn<span class="op">()</span>;</span>
-<span id="cb116-5"><a href="#cb116-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-6"><a href="#cb116-6" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> b1 <span class="op">=</span> <span class="op">!</span>make_decl<span class="op">(</span><span class="dv">1</span><span class="op">)</span>;  <span class="co">// OK, constexpr variable so this is plainly</span></span>
-<span id="cb116-7"><a href="#cb116-7" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// constant evaluated</span></span>
-<span id="cb116-8"><a href="#cb116-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-9"><a href="#cb116-9" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> b2 <span class="op">=</span> <span class="op">!</span>make_decl<span class="op">(</span><span class="dv">2</span><span class="op">)</span>;            <span class="co">// error: initializer !make_decl(42) produced</span></span>
-<span id="cb116-10"><a href="#cb116-10" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// a declaration but is not plainly constant</span></span>
-<span id="cb116-11"><a href="#cb116-11" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// evaluated</span></span>
-<span id="cb116-12"><a href="#cb116-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-13"><a href="#cb116-13" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> b3 <span class="op">=</span> tfn<span class="op">&lt;</span><span class="dv">3</span><span class="op">&gt;()</span>;       <span class="co">// error: the invocation of make_decl(R) in the</span></span>
-<span id="cb116-14"><a href="#cb116-14" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// requires clause produced a declaration but is</span></span>
-<span id="cb116-15"><a href="#cb116-15" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// not plainly constant evaluated</span></span>
-<span id="cb116-16"><a href="#cb116-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-17"><a href="#cb116-17" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">int</span> <span class="op">*</span>not_constant<span class="op">()</span> <span class="op">{</span></span>
-<span id="cb116-18"><a href="#cb116-18" aria-hidden="true" tabindex="-1"></a>  make_decl<span class="op">(</span><span class="dv">4</span><span class="op">)</span>;</span>
-<span id="cb116-19"><a href="#cb116-19" aria-hidden="true" tabindex="-1"></a>  <span class="cf">return</span> <span class="kw">new</span> <span class="dt">int</span> <span class="op">{}</span>;</span>
-<span id="cb116-20"><a href="#cb116-20" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
-<span id="cb116-21"><a href="#cb116-21" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> b4 <span class="op">=</span> <span class="op">[]</span> <span class="op">{</span></span>
-<span id="cb116-22"><a href="#cb116-22" aria-hidden="true" tabindex="-1"></a>  <span class="dt">int</span> <span class="op">*</span>p <span class="op">=</span> not_constant<span class="op">()</span>;          <span class="co">// error: not_constant() produces a declaration</span></span>
-<span id="cb116-23"><a href="#cb116-23" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// in an immediate-escalated function, but is</span></span>
-<span id="cb116-24"><a href="#cb116-24" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// not plainly constant-evaluated.</span></span>
-<span id="cb116-25"><a href="#cb116-25" aria-hidden="true" tabindex="-1"></a>  <span class="kw">delete</span> p;</span>
-<span id="cb116-26"><a href="#cb116-26" aria-hidden="true" tabindex="-1"></a>  <span class="cf">return</span> <span class="kw">true</span>;</span>
-<span id="cb116-27"><a href="#cb116-27" aria-hidden="true" tabindex="-1"></a><span class="op">}()</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb118"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb118-1"><a href="#cb118-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> make_decl<span class="op">(</span><span class="dt">int</span><span class="op">)</span>;      <span class="co">// calling &#39;make_decl(n)&#39; produces an injected</span></span>
+<span id="cb118-2"><a href="#cb118-2" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// declaration in the global namespace</span></span>
+<span id="cb118-3"><a href="#cb118-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-4"><a href="#cb118-4" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> b1 <span class="op">=</span> <span class="op">!</span>make_decl<span class="op">(</span><span class="dv">1</span><span class="op">)</span>;  <span class="co">// OK, constexpr variable so this is plainly</span></span>
+<span id="cb118-5"><a href="#cb118-5" aria-hidden="true" tabindex="-1"></a>                                    <span class="co">// constant evaluated</span></span>
+<span id="cb118-6"><a href="#cb118-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-7"><a href="#cb118-7" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> b2 <span class="op">=</span> <span class="op">!</span>make_decl<span class="op">(</span><span class="dv">2</span><span class="op">)</span>;</span>
+<span id="cb118-8"><a href="#cb118-8" aria-hidden="true" tabindex="-1"></a>  <span class="co">// error: initializer !make_decl(42) produced an injected declaration but is</span></span>
+<span id="cb118-9"><a href="#cb118-9" aria-hidden="true" tabindex="-1"></a>  <span class="co">// not plainly constant-evaluated</span></span>
+<span id="cb118-10"><a href="#cb118-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-11"><a href="#cb118-11" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="dt">int</span> R<span class="op">&gt;</span> <span class="kw">requires</span> <span class="op">(</span>make_decl<span class="op">(</span>R<span class="op">))</span></span>
+<span id="cb118-12"><a href="#cb118-12" aria-hidden="true" tabindex="-1"></a>  <span class="dt">bool</span> tfn<span class="op">()</span>;</span>
+<span id="cb118-13"><a href="#cb118-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-14"><a href="#cb118-14" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> b3 <span class="op">=</span> tfn<span class="op">&lt;</span><span class="dv">3</span><span class="op">&gt;()</span>;</span>
+<span id="cb118-15"><a href="#cb118-15" aria-hidden="true" tabindex="-1"></a>  <span class="co">// error: the invocation of make_decl(R) in the requires clause produces an</span></span>
+<span id="cb118-16"><a href="#cb118-16" aria-hidden="true" tabindex="-1"></a>  <span class="co">// injected declaration but is not plainly constant-evaluated</span></span>
+<span id="cb118-17"><a href="#cb118-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-18"><a href="#cb118-18" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span><span class="op">&gt;</span> <span class="kw">struct</span> S <span class="op">{</span></span>
+<span id="cb118-19"><a href="#cb118-19" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> b4 <span class="op">=</span> make_decl<span class="op">(</span><span class="dv">4</span><span class="op">)</span>;</span>
+<span id="cb118-20"><a href="#cb118-20" aria-hidden="true" tabindex="-1"></a>    <span class="co">// error: target scope of the injected declaration is not</span></span>
+<span id="cb118-21"><a href="#cb118-21" aria-hidden="true" tabindex="-1"></a>    <span class="co">// instantatiation-sequenced with the expression</span></span>
+<span id="cb118-22"><a href="#cb118-22" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_139" id="pnum_139">24</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_154" id="pnum_154">24</a></span>
 The <em>evaluation context</em> is a set of points within the program
-that determines which declarations are found by certain expressions used
-for reflection. During the evaluation of a manifestly constant-evaluated
-expression <code class="sourceCode cpp"><em>M</em></code>, the
-evaluation context of an evaluation
-<code class="sourceCode cpp"><em>E</em></code> comprises the union
-of</p>
+that determines the behavior of certain functions used for reflection.
+During the evaluation of a manifestly constant-evaluated expression
+<code class="sourceCode cpp"><em>M</em></code>, the evaluation context
+of an evaluation <code class="sourceCode cpp"><em>E</em></code>
+comprises the union of</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_140" id="pnum_140">(24.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_155" id="pnum_155">(24.1)</a></span>
 the instantiation context of
-<code class="sourceCode cpp"><em>M</em></code> ([module.context]),
+<code class="sourceCode cpp"><em>M</em></code> (<span>10.6 <a href="https://wg21.link/module.context">[module.context]</a></span>),
 and</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_141" id="pnum_141">(24.2)</a></span>
-the injected points corresponding to any injected declarations
-([expr.const]) produced by evaluations sequenced before
-<code class="sourceCode cpp"><em>E</em></code> ([intro.execution]).</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_156" id="pnum_156">(24.2)</a></span>
+the injected points corresponding to any injected declarations produced
+by evaluations sequenced before
+<code class="sourceCode cpp"><em>E</em></code> (<span>6.9.1 <a href="https://wg21.link/intro.execution">[intro.execution]</a></span>).</li>
 </ul>
 </div>
 </blockquote>
 </div>
-<h3 class="unnumbered" id="dcl.typedef-the-typedef-specifier"><span>9.2.4 <a href="https://wg21.link/dcl.typedef">[dcl.typedef]</a></span> The
-<code class="sourceCode cpp"><span class="kw">typedef</span></code>
-specifier<a href="#dcl.typedef-the-typedef-specifier" class="self-link"></a></h3>
-<p>Account for
-<code class="sourceCode cpp"><em>splice-type-speciifer</em></code>s in
-paragraph 3.</p>
-<div class="std">
-<blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_142" id="pnum_142">3</a></span>
-A <code class="sourceCode cpp"><em>simple-template-id</em></code> is
-only a <code class="sourceCode cpp"><em>typedef-name</em></code> if its
-<code class="sourceCode cpp"><em>template-name</em></code> <span class="addu">or
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>
-designates</span> <span class="rm" style="color: #bf0303"><del>names</del></span> an alias template or a
-template
-<code class="sourceCode cpp"><em>template-parameter</em></code>.</p>
-</blockquote>
-</div>
 <h3 class="unnumbered" id="dcl.type.simple-simple-type-specifiers"><span>9.2.9.3 <a href="https://wg21.link/dcl.type.simple">[dcl.type.simple]</a></span>
 Simple type specifiers<a href="#dcl.type.simple-simple-type-specifiers" class="self-link"></a></h3>
 <p>Extend the grammar for
@@ -6409,69 +6699,47 @@ <h3 class="unnumbered" id="dcl.type.simple-simple-type-specifiers"><span>9.2.9.3
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb117"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb117-1"><a href="#cb117-1" aria-hidden="true" tabindex="-1"></a>  <em>computed-type-specifier</em>:</span>
-<span id="cb117-2"><a href="#cb117-2" aria-hidden="true" tabindex="-1"></a>     <em>decltype-specifier</em></span>
-<span id="cb117-3"><a href="#cb117-3" aria-hidden="true" tabindex="-1"></a>     <em>pack-index-specifier</em></span>
-<span id="cb117-4"><a href="#cb117-4" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>splice-type-specifier</em></span></span></code></pre></div>
-</div>
-</blockquote>
+<div class="sourceCode" id="cb119"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb119-1"><a href="#cb119-1" aria-hidden="true" tabindex="-1"></a>  <em>computed-type-specifier</em>:</span>
+<span id="cb119-2"><a href="#cb119-2" aria-hidden="true" tabindex="-1"></a>     <em>decltype-specifier</em></span>
+<span id="cb119-3"><a href="#cb119-3" aria-hidden="true" tabindex="-1"></a>     <em>pack-index-specifier</em></span>
+<span id="cb119-4"><a href="#cb119-4" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>splice-type-specifier</em></span></span></code></pre></div>
 </div>
-<p>Add a restriction to paragrpah 2 disallowing splicers from appearing
-after nested name specifiers.</p>
-<div class="std">
-<blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_143" id="pnum_143">2</a></span>
-The component names of a
-<code class="sourceCode cpp"><em>simple-type-specifier</em></code> are
-those of its
-<code class="sourceCode cpp"><em>nested-name-specifier</em></code>,
-<code class="sourceCode cpp"><em>type-name</em></code>,
-<code class="sourceCode cpp"><em>simple-template-id</em></code>,
-<code class="sourceCode cpp"><em>template-name</em></code>, and/or
-<code class="sourceCode cpp"><em>type-constraint</em></code> (if it is a
-<code class="sourceCode cpp"><em>placeholder-type-specifier</em></code>).
-The component name of a
-<code class="sourceCode cpp"><em>type-name</em></code> is the first name
-in it. <span class="addu">The
-<code class="sourceCode cpp"><em>simple-template-id</em></code> in a
-<code class="sourceCode cpp"><em>type-specifier</em></code> of the form
-<code class="sourceCode cpp"><em>nested-name-specifier</em> <span class="kw">template</span> <em>simple-template-id</em></code>
-shall not contain a splicer.</span></p>
 </blockquote>
 </div>
-<p>Indicate that a
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code> can
-be a placeholder for a deduced class type.</p>
+<p>Extend the definition of “placeholder for a deduced class type” in p3
+to accommodate
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_144" id="pnum_144">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_157" id="pnum_157">3</a></span>
 A
 <code class="sourceCode cpp"><em>placeholder-type-specifier</em></code>
 is a placeholder for a type to be deduced ([dcl.spec.auto]). A
 <code class="sourceCode cpp"><em>type-specifier</em></code> <span class="rm" style="color: #bf0303"><del>of the form <span><code class="sourceCode default">typename<sub><em>opt</em></sub> <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>template-name</em></code></span></del></span>
 is a placeholder for a deduced class type ([dcl.type.class.deduct])
-<span class="addu">if it</span></p>
-<div class="addu">
+<span class="addu">if it either </span></p>
 <ul>
-<li>is of the form <code class="sourceCode cpp">typename<sub><em>opt</em></sub> <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>template-name</em></code>,
-or</li>
-<li>consists of a
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code> that
-designates a class template or alias template.</li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_158" id="pnum_158">(3.1)</a></span>
+is of the form <code class="sourceCode cpp">typename<sub><em>opt</em></sub> <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>template-name</em></code>,
+or</span></li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_159" id="pnum_159">(3.2)</a></span>
+is of the form
+<code class="sourceCode cpp">typename<sub><em>opt</em></sub> <em>splice-specifier</em></code>
+and the <code class="sourceCode cpp"><em>splice-specifier</em></code>
+designates a class template or alias template.</span></li>
 </ul>
-</div>
 <p>The
 <code class="sourceCode cpp"><em>nested-name-specifier</em></code>, if
 any, shall be non-dependent and the
 <code class="sourceCode cpp"><em>template-name</em></code> <span class="addu">or
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code></span>
+<code class="sourceCode cpp"><em>splice-specifier</em></code></span>
 shall <span class="rm" style="color: #bf0303"><del>name</del></span>
 <span class="addu">designate</span> a deducible template. A
 <em>deducible template</em> is either a class template or is an alias
 template whose
 <code class="sourceCode cpp"><em>defining-type-id</em></code> is of the
 form</p>
-<div class="sourceCode" id="cb118"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb118-1"><a href="#cb118-1" aria-hidden="true" tabindex="-1"></a>typename<sub><em>opt</em></sub> <em>nested-name-specifier</em><sub><em>opt</em></sub> template<sub><em>opt</em></sub> <em>simple-template-id</em></span></code></pre></div>
+<div class="sourceCode" id="cb120"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb120-1"><a href="#cb120-1" aria-hidden="true" tabindex="-1"></a>typename<sub><em>opt</em></sub> <em>nested-name-specifier</em><sub><em>opt</em></sub> template<sub><em>opt</em></sub> <em>simple-template-id</em></span></code></pre></div>
 <p>where the
 <code class="sourceCode cpp"><em>nested-name-specifier</em></code> (if
 any) is non-dependent and the
@@ -6537,7 +6805,7 @@ <h3 class="unnumbered" id="dcl.type.simple-simple-type-specifiers"><span>9.2.9.3
 <tr class="odd">
 <td style="text-align: left;"><span class="addu"><code class="sourceCode cpp"><em>splice-type-specifier</em></code></span></td>
 <td style="text-align: left;"><span class="addu">the type as defined in
-[dcl.type.class.deduct]</span></td>
+[dcl.type.splice]</span></td>
 </tr>
 <tr class="even">
 <td style="text-align: left;"><code class="sourceCode cpp"><span class="op">...</span></code></td>
@@ -6547,6 +6815,83 @@ <h3 class="unnumbered" id="dcl.type.simple-simple-type-specifiers"><span>9.2.9.3
 </table>
 </blockquote>
 </div>
+<h3 class="unnumbered" id="dcl.type.splice-type-splicing">[dcl.type.splice] Type splicing<a href="#dcl.type.splice-type-splicing" class="self-link"></a></h3>
+<p>Add a new subsection of (<span>9.2.9 <a href="https://wg21.link/dcl.type">[dcl.type]</a></span>) following
+(<span>9.2.9.8 <a href="https://wg21.link/dcl.type.class.deduct">[dcl.type.class.deduct]</a></span>).</p>
+<div class="std">
+<blockquote>
+<div class="addu">
+<p><strong>Type Splicing [dcl.type.splice]</strong></p>
+<div class="sourceCode" id="cb121"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb121-1"><a href="#cb121-1" aria-hidden="true" tabindex="-1"></a><em>splice-type-specifier</em>:</span>
+<span id="cb121-2"><a href="#cb121-2" aria-hidden="true" tabindex="-1"></a>   typename<sub><em>opt</em></sub> <em>splice-specifier</em></span>
+<span id="cb121-3"><a href="#cb121-3" aria-hidden="true" tabindex="-1"></a>   typename<sub><em>opt</em></sub> <em>splice-specialization-specifier</em></span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_160" id="pnum_160">1</a></span>
+A <code class="sourceCode cpp"><em>splice-specifier</em></code> or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+immediately followed by
+<code class="sourceCode cpp"><span class="op">::</span></code> is never
+interpreted as part of a
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>. A
+<code class="sourceCode cpp"><em>splice-specifier</em></code> or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+not preceded by
+<code class="sourceCode cpp"><span class="kw">typename</span></code> is
+only interpreted as a
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>
+within a type-only context (<span>13.8.1 <a href="https://wg21.link/temp.res.general">[temp.res.general]</a></span>).</p>
+<div class="example">
+<span>[ <em>Example 1:</em> </span>
+<div class="sourceCode" id="cb122"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb122-1"><a href="#cb122-1" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> S <span class="op">{</span> <span class="kw">using</span> type <span class="op">=</span> <span class="dt">int</span>; <span class="op">}</span>;</span>
+<span id="cb122-2"><a href="#cb122-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span> R<span class="op">&gt;</span> <span class="kw">struct</span> TCls <span class="op">{</span></span>
+<span id="cb122-3"><a href="#cb122-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">typename</span> <span class="op">[:</span>R<span class="op">:]::</span>type member;  <span class="co">// typename applies to the qualified name</span></span>
+<span id="cb122-4"><a href="#cb122-4" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
+<span id="cb122-5"><a href="#cb122-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb122-6"><a href="#cb122-6" aria-hidden="true" tabindex="-1"></a><span class="dt">int</span> fn<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb122-7"><a href="#cb122-7" aria-hidden="true" tabindex="-1"></a>  <span class="op">[:^^</span>S<span class="op">::</span>type<span class="op">:]</span> <span class="op">*</span>var;           <span class="co">// error: [:^^S::type:] is an expression</span></span>
+<span id="cb122-8"><a href="#cb122-8" aria-hidden="true" tabindex="-1"></a>  <span class="kw">typename</span> <span class="op">[:^^</span>S<span class="op">::</span>type<span class="op">:]</span> <span class="op">*</span>var;  <span class="co">// OK, declares variable with type int*</span></span>
+<span id="cb122-9"><a href="#cb122-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb122-10"><a href="#cb122-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb122-11"><a href="#cb122-11" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> alias <span class="op">=</span> <span class="op">[:^^</span>S<span class="op">::</span>type<span class="op">:]</span>;    <span class="co">// OK, type-only context</span></span></code></pre></div>
+<span> — <em>end example</em> ]</span>
+</div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_161" id="pnum_161">2</a></span>
+For a <code class="sourceCode cpp"><em>splice-type-specifier</em></code>
+of the form
+<code class="sourceCode cpp">typename<sub><em>opt</em></sub> <em>splice-specifier</em></code>,
+the <code class="sourceCode cpp"><em>splice-specifier</em></code> shall
+designate a type, a type alias, a primary class template, an alias
+template, or a concept. The
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>
+designates the same entity as the
+<code class="sourceCode cpp"><em>splice-specifier</em></code>.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_162" id="pnum_162">3</a></span>
+For a <code class="sourceCode cpp"><em>splice-type-specifier</em></code>
+of the form <code class="sourceCode cpp">typename<sub><em>opt</em></sub> <em>splice-specialization-specifier</em></code>,
+the <code class="sourceCode cpp"><em>splice-specifier</em></code> of the
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+shall designate a primary class template or an alias template. Let
+<code class="sourceCode cpp"><em>T</em></code> be that template and let
+<code class="sourceCode cpp"><em>S</em></code> be the specialization of
+<code class="sourceCode cpp"><em>T</em></code> corresponding to the
+<code class="sourceCode cpp"><em>template-argument-list</em></code> (if
+any) of the
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>.</p>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_163" id="pnum_163">(3.1)</a></span>
+If <code class="sourceCode cpp"><em>T</em></code> is a primary class
+template, the
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>
+designates <code class="sourceCode cpp"><em>S</em></code>.</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_164" id="pnum_164">(3.2)</a></span>
+Otherwise if <code class="sourceCode cpp"><em>T</em></code> is an alias
+template, the
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>
+designates the type denoted by
+<code class="sourceCode cpp"><em>S</em></code>.</li>
+</ul>
+</div>
+</blockquote>
+</div>
 <h3 class="unnumbered" id="dcl.init.general-initializers-general"><span>9.4.1 <a href="https://wg21.link/dcl.init.general">[dcl.init.general]</a></span>
 Initializers (General)<a href="#dcl.init.general-initializers-general" class="self-link"></a></h3>
 <p>Change paragraphs 6-8 of <span>9.4.1 <a href="https://wg21.link/dcl.init.general">[dcl.init.general]</a></span>
@@ -6555,45 +6900,45 @@ <h3 class="unnumbered" id="dcl.init.general-initializers-general"><span>9.4.1 <a
 zero-initialization for scalar types ]</span>:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_145" id="pnum_145">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_165" id="pnum_165">6</a></span>
 To <em>zero-initialize</em> an object or reference of type
 <code class="sourceCode cpp">T</code> means:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_146" id="pnum_146">(6.0)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_166" id="pnum_166">(6.0)</a></span>
 <span class="addu">if <code class="sourceCode cpp">T</code> is <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,
 the object is initialized to a null reflection value;</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_147" id="pnum_147">(6.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_167" id="pnum_167">(6.1)</a></span>
 if <code class="sourceCode cpp">T</code> is <span class="rm" style="color: #bf0303"><del>a</del></span> <span class="addu">any
 other</span> scalar type ([basic.types.general]), the object is
 initialized to the value obtained by converting the integer literal
 <code class="sourceCode cpp"><span class="dv">0</span></code> (zero) to
 <code class="sourceCode cpp">T</code>;</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_148" id="pnum_148">(6.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_168" id="pnum_168">(6.2)</a></span>
 […]</li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_149" id="pnum_149">7</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_169" id="pnum_169">7</a></span>
 To <em>default-initialize</em> an object of type
 <code class="sourceCode cpp">T</code> means:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_150" id="pnum_150">(7.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_170" id="pnum_170">(7.1)</a></span>
 If <code class="sourceCode cpp">T</code> is a (possibly cv-qualified)
 class type ([class]), […]</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_151" id="pnum_151">(7.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_171" id="pnum_171">(7.2)</a></span>
 If T is an array type, […]</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_152" id="pnum_152">(7.*)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_172" id="pnum_172">(7.*)</a></span>
 <span class="addu">If <code class="sourceCode cpp">T</code> is <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,
 the object is zero-initialized.</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_153" id="pnum_153">(7.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_173" id="pnum_173">(7.3)</a></span>
 Otherwise, no initialization is performed.</li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_154" id="pnum_154">8</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_174" id="pnum_174">8</a></span>
 A class type <code class="sourceCode cpp">T</code> is
 <em>const-default-constructible</em> if default-initialization of
 <code class="sourceCode cpp">T</code> would invoke a user-provided
 constructor of <code class="sourceCode cpp">T</code> (not inherited from
 a base class) or if</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_155" id="pnum_155">(8.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_175" id="pnum_175">(8.1)</a></span>
 […]</li>
 </ul>
 <p>If a program calls for the default-initialization of an object of a
@@ -6601,7 +6946,7 @@ <h3 class="unnumbered" id="dcl.init.general-initializers-general"><span>9.4.1 <a
 <code class="sourceCode cpp">T</code> shall be <span class="addu"><code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>
 or</span> a const-default-constructible <span class="rm" style="color: #bf0303"><del>class</del></span> type, or array
 thereof.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_156" id="pnum_156">9</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_176" id="pnum_176">9</a></span>
 To value-initialize an object of type T means: […]</p>
 </blockquote>
 </div>
@@ -6610,26 +6955,26 @@ <h3 class="unnumbered" id="dcl.fct-functions"><span>9.3.4.6 <a href="https://wg2
 reflections of abominable function types:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_157" id="pnum_157">9</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_177" id="pnum_177">9</a></span>
 A function type with a
 <code class="sourceCode cpp"><em>cv-qualifier-seq</em></code> or a
 <code class="sourceCode cpp"><em>ref-qualifier</em></code> (including a
 type named by <code class="sourceCode cpp"><em>typedef-name</em></code>
 ([dcl.typedef], [temp.param])) shall appear only as:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_158" id="pnum_158">(9.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_178" id="pnum_178">(9.1)</a></span>
 the function type for a non-static member function,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_159" id="pnum_159">(9.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_179" id="pnum_179">(9.2)</a></span>
 the function type to which a pointer to member refers,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_160" id="pnum_160">(9.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_180" id="pnum_180">(9.3)</a></span>
 the top-level function type of a function typedef declaration or
 <code class="sourceCode cpp"><em>alias-declaration</em></code>,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_161" id="pnum_161">(9.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_181" id="pnum_181">(9.4)</a></span>
 the <code class="sourceCode cpp"><em>type-id</em></code> in the default
 argument of a
 <code class="sourceCode cpp"><em>type-parameter</em></code>
 ([temp.param]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_162" id="pnum_162">(9.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_182" id="pnum_182">(9.5)</a></span>
 the <code class="sourceCode cpp"><em>type-id</em></code> of a
 <code class="sourceCode cpp"><em>template-argument</em></code> for a
 <code class="sourceCode cpp"><em>type-parameter</em></code>
@@ -6638,7 +6983,7 @@ <h3 class="unnumbered" id="dcl.fct-functions"><span>9.3.4.6 <a href="https://wg2
 </ul>
 <div class="addu">
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_163" id="pnum_163">(9.6)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_183" id="pnum_183">(9.6)</a></span>
 the operand of a
 <code class="sourceCode cpp"><em>reflect-expression</em></code>
 ([expr.reflect]).</li>
@@ -6652,10 +6997,11 @@ <h3 class="unnumbered" id="dcl.fct.def.delete-deleted-definitions"><span>9.5.3 <
 to allow for reflections of deleted functions:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_164" id="pnum_164">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_184" id="pnum_184">2</a></span>
 A program that refers to a deleted function implicitly or explicitly,
 other than to declare it <span class="addu">or to use as the operand of
-the reflection operator ([expr.reflect])</span>, is ill-formed.</p>
+a <code class="sourceCode cpp"><em>reflect-expression</em></code>
+([expr.reflect])</span>, is ill-formed.</p>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="enum.udecl-the-using-enum-declaration"><span>9.7.2 <a href="https://wg21.link/enum.udecl">[enum.udecl]</a></span> The <code class="sourceCode cpp"><span class="kw">using</span> <span class="kw">enum</span></code>
@@ -6666,33 +7012,36 @@ <h3 class="unnumbered" id="enum.udecl-the-using-enum-declaration"><span>9.7.2 <a
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb119"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb119-1"><a href="#cb119-1" aria-hidden="true" tabindex="-1"></a>  <em>using-enum-declaration</em>:</span>
-<span id="cb119-2"><a href="#cb119-2" aria-hidden="true" tabindex="-1"></a>     using enum <em>using-enum-declarator</em> ;</span>
-<span id="cb119-3"><a href="#cb119-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb119-4"><a href="#cb119-4" aria-hidden="true" tabindex="-1"></a>  <em>using-enum-declarator</em>:</span>
-<span id="cb119-5"><a href="#cb119-5" aria-hidden="true" tabindex="-1"></a>     <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>identifier</em></span>
-<span id="cb119-6"><a href="#cb119-6" aria-hidden="true" tabindex="-1"></a>     <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>simple-template-id</em></span>
-<span id="cb119-7"><a href="#cb119-7" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>splice-type-specifier</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb123"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb123-1"><a href="#cb123-1" aria-hidden="true" tabindex="-1"></a>  <em>using-enum-declaration</em>:</span>
+<span id="cb123-2"><a href="#cb123-2" aria-hidden="true" tabindex="-1"></a>     using enum <em>using-enum-declarator</em> ;</span>
+<span id="cb123-3"><a href="#cb123-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb123-4"><a href="#cb123-4" aria-hidden="true" tabindex="-1"></a>  <em>using-enum-declarator</em>:</span>
+<span id="cb123-5"><a href="#cb123-5" aria-hidden="true" tabindex="-1"></a>     <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>identifier</em></span>
+<span id="cb123-6"><a href="#cb123-6" aria-hidden="true" tabindex="-1"></a>     <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>simple-template-id</em></span>
+<span id="cb123-7"><a href="#cb123-7" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>splice-type-specifier</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
-<p>Modify paragraph 1 to handle splicers:</p>
+<p>Modify paragraph 1 to handle
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_165" id="pnum_165">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_185" id="pnum_185">1</a></span>
 <span class="addu">A
 <code class="sourceCode cpp"><em>using-enum-declarator</em></code> of
 the form
 <code class="sourceCode cpp"><em>splice-type-specifier</em></code> is a
 type-only context, and designates the same construct designated by the
-splicer. Any other</span> <span class="rm" style="color: #bf0303"><del>A</del></span>
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>. Any
+other</span> <span class="rm" style="color: #bf0303"><del>A</del></span>
 <code class="sourceCode cpp"><em>using-enum-declarator</em></code> names
 the set of declarations found by type-only lookup
 ([basic.lookup.general]) for the
 <code class="sourceCode cpp"><em>using-enum-declarator</em></code>
-([basic.lookup.unqual], [basic.lookup.qual]). The
-<code class="sourceCode cpp"><em>using-enum-declarator</em></code> shall
-designate a non-dependent type with a reachable
+(<span>6.5.3 <a href="https://wg21.link/basic.lookup.unqual">[basic.lookup.unqual]</a></span>,
+<span>6.5.5 <a href="https://wg21.link/basic.lookup.qual">[basic.lookup.qual]</a></span>).
+The <code class="sourceCode cpp"><em>using-enum-declarator</em></code>
+shall designate a non-dependent type with a reachable
 <code class="sourceCode cpp"><em>enum-specifier</em></code>.</p>
 </blockquote>
 </div>
@@ -6705,9 +7054,9 @@ <h3 class="unnumbered" id="namespace.alias-namespace-alias"><span>9.8.3
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb120"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb120-1"><a href="#cb120-1" aria-hidden="true" tabindex="-1"></a>  <em>namespace-alias-definition</em>:</span>
-<span id="cb120-2"><a href="#cb120-2" aria-hidden="true" tabindex="-1"></a>      namespace <em>identifier</em> = <em>qualified-namespace-specifier</em></span>
-<span id="cb120-3"><a href="#cb120-3" aria-hidden="true" tabindex="-1"></a><span class="va">+     namespace <em>identifier</em> = <em>splice-specifier</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb124"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb124-1"><a href="#cb124-1" aria-hidden="true" tabindex="-1"></a>  <em>namespace-alias-definition</em>:</span>
+<span id="cb124-2"><a href="#cb124-2" aria-hidden="true" tabindex="-1"></a>      namespace <em>identifier</em> = <em>qualified-namespace-specifier</em></span>
+<span id="cb124-3"><a href="#cb124-3" aria-hidden="true" tabindex="-1"></a><span class="va">+     namespace <em>identifier</em> = <em>splice-specifier</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -6715,11 +7064,11 @@ <h3 class="unnumbered" id="namespace.alias-namespace-alias"><span>9.8.3
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_166" id="pnum_166">0</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_186" id="pnum_186">0</a></span>
 A <code class="sourceCode cpp"><em>splice-specifier</em></code>
 appearing in a
 <code class="sourceCode cpp"><em>namespace-alias-definition</em></code>
-shall designate a namespace or
+shall designate a namespace or a
 <code class="sourceCode cpp"><em>namespace-alias</em></code>.</p>
 </div>
 </blockquote>
@@ -6728,7 +7077,7 @@ <h3 class="unnumbered" id="namespace.alias-namespace-alias"><span>9.8.3
 follows:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_167" id="pnum_167">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_187" id="pnum_187">2</a></span>
 The <code class="sourceCode cpp"><em>identifier</em></code> in a
 <code class="sourceCode cpp"><em>namespace-alias-definition</em></code>
 becomes a <code class="sourceCode cpp"><em>namespace-alias</em></code>
@@ -6746,9 +7095,9 @@ <h3 class="unnumbered" id="namespace.udir-using-namespace-directive"><span>9.8.4
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb121"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb121-1"><a href="#cb121-1" aria-hidden="true" tabindex="-1"></a>  <em>using-directive</em>:</span>
-<span id="cb121-2"><a href="#cb121-2" aria-hidden="true" tabindex="-1"></a>      <em>attribute-specifier-seq</em><sub><em>opt</em></sub> using namespace <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>namespace-name</em></span>
-<span id="cb121-3"><a href="#cb121-3" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>attribute-specifier-seq</em><sub><em>opt</em></sub> using namespace <em>splice-specifier</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb125"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb125-1"><a href="#cb125-1" aria-hidden="true" tabindex="-1"></a>  <em>using-directive</em>:</span>
+<span id="cb125-2"><a href="#cb125-2" aria-hidden="true" tabindex="-1"></a>      <em>attribute-specifier-seq</em><sub><em>opt</em></sub> using namespace <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>namespace-name</em></span>
+<span id="cb125-3"><a href="#cb125-3" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>attribute-specifier-seq</em><sub><em>opt</em></sub> using namespace <em>splice-specifier</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -6757,7 +7106,7 @@ <h3 class="unnumbered" id="namespace.udir-using-namespace-directive"><span>9.8.4
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_168" id="pnum_168">0</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_188" id="pnum_188">0</a></span>
 The <code class="sourceCode cpp"><em>splice-specifier</em></code>, if
 any, designates a namespace or
 <code class="sourceCode cpp"><em>namespace-alias</em></code>. The
@@ -6765,7 +7114,7 @@ <h3 class="unnumbered" id="namespace.udir-using-namespace-directive"><span>9.8.4
 the <code class="sourceCode cpp"><em>splice-specifier</em></code> shall
 not be dependent.</p>
 </div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_169" id="pnum_169">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_189" id="pnum_189">1</a></span>
 A <code class="sourceCode cpp"><em>using-directive</em></code> shall not
 appear in class scope, but may appear in namespace scope or in block
 scope.</p>
@@ -6804,10 +7153,10 @@ <h3 class="unnumbered" id="dcl.attr.grammar-attribute-syntax-and-semantics"><spa
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb122"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb122-1"><a href="#cb122-1" aria-hidden="true" tabindex="-1"></a>  <em>attribute-specifier</em>:</span>
-<span id="cb122-2"><a href="#cb122-2" aria-hidden="true" tabindex="-1"></a>     [ [ <em>attribute-using-prefix</em><sub><em>opt</em></sub> <em>attribute-list</em> ] ]</span>
-<span id="cb122-3"><a href="#cb122-3" aria-hidden="true" tabindex="-1"></a><span class="va">+    [ [ using <em>attribute-namespace</em> :] ]</span></span>
-<span id="cb122-4"><a href="#cb122-4" aria-hidden="true" tabindex="-1"></a>     <em>alignment-specifier</em></span></code></pre></div>
+<div class="sourceCode" id="cb126"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb126-1"><a href="#cb126-1" aria-hidden="true" tabindex="-1"></a>  <em>attribute-specifier</em>:</span>
+<span id="cb126-2"><a href="#cb126-2" aria-hidden="true" tabindex="-1"></a>     [ [ <em>attribute-using-prefix</em><sub><em>opt</em></sub> <em>attribute-list</em> ] ]</span>
+<span id="cb126-3"><a href="#cb126-3" aria-hidden="true" tabindex="-1"></a><span class="va">+    [ [ using <em>attribute-namespace</em> :] ]</span></span>
+<span id="cb126-4"><a href="#cb126-4" aria-hidden="true" tabindex="-1"></a>     <em>alignment-specifier</em></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -6815,13 +7164,13 @@ <h3 class="unnumbered" id="dcl.attr.grammar-attribute-syntax-and-semantics"><spa
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb123"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb123-1"><a href="#cb123-1" aria-hidden="true" tabindex="-1"></a>  <em>balanced-token</em> :</span>
-<span id="cb123-2"><a href="#cb123-2" aria-hidden="true" tabindex="-1"></a>      ( <em>balanced-token-seq</em><sub><em>opt</em></sub> )</span>
-<span id="cb123-3"><a href="#cb123-3" aria-hidden="true" tabindex="-1"></a>      [ <em>balanced-token-seq</em><sub><em>opt</em></sub> ]</span>
-<span id="cb123-4"><a href="#cb123-4" aria-hidden="true" tabindex="-1"></a>      { <em>balanced-token-seq</em><sub><em>opt</em></sub> }</span>
-<span id="cb123-5"><a href="#cb123-5" aria-hidden="true" tabindex="-1"></a><span class="st">-     any token other than a parenthesis, a bracket, or a brace</span></span>
-<span id="cb123-6"><a href="#cb123-6" aria-hidden="true" tabindex="-1"></a><span class="va">+     [: <em>balanced-token-seq</em><sub><em>opt</em></sub> :]</span></span>
-<span id="cb123-7"><a href="#cb123-7" aria-hidden="true" tabindex="-1"></a><span class="va">+     any token other than (, ), [, ], {, }, [:, or :]</span></span></code></pre></div>
+<div class="sourceCode" id="cb127"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb127-1"><a href="#cb127-1" aria-hidden="true" tabindex="-1"></a>  <em>balanced-token</em> :</span>
+<span id="cb127-2"><a href="#cb127-2" aria-hidden="true" tabindex="-1"></a>      ( <em>balanced-token-seq</em><sub><em>opt</em></sub> )</span>
+<span id="cb127-3"><a href="#cb127-3" aria-hidden="true" tabindex="-1"></a>      [ <em>balanced-token-seq</em><sub><em>opt</em></sub> ]</span>
+<span id="cb127-4"><a href="#cb127-4" aria-hidden="true" tabindex="-1"></a>      { <em>balanced-token-seq</em><sub><em>opt</em></sub> }</span>
+<span id="cb127-5"><a href="#cb127-5" aria-hidden="true" tabindex="-1"></a><span class="st">-     any token other than a parenthesis, a bracket, or a brace</span></span>
+<span id="cb127-6"><a href="#cb127-6" aria-hidden="true" tabindex="-1"></a><span class="va">+     [: <em>balanced-token-seq</em><sub><em>opt</em></sub> :]</span></span>
+<span id="cb127-7"><a href="#cb127-7" aria-hidden="true" tabindex="-1"></a><span class="va">+     any token other than (, ), [, ], {, }, [:, or :]</span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -6829,7 +7178,7 @@ <h3 class="unnumbered" id="dcl.attr.grammar-attribute-syntax-and-semantics"><spa
 as follows:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_170" id="pnum_170">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_190" id="pnum_190">4</a></span>
 […] An <code class="sourceCode cpp"><em>attribute-specifier</em></code>
 that contains no <code class="sourceCode cpp"><em>attribute</em></code>s
 <span class="addu">and no
@@ -6846,15 +7195,15 @@ <h3 class="unnumbered" id="dcl.attr.grammar-attribute-syntax-and-semantics"><spa
 — <em>end note</em> ]</span></span></span> …</p>
 </blockquote>
 </div>
-<h3 class="unnumbered" id="module.global.frag-global-module-fragment">[module.global.frag]
+<h3 class="unnumbered" id="module.global.frag-global-module-fragment"><span>10.4 <a href="https://wg21.link/module.global.frag">[module.global.frag]</a></span>
 Global module fragment<a href="#module.global.frag-global-module-fragment" class="self-link"></a></h3>
-<p>Extend the caveat in paragraph 3.7 to also apply to
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s.</p>
+<p>Specify in paragraph 3 that it is unspecified whether spliced types
+are replaced by their designated types, and renumber accordingly.</p>
 <div class="std">
 <blockquote>
 <p>In this determination, it is unspecified</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_171" id="pnum_171">(3.6)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_191" id="pnum_191">(3.6)</a></span>
 whether a reference to an
 <code class="sourceCode cpp"><em>alias-declaration</em></code>,
 <code class="sourceCode cpp"><span class="kw">typedef</span></code>
@@ -6863,16 +7212,21 @@ <h3 class="unnumbered" id="module.global.frag-global-module-fragment">[module.gl
 <code class="sourceCode cpp"><em>namespace-alias-definition</em></code>
 is replaced by the declarations they name prior to this
 determination,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_172" id="pnum_172">(3.7)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_192" id="pnum_192">(3.7)</a></span>
 whether a
 <code class="sourceCode cpp"><em>simple-template-id</em></code> that
 does not denote a dependent type and whose
-<code class="sourceCode cpp"><em>template-name</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>template-name</em></code> names an
+alias template is replaced by its denoted type prior to this
+determination,</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_193" id="pnum_193">(3.8)</a></span>
+whether a
+<code class="sourceCode cpp"><em>decltype-specifier</em></code> <span class="addu">or
 <code class="sourceCode cpp"><em>splice-type-specifier</em></code></span>
-<span class="rm" style="color: #bf0303"><del>names</del></span> <span class="addu">designates</span> an alias template is replaced by its
-denoted type prior to this determination,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_173" id="pnum_173">(3.8)</a></span>
-…</li>
+that does not <span class="rm" style="color: #bf0303"><del>denote</del></span> <span class="addu">designate</span> a dependent type is replaced by its <span class="rm" style="color: #bf0303"><del>denoted</del></span> <span class="addu">designated</span> type prior to this determination,</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_194" id="pnum_194">(3.9)</a></span>
+whether a non-value-dependent constant expression is replaced by the
+result of constant evaluation prior to this determination.</li>
 </ul>
 </blockquote>
 </div>
@@ -6882,66 +7236,31 @@ <h3 class="unnumbered" id="module.reach-reachability"><span>10.7 <a href="https:
 declarations:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_174" id="pnum_174">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_195" id="pnum_195">3</a></span>
 A declaration <code class="sourceCode cpp"><em>D</em></code> is
 <em>reachable from</em> a point
 <code class="sourceCode cpp"><em>P</em></code> if</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_175" id="pnum_175">(3.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_196" id="pnum_196">(3.1)</a></span>
 <span class="addu"><code class="sourceCode cpp"><em>P</em></code> is not
 an injected point and</span>
 <code class="sourceCode cpp"><em>D</em></code> appears prior to
 <code class="sourceCode cpp"><em>P</em></code> in the same translation
 unit, <span class="rm" style="color: #bf0303"><del>or</del></span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_176" id="pnum_176">(3.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_197" id="pnum_197">(3.2)</a></span>
 <span class="addu"><code class="sourceCode cpp"><em>D</em></code> is an
 injected declaration for which
 <code class="sourceCode cpp"><em>P</em></code> is the corresponding
 injected point, or</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_177" id="pnum_177">(3.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_198" id="pnum_198">(3.3)</a></span>
 <code class="sourceCode cpp"><em>D</em></code> is not discarded
-([module.global.frag]), appears in a translation unit that is reachable
-from <code class="sourceCode cpp"><em>P</em></code>, and does not appear
-within a <em>private-module-framgent</em>.</li>
+(<span>10.4 <a href="https://wg21.link/module.global.frag">[module.global.frag]</a></span>),
+appears in a translation unit that is reachable from
+<code class="sourceCode cpp"><em>P</em></code>, and does not appear
+within a <em>private-module-fragment</em>.</li>
 </ul>
 </blockquote>
 </div>
-<h3 class="unnumbered" id="class.pre-preamble">[class.pre] Preamble<a href="#class.pre-preamble" class="self-link"></a></h3>
-<p>Disallow splicers from appearing in a declaration of a
-<code class="sourceCode cpp"><em>class-name</em></code> in paragraph
-1.</p>
-<div class="std">
-<blockquote>
-<p>…</p>
-<p>A class declaration where the
-<code class="sourceCode cpp"><em>class-name</em></code> in the
-<code class="sourceCode cpp"><em>class-head-name</em></code> is a
-<code class="sourceCode cpp"><em>simple-template-id</em></code> shall be
-an explicit specialization ([temp.expl.spec]) or a partial
-specialization ([temp.spec.partial]). <span class="addu">The
-<code class="sourceCode cpp"><em>simple-template-id</em></code> shall
-not contain a splicer.</span> A
-<code class="sourceCode cpp"><em>class-specifier</em></code> whose
-<code class="sourceCode cpp"><em>class-head</em></code> omits the
-<code class="sourceCode cpp"><em>class-head-name</em></code> defines an
-<em>unnamed class</em>.</p>
-</blockquote>
-</div>
-<h3 class="unnumbered" id="class.name-class-names">[class.name] Class
-names<a href="#class.name-class-names" class="self-link"></a></h3>
-<p>Cover
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s in
-paragraph 5.</p>
-<div class="std">
-<blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_178" id="pnum_178">5</a></span>
-A <code class="sourceCode cpp"><em>simple-template-id</em></code> is
-only a <code class="sourceCode cpp"><em>class-name</em></code> if its
-<code class="sourceCode cpp"><em>template-name</em></code> <span class="addu">or
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code></span>
-<span class="rm" style="color: #bf0303"><del>names</del></span> <span class="addu">designates</span> a class template.</p>
-</blockquote>
-</div>
 <h3 class="unnumbered" id="class.mem.general-general"><span>11.4.1 <a href="https://wg21.link/class.mem.general">[class.mem.general]</a></span>
 General<a href="#class.mem.general-general" class="self-link"></a></h3>
 <p>Extend paragraph 5, and modify note 3, to clarify the existence of
@@ -6949,25 +7268,182 @@ <h3 class="unnumbered" id="class.mem.general-general"><span>11.4.1 <a href="http
 types.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_179" id="pnum_179">5</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_199" id="pnum_199">5</a></span>
 A data member or member function may be declared
 <code class="sourceCode cpp"><span class="kw">static</span></code> in
 its <em>member-declaration</em>, in which case it is a <em>static
-member</em> (see [class.static]) (a <em>static data member</em>
-([class.static.data]) or <em>static member function</em>
-([class.static.mfct]), respectively) of the class. Any other data member
-or member function is a <em>non-static member</em> (a <em>non-static
-data member</em> or <em>non-static member function</em>
-([class.mfct.non.static]), respectively). <span class="addu">For each
-non-static data member of reference type, there is a unique member
-subobject whose size and alignment is the same as if the data member
-were declared with the corresponding pointer type.</span></p>
+member</em> (see <span>11.4.9 <a href="https://wg21.link/class.static">[class.static]</a></span>) (a
+<em>static data member</em> (<span>11.4.9.3 <a href="https://wg21.link/class.static.data">[class.static.data]</a></span>)
+or <em>static member function</em> (<span>11.4.9.2 <a href="https://wg21.link/class.static.mfct">[class.static.mfct]</a></span>),
+respectively) of the class. Any other data member or member function is
+a <em>non-static member</em> (a <em>non-static data member</em> or
+<em>non-static member function</em> (<span>11.4.3 <a href="https://wg21.link/class.mfct.non.static">[class.mfct.non.static]</a></span>),
+respectively). <span class="addu">For each non-static data member of
+reference type, there is a unique member subobject whose size and
+alignment is the same as if the data member were declared with the
+corresponding pointer type.</span></p>
 <p><span class="note3"><span>[ <em>Note 3:</em> </span><span class="rm" style="color: #bf0303"><del>A non-static data member of non-reference
 type is a member subobject of a class object.</del></span> <span class="addu">An object of class type has a member subobject
-corresponding to each non-static data member of its class</span><span>
+corresponding to each non-static data member of its class.</span><span>
 — <em>end note</em> ]</span></span></p>
 </blockquote>
 </div>
+<h3 class="unnumbered" id="over.pre-preamble">[over.pre] Preamble<a href="#over.pre-preamble" class="self-link"></a></h3>
+<p>Move the definition “overload set” from <span>6.5 <a href="https://wg21.link/basic.lookup">[basic.lookup]</a></span> to
+paragraph 2, rewrite the preamble to better describe overload
+resolution, and add a note explaining the expressions that form overload
+sets.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_200" id="pnum_200">2</a></span>
+<span class="addu">An <em>overload set</em> is a set of declarations
+that each denote a function or function template.</span> <span class="rm" style="color: #bf0303"><del>When a function is named in a
+call, which function declaration is being referenced and the validity of
+the call are determined</del></span> <span class="addu">The process of
+<em>overload resolution</em> determines the identity of a function and
+its validity in a context</span> by comparing the types of the arguments
+at <span class="rm" style="color: #bf0303"><del>the</del></span> <span class="addu">a</span> point of use with the types of the parameters in
+<span class="rm" style="color: #bf0303"><del>the</del></span> <span class="addu">candidate functions derived from</span> <span class="rm" style="color: #bf0303"><del>declarations in</del></span> the <span class="addu">initial</span> overload set. <span class="rm" style="color: #bf0303"><del>This function selection process is called
+<em>overload resolution</em> and</del></span> <span class="addu">Overload resolution</span> is defined in [over.match].</p>
+<p><span class="addu"><span class="note"><span>[ <em>Note 1:</em>
+</span>Overload sets are formed by
+<code class="sourceCode cpp"><em>id-expression</em></code>s naming
+functions and function templates and by
+<code class="sourceCode cpp"><em>splice-expression</em></code>s that
+designate entities of the same kinds.<span> — <em>end
+note</em> ]</span></span></span></p>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="over.match.general-general"><span>12.2.1 <a href="https://wg21.link/over.match.general">[over.match.general]</a></span>
+General<a href="#over.match.general-general" class="self-link"></a></h3>
+<p>Modify paragraphs 3 and 4 to clarify that access rules do not apply
+in all contexts.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_201" id="pnum_201">3</a></span>
+If a best viable function exists and is unique, overload resolution
+succeeds and produces it as the result. Otherwise overload resolution
+fails and the invocation is ill-formed. When overload resolution
+succeeds, and the best viable function is <span class="rm" style="color: #bf0303"><del>not</del></span> <span class="addu">neither
+designated in a manner exempt from access rules nor</span> accessible in
+the context in which it is used, the program is ill-formed.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_202" id="pnum_202">4</a></span>
+Overload resolution results in a <em>usable candidate</em> if overload
+resolution succeeds and the selected candidate is either not a function
+(<span>12.5 <a href="https://wg21.link/over.built">[over.built]</a></span>), or is a
+function that is not deleted and is <span class="addu">either designated
+in a manner exempt from access rules or is</span> accessible from the
+context in which overload resolution was performed.</p>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="over.call.func-call-to-named-function"><span>12.2.2.2.2 <a href="https://wg21.link/over.call.func">[over.call.func]</a></span> Call
+to named function<a href="#over.call.func-call-to-named-function" class="self-link"></a></h3>
+<p>Modify paragraph 1 to clarify that this section will also apply to
+splices of function templates.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_203" id="pnum_203">1</a></span>
+Of interest in [over.call.func] are <span class="rm" style="color: #bf0303"><del>only</del></span> those function calls in
+which the <code class="sourceCode cpp"><em>posfix-expression</em></code>
+ultimately contains an
+<code class="sourceCode cpp"><em>id-expression</em></code> that denotes
+one or more functions <span class="addu">or a
+<code class="sourceCode cpp"><em>splice-expression</em></code> that
+designates a function template</span>. Such a
+<code class="sourceCode cpp"><em>postfix-expression</em></code>, perhaps
+nested arbitrarily deep in parentheses, has one of the following
+forms:</p>
+<div>
+<div class="sourceCode" id="cb128"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb128-1"><a href="#cb128-1" aria-hidden="true" tabindex="-1"></a>  <em>postfix-expression</em>:</span>
+<span id="cb128-2"><a href="#cb128-2" aria-hidden="true" tabindex="-1"></a>     <em>postfix-expression</em> . <em>id-expression</em></span>
+<span id="cb128-3"><a href="#cb128-3" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>postfix-expression</em> . <em>splice-expression</em></span></span>
+<span id="cb128-4"><a href="#cb128-4" aria-hidden="true" tabindex="-1"></a>     <em>postfix-expression</em> -&gt; <em>id-expression</em></span>
+<span id="cb128-5"><a href="#cb128-5" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>postfix-expression</em> -&gt; <em>splice-expression</em></span></span>
+<span id="cb128-6"><a href="#cb128-6" aria-hidden="true" tabindex="-1"></a>     <em>primary-expression</em></span></code></pre></div>
+</div>
+<p>These represent two syntactic subcategories of function calls:
+qualified function calls and unqualified function calls.</p>
+</blockquote>
+</div>
+<p>Modify paragraph 2 to account for overload resolution of
+<code class="sourceCode cpp"><em>splice-expression</em></code>s
+designating member function templates.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_204" id="pnum_204">2</a></span>
+In qualified function calls, the function is <span class="rm" style="color: #bf0303"><del>named</del></span> <span class="addu">designated</span> by an
+<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-expression</em></code></span>
+preceded by an
+<code class="sourceCode cpp"><span class="op">-&gt;</span></code> or
+<code class="sourceCode cpp"><span class="op">.</span></code> operator.
+Since the construct
+<code class="sourceCode cpp">A<span class="op">-&gt;</span>B</code> is
+generally equivalent to <code class="sourceCode cpp"><span class="op">(*</span>A<span class="op">).</span>B</code>,
+the rest of [over] assumes, without loss of generality, that all member
+function calls have been normalized to the form that uses an object and
+the <code class="sourceCode cpp"><span class="op">.</span></code>
+operator. Furthermore, [over] assumes that the
+<code class="sourceCode cpp"><em>postfix-expression</em></code> that is
+the left operand of the
+<code class="sourceCode cpp"><span class="op">.</span></code> operator
+has type “<em>cv</em> <code class="sourceCode cpp">T</code>” where
+<code class="sourceCode cpp">T</code> denotes a class.<sup>102</sup> The
+<span class="addu">set of</span> function declarations <span class="addu">constituting the candidate functions is</span> found by
+name lookup (<span>6.5.2 <a href="https://wg21.link/class.member.lookup">[class.member.lookup]</a></span>)
+<span class="addu">if the
+<code class="sourceCode cpp"><span class="op">.</span></code> is
+followed by an
+<code class="sourceCode cpp"><em>id-expression</em></code> and is
+otherwise the singleton containing the function template designated by
+the
+<code class="sourceCode cpp"><em>splice-expression</em></code></span>
+<span class="rm" style="color: #bf0303"><del>constitute the set of
+candidate functions</del></span>. The argument list is the
+<code class="sourceCode cpp"><em>expression-list</em></code> in the call
+augmented by the addition of the left operand of the
+<code class="sourceCode cpp"><span class="op">.</span></code> operator
+in the normalized member function call as the implied object argument
+(<span>12.2.2 <a href="https://wg21.link/over.match.funcs">[over.match.funcs]</a></span>).</p>
+</blockquote>
+</div>
+<p>Modify paragraph 3 to account for overload resolution of
+<code class="sourceCode cpp"><em>splice-expression</em></code>s
+designating non-member function templates.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_205" id="pnum_205">3</a></span>
+In unqualified function calls, the function is named by a
+<code class="sourceCode cpp"><em>primary-expression</em></code>. <span class="addu">If that
+<code class="sourceCode cpp"><em>primary-expression</em></code> is a
+<code class="sourceCode cpp"><em>splice-expression</em></code>, then the
+set of function declarations constituting the candidate functions is the
+singleton containing the function template designated by that
+<code class="sourceCode cpp"><em>splice-expression</em></code>. For all
+other cases, the</span> <span class="rm" style="color: #bf0303"><del>The</del></span> function declarations found
+by name lookup (<span>6.5 <a href="https://wg21.link/basic.lookup">[basic.lookup]</a></span>)
+constitute the set of candidate functions. Because of the rules for name
+lookup, the set of candidate functions consists either entirely of
+non-member functions or entirely of member functions of some class
+<code class="sourceCode cpp">T</code>. In the former case or if the
+<code class="sourceCode cpp"><em>primary-expression</em></code> is <span class="addu">a
+<code class="sourceCode cpp"><em>splice-expression</em></code> or</span>
+the address of an overload set, the argument list is the same as the
+<code class="sourceCode cpp"><em>expression-list</em></code> in the
+call. Otherwise, the argument list is the
+<code class="sourceCode cpp"><em>expression-list</em></code> in the call
+augmented by the addition of an implied function argument as in a
+qualified function call. If the current class is, or is derived from,
+<code class="sourceCode cpp">T</code>, and the keyword
+<code class="sourceCode cpp"><span class="kw">this</span></code>
+(<span>7.5.2 <a href="https://wg21.link/expr.prim.this">[expr.prim.this]</a></span>)
+refers to it, then the implied object argument is <code class="sourceCode cpp"><span class="op">(*</span><span class="kw">this</span><span class="op">)</span></code>.
+Otherwise, a contrived object of type
+<code class="sourceCode cpp">T</code> becomes the implied object
+argument;<sup>103</sup> if overload resolution selects a non-static
+member function, the call is ill-formed.</p>
+</blockquote>
+</div>
 <h3 class="unnumbered" id="over.match.class.deduct-class-template-argument-deduction"><span>12.2.2.9
 <a href="https://wg21.link/over.match.class.deduct">[over.match.class.deduct]</a></span>
 Class template argument deduction<a href="#over.match.class.deduct-class-template-argument-deduction" class="self-link"></a></h3>
@@ -6975,17 +7451,17 @@ <h3 class="unnumbered" id="over.match.class.deduct-class-template-argument-deduc
 <code class="sourceCode cpp"><em>splice-type-specifier</em></code>s.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_180" id="pnum_180">1</a></span>
-When resolving a placeholder for a deduced class type
-([dcl.type.class.deduct]) where the
-<code class="sourceCode cpp"><em>template-name</em></code> <span class="addu">or
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_206" id="pnum_206">1</a></span>
+When resolving a placeholder for a deduced class type (<span>9.2.9.8 <a href="https://wg21.link/dcl.type.class.deduct">[dcl.type.class.deduct]</a></span>)
+where the <code class="sourceCode cpp"><em>template-name</em></code>
+<span class="addu">or
 <code class="sourceCode cpp"><em>splice-type-specifier</em></code></span>
 <span class="rm" style="color: #bf0303"><del>names</del></span> <span class="addu">designates</span> a primary class template
 <code class="sourceCode cpp">C</code>, a set of functions and function
 templates, called the guides of <code class="sourceCode cpp">C</code>,
 is formed comprising:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_181" id="pnum_181">(1.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_207" id="pnum_207">(1.1)</a></span>
 …</li>
 </ul>
 </blockquote>
@@ -6994,19 +7470,19 @@ <h3 class="unnumbered" id="over.match.class.deduct-class-template-argument-deduc
 <code class="sourceCode cpp"><em>splice-type-specifier</em></code>s.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_182" id="pnum_182">3</a></span>
-When resolving a placeholder for a deduced class type
-([dcl.type.simple]) where the
-<code class="sourceCode cpp"><em>template-name</em></code> <span class="addu">or
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_208" id="pnum_208">3</a></span>
+When resolving a placeholder for a deduced class type (<span>9.2.9.3 <a href="https://wg21.link/dcl.type.simple">[dcl.type.simple]</a></span>)
+where the <code class="sourceCode cpp"><em>template-name</em></code>
+<span class="addu">or
 <code class="sourceCode cpp"><em>splice-type-specifier</em></code></span>
 <span class="rm" style="color: #bf0303"><del>names</del></span> <span class="addu">designates</span> an alias template
 <code class="sourceCode cpp">A</code>, the
 <code class="sourceCode cpp"><em>defining-type-id</em></code> of
 <code class="sourceCode cpp">A</code> must be of the form</p>
-<div class="sourceCode" id="cb124"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb124-1"><a href="#cb124-1" aria-hidden="true" tabindex="-1"></a>typename<sub><em>opt</em></sub> <em>nested-name-specifier</em><sub><em>opt</em></sub> template<sub><em>opt</em></sub> <em>simple-template-id</em></span></code></pre></div>
-<p>as specified in [dcl.type.simple]. The guides of
-<code class="sourceCode cpp">A</code> are the set of functions or
-function templates formed as follows. …</p>
+<div class="sourceCode" id="cb129"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb129-1"><a href="#cb129-1" aria-hidden="true" tabindex="-1"></a>typename<sub><em>opt</em></sub> <em>nested-name-specifier</em><sub><em>opt</em></sub> template<sub><em>opt</em></sub> <em>simple-template-id</em></span></code></pre></div>
+<p>as specified in <span>9.2.9.3 <a href="https://wg21.link/dcl.type.simple">[dcl.type.simple]</a></span>.
+The guides of <code class="sourceCode cpp">A</code> are the set of
+functions or function templates formed as follows. …</p>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="over.built-built-in-operators"><span>12.5 <a href="https://wg21.link/over.built">[over.built]</a></span> Built-in
@@ -7015,13 +7491,13 @@ <h3 class="unnumbered" id="over.built-built-in-operators"><span>12.5 <a href="ht
 to <span>12.5 <a href="https://wg21.link/over.built">[over.built]</a></span>:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_183" id="pnum_183">16</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_209" id="pnum_209">16</a></span>
 For every <code class="sourceCode cpp">T</code>, where
 <code class="sourceCode cpp">T</code> is a pointer-to-member type<span class="addu">, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,</span>
 or <code class="sourceCode cpp">std<span class="op">::</span>nullptr_t</code>,
 there exist candidate operator functions of the form</p>
-<div class="sourceCode" id="cb125"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb125-1"><a href="#cb125-1" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>T, T<span class="op">)</span>;</span>
-<span id="cb125-2"><a href="#cb125-2" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">!=(</span>T, T<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb130"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb130-1"><a href="#cb130-1" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>T, T<span class="op">)</span>;</span>
+<span id="cb130-2"><a href="#cb130-2" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">!=(</span>T, T<span class="op">)</span>;</span></code></pre></div>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="temp.param-template-parameters"><span>13.2 <a href="https://wg21.link/temp.param">[temp.param]</a></span> Template
@@ -7032,19 +7508,20 @@ <h3 class="unnumbered" id="temp.param-template-parameters"><span>13.2 <a href="h
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb126"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb126-1"><a href="#cb126-1" aria-hidden="true" tabindex="-1"></a>  <em>type-constraint</em>:</span>
-<span id="cb126-2"><a href="#cb126-2" aria-hidden="true" tabindex="-1"></a>      <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>concept-name</em></span>
-<span id="cb126-3"><a href="#cb126-3" aria-hidden="true" tabindex="-1"></a>      <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>concept-name</em> &lt; <em>template-argument-list</em><sub><em>opt</em></sub>&gt;</span>
-<span id="cb126-4"><a href="#cb126-4" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-type-specifier</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb131"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb131-1"><a href="#cb131-1" aria-hidden="true" tabindex="-1"></a>  <em>type-constraint</em>:</span>
+<span id="cb131-2"><a href="#cb131-2" aria-hidden="true" tabindex="-1"></a>      <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>concept-name</em></span>
+<span id="cb131-3"><a href="#cb131-3" aria-hidden="true" tabindex="-1"></a>      <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>concept-name</em> &lt; <em>template-argument-list</em><sub><em>opt</em></sub>&gt;</span>
+<span id="cb131-4"><a href="#cb131-4" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-type-specifier</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
-<p>Add a paragraph after paragraph 3 to restrict the type splicers that
-form <code class="sourceCode cpp"><em>type-constraint</em></code>s.</p>
+<p>Add a paragraph after paragraph 3 to restrict which
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s form
+<code class="sourceCode cpp"><em>type-constraint</em></code>s.</p>
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_184" id="pnum_184">3+</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_210" id="pnum_210">3+</a></span>
 A non-dependent
 <code class="sourceCode cpp"><em>splice-type-specifier</em></code> only
 forms a <code class="sourceCode cpp"><em>type-constraint</em></code>
@@ -7058,88 +7535,54 @@ <h3 class="unnumbered" id="temp.param-template-parameters"><span>13.2 <a href="h
 </div>
 <h3 class="unnumbered" id="temp.names-names-of-template-specializations"><span>13.3 <a href="https://wg21.link/temp.names">[temp.names]</a></span> Names of
 template specializations<a href="#temp.names-names-of-template-specializations" class="self-link"></a></h3>
-<p>Extend
-<code class="sourceCode cpp"><em>simple-template-id</em></code> and
-<code class="sourceCode cpp"><em>template-argument</em></code> to
-leverage splicers.</p>
+<p>Define the term
+<code class="sourceCode cpp"><em>splice-template-argument</em></code>,
+and add it as a production for
+<code class="sourceCode cpp"><em>template-argument</em></code>.</p>
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb127"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb127-1"><a href="#cb127-1" aria-hidden="true" tabindex="-1"></a>  <em>simple-template-id</em>:</span>
-<span id="cb127-2"><a href="#cb127-2" aria-hidden="true" tabindex="-1"></a>      <em>template-name</em> &lt; <em>template-argument-list</em><sub><em>opt</em></sub> &gt;</span>
-<span id="cb127-3"><a href="#cb127-3" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-expr-template-specifier</em> &lt; <em>template-argument-list</em><sub><em>opt</em></sub> &gt;</span></span>
-<span id="cb127-4"><a href="#cb127-4" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-type-specifier</em> &lt; <em>template-argument-list</em><sub><em>opt</em></sub> &gt;</span></span>
-<span id="cb127-5"><a href="#cb127-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb127-6"><a href="#cb127-6" aria-hidden="true" tabindex="-1"></a>  <em>template-id</em>:</span>
-<span id="cb127-7"><a href="#cb127-7" aria-hidden="true" tabindex="-1"></a>      <em>simple-template-id</em></span>
-<span id="cb127-8"><a href="#cb127-8" aria-hidden="true" tabindex="-1"></a>      $operator-function-id &lt; <em>template-argument-list</em><sub><em>opt</em></sub> &gt;</span>
-<span id="cb127-9"><a href="#cb127-9" aria-hidden="true" tabindex="-1"></a>      $literal-operator-id &lt; <em>template-argument-list</em><sub><em>opt</em></sub> &gt;</span>
-<span id="cb127-10"><a href="#cb127-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb127-11"><a href="#cb127-11" aria-hidden="true" tabindex="-1"></a>  <em>template-name</em>:</span>
-<span id="cb127-12"><a href="#cb127-12" aria-hidden="true" tabindex="-1"></a>      identifier</span>
-<span id="cb127-13"><a href="#cb127-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb127-14"><a href="#cb127-14" aria-hidden="true" tabindex="-1"></a>  <em>template-argument-list</em>:</span>
-<span id="cb127-15"><a href="#cb127-15" aria-hidden="true" tabindex="-1"></a>      <em>template-argument</em> ...<sub><em>opt</em></sub></span>
-<span id="cb127-16"><a href="#cb127-16" aria-hidden="true" tabindex="-1"></a>      <em>template-argument-list</em> , <em>template-argument</em> ...<sub><em>opt</em></sub></span>
-<span id="cb127-17"><a href="#cb127-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb127-18"><a href="#cb127-18" aria-hidden="true" tabindex="-1"></a>  <em>template-argument</em>:</span>
-<span id="cb127-19"><a href="#cb127-19" aria-hidden="true" tabindex="-1"></a>      <em>constant-expression</em></span>
-<span id="cb127-20"><a href="#cb127-20" aria-hidden="true" tabindex="-1"></a>      <em>type-id</em></span>
-<span id="cb127-21"><a href="#cb127-21" aria-hidden="true" tabindex="-1"></a>      <em>id-expression</em></span>
-<span id="cb127-22"><a href="#cb127-22" aria-hidden="true" tabindex="-1"></a>      <em>braced-init-list</em></span>
-<span id="cb127-23"><a href="#cb127-23" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-specifier</em></span></span></code></pre></div>
-</div>
-</blockquote>
-</div>
-<p>Extend paragraph 2 to cover
-<code class="sourceCode cpp"><em>simple-template-id</em></code>s and
-<code class="sourceCode cpp"><em>template-id</em></code>s that have no
-component name.</p>
-<div class="std">
-<blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_185" id="pnum_185">2</a></span>
-The component name of a <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default"><em>simple-template-id</em></code></span>,
-<span><code class="sourceCode default"><em>template-id</em></code></span>,
-or</del></span>
-<code class="sourceCode cpp"><em>template-name</em></code> is its
-<code class="sourceCode cpp"><em>identifier</em></code> <span class="rm" style="color: #bf0303"><del>the first name in it</del></span>. <span class="addu">The component names of a
-<code class="sourceCode cpp"><em>simple-template-id</em></code> are
-those of its <code class="sourceCode cpp"><em>template-name</em></code>
-(if any). The component names of a
-<code class="sourceCode cpp"><em>template-id</em></code> are those of
-its <code class="sourceCode cpp"><em>simple-template-id</em></code>,
-<code class="sourceCode cpp"><em>operator-function-id</em></code>, or
-<code class="sourceCode cpp"><em>literal-operator-id</em></code>.</span></p>
+<div class="sourceCode" id="cb132"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb132-1"><a href="#cb132-1" aria-hidden="true" tabindex="-1"></a>  <em>template-argument</em>:</span>
+<span id="cb132-2"><a href="#cb132-2" aria-hidden="true" tabindex="-1"></a>      <em>constant-expression</em></span>
+<span id="cb132-3"><a href="#cb132-3" aria-hidden="true" tabindex="-1"></a>      <em>type-id</em></span>
+<span id="cb132-4"><a href="#cb132-4" aria-hidden="true" tabindex="-1"></a>      <em>id-expression</em></span>
+<span id="cb132-5"><a href="#cb132-5" aria-hidden="true" tabindex="-1"></a>      <em>braced-init-list</em></span>
+<span id="cb132-6"><a href="#cb132-6" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-template-argument</em></span></span>
+<span id="cb132-7"><a href="#cb132-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-8"><a href="#cb132-8" aria-hidden="true" tabindex="-1"></a><span class="va">+ <em>splice-template-argument</em>:</span></span>
+<span id="cb132-9"><a href="#cb132-9" aria-hidden="true" tabindex="-1"></a><span class="va">+     <em>splice-specifier</em></span></span></code></pre></div>
+</div>
 </blockquote>
 </div>
 <p>Extend and re-format paragraph 3 of <span>13.3 <a href="https://wg21.link/temp.names">[temp.names]</a></span>:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_186" id="pnum_186">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_211" id="pnum_211">3</a></span>
 A <code class="sourceCode cpp"><span class="op">&lt;</span></code> is
 interpreted as the delimiter of a
 <code class="sourceCode cpp"><em>template-argument-list</em></code> if
-it follows <span class="addu">either</span></p>
+it follows</p>
 <ul>
-<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_187" id="pnum_187">(3.1)</a></span>
-a
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>
-or <code class="sourceCode cpp"><em>splice-type-specifier</em></code>,
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_212" id="pnum_212">(3.1)</a></span>
+a <code class="sourceCode cpp"><em>splice-specifier</em></code> that
+either appears in a type-only context or is preceded by
+<code class="sourceCode cpp"><span class="kw">template</span></code> or
+<code class="sourceCode cpp"><span class="kw">typename</span></code>,
 or</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_188" id="pnum_188">(3.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_213" id="pnum_213">(3.2)</a></span>
 a name that is not a
 <code class="sourceCode cpp"><em>conversion-function-id</em></code> and
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_189" id="pnum_189">(3.2.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_214" id="pnum_214">(3.2.1)</a></span>
 that follows the keyword template or a ~ after a nested-name-specifier
 or in a class member access expression, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_190" id="pnum_190">(3.2.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_215" id="pnum_215">(3.2.2)</a></span>
 for which name lookup finds the injected-class-name of a class template
 or finds any declaration of a template, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_191" id="pnum_191">(3.2.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_216" id="pnum_216">(3.2.3)</a></span>
 that is an unqualified name for which name lookup either finds one or
 more functions or finds nothing, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_192" id="pnum_192">(3.2.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_217" id="pnum_217">(3.2.4)</a></span>
 that is a terminal name in a using-declarator ([namespace.udecl]), in a
 declarator-id ([dcl.meaning]), or in a type-only context other than a
 nested-name-specifier ([temp.res]).</li>
@@ -7148,81 +7591,174 @@ <h3 class="unnumbered" id="temp.names-names-of-template-specializations"><span>1
 <p><span class="note"><span>[ <em>Note 1:</em> </span>If the name is an
 identifier, it is then interpreted as a <em>template-name</em>. The
 keyword template is used to indicate that a dependent qualified name
-([temp.dep.type]) denotes a template where an expression might
-appear.<span> — <em>end note</em> ]</span></span></p>
+(<span>13.8.3.2 <a href="https://wg21.link/temp.dep.type">[temp.dep.type]</a></span>)
+denotes a template where an expression might appear.<span> — <em>end
+note</em> ]</span></span></p>
 <div class="example">
 <span>[ <em>Example 1:</em> </span>
 <div>
-<div class="sourceCode" id="cb128"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb128-1"><a href="#cb128-1" aria-hidden="true" tabindex="-1"></a>struct X {</span>
-<span id="cb128-2"><a href="#cb128-2" aria-hidden="true" tabindex="-1"></a>  template&lt;std::size_t&gt; X* alloc();</span>
-<span id="cb128-3"><a href="#cb128-3" aria-hidden="true" tabindex="-1"></a>  template&lt;std::size_t&gt; static X* adjust();</span>
-<span id="cb128-4"><a href="#cb128-4" aria-hidden="true" tabindex="-1"></a>};</span>
-<span id="cb128-5"><a href="#cb128-5" aria-hidden="true" tabindex="-1"></a>template&lt;class T&gt; void f(T* p) {</span>
-<span id="cb128-6"><a href="#cb128-6" aria-hidden="true" tabindex="-1"></a>  T* p1 = p-&gt;alloc&lt;200&gt;();              // error: &lt; means less than</span>
-<span id="cb128-7"><a href="#cb128-7" aria-hidden="true" tabindex="-1"></a>  T* p2 = p-&gt;template alloc&lt;200&gt;();     // OK, &lt; starts template argument list</span>
-<span id="cb128-8"><a href="#cb128-8" aria-hidden="true" tabindex="-1"></a>  T::adjust&lt;100&gt;();                     // error: &lt; means less than</span>
-<span id="cb128-9"><a href="#cb128-9" aria-hidden="true" tabindex="-1"></a>  T::template adjust&lt;100&gt;();            // OK, &lt; starts template argument list</span>
-<span id="cb128-10"><a href="#cb128-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-11"><a href="#cb128-11" aria-hidden="true" tabindex="-1"></a><span class="va">+ static constexpr auto r = ^^T::adjust;</span></span>
-<span id="cb128-12"><a href="#cb128-12" aria-hidden="true" tabindex="-1"></a><span class="va">+ T* p3 = [:r:]&lt;200&gt;();                 // error: &lt; means less than</span></span>
-<span id="cb128-13"><a href="#cb128-13" aria-hidden="true" tabindex="-1"></a><span class="va">+ T* p4 = template [:r:]&lt;200&gt;();        // OK, &lt; starts template argument list</span></span>
-<span id="cb128-14"><a href="#cb128-14" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
+<div class="sourceCode" id="cb133"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb133-1"><a href="#cb133-1" aria-hidden="true" tabindex="-1"></a>struct X {</span>
+<span id="cb133-2"><a href="#cb133-2" aria-hidden="true" tabindex="-1"></a>  template&lt;std::size_t&gt; X* alloc();</span>
+<span id="cb133-3"><a href="#cb133-3" aria-hidden="true" tabindex="-1"></a>  template&lt;std::size_t&gt; static X* adjust();</span>
+<span id="cb133-4"><a href="#cb133-4" aria-hidden="true" tabindex="-1"></a>};</span>
+<span id="cb133-5"><a href="#cb133-5" aria-hidden="true" tabindex="-1"></a>template&lt;class T&gt; void f(T* p) {</span>
+<span id="cb133-6"><a href="#cb133-6" aria-hidden="true" tabindex="-1"></a>  T* p1 = p-&gt;alloc&lt;200&gt;();              // error: &lt; means less than</span>
+<span id="cb133-7"><a href="#cb133-7" aria-hidden="true" tabindex="-1"></a>  T* p2 = p-&gt;template alloc&lt;200&gt;();     // OK, &lt; starts template argument list</span>
+<span id="cb133-8"><a href="#cb133-8" aria-hidden="true" tabindex="-1"></a>  T::adjust&lt;100&gt;();                     // error: &lt; means less than</span>
+<span id="cb133-9"><a href="#cb133-9" aria-hidden="true" tabindex="-1"></a>  T::template adjust&lt;100&gt;();            // OK, &lt; starts template argument list</span>
+<span id="cb133-10"><a href="#cb133-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb133-11"><a href="#cb133-11" aria-hidden="true" tabindex="-1"></a><span class="va">+ static constexpr auto r = ^^T::adjust;</span></span>
+<span id="cb133-12"><a href="#cb133-12" aria-hidden="true" tabindex="-1"></a><span class="va">+ T* p3 = [:r:]&lt;200&gt;();                 // error: &lt; means less than</span></span>
+<span id="cb133-13"><a href="#cb133-13" aria-hidden="true" tabindex="-1"></a><span class="va">+ T* p4 = template [:r:]&lt;200&gt;();        // OK, &lt; starts template argument list</span></span>
+<span id="cb133-14"><a href="#cb133-14" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
 </div>
 <span> — <em>end example</em> ]</span>
 </div>
 </blockquote>
 </div>
-<p>Extend paragraph 8 to also cover
-<code class="sourceCode cpp"><em>simple-template-id</em></code>s
-containing
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>s.</p>
+<p>Clarify that the
+<code class="sourceCode cpp"><span class="op">&gt;</span></code>
+disambiguation in paragraph 4 also applies to the parsing of
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s:</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_218" id="pnum_218">4</a></span>
+When parsing a
+<code class="sourceCode cpp"><em>template-argument-list</em></code>, the
+first non-nested
+<code class="sourceCode cpp"><span class="op">&gt;</span></code><sup>111</sup>
+is taken as the ending delimiter rather than a greater-than operator.
+Similarly, the first non-nested
+<code class="sourceCode cpp"><span class="op">&gt;&gt;</span></code> is
+treated as two consecutive but distinct
+<code class="sourceCode cpp"><span class="op">&gt;</span></code> tokens,
+the first of which is taken as the end of the
+<code class="sourceCode cpp"><em>template-argument-list</em></code> and
+completes the <code class="sourceCode cpp"><em>template-id</em></code>
+<span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>.</p>
+<p><span class="note"><span>[ <em>Note 2:</em> </span>The second
+<code class="sourceCode cpp"><span class="op">&gt;</span></code> token
+produced by this replacement rule can terminate an enclosing
+<code class="sourceCode cpp"><em>template-id</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+construct or it can be part of a different construct (e.g., a
+cast).<span> — <em>end note</em> ]</span></span></p>
+</blockquote>
+</div>
+<p>Extend the definition of a <em>valid</em>
+<code class="sourceCode cpp"><em>template-id</em></code> to also cover
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s:</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_219" id="pnum_219">7</a></span>
+A <code class="sourceCode cpp"><em>template-id</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+is <em>valid</em> if</p>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_220" id="pnum_220">(7.1)</a></span>
+there are at most as many arguments as there are parameters or a
+parameter is a template parameter pack (<span>13.7.4 <a href="https://wg21.link/temp.variadic">[temp.variadic]</a></span>),</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_221" id="pnum_221">(7.2)</a></span>
+there is an argument for each non-deducible non-pack parameter that does
+not have a default
+<code class="sourceCode cpp"><em>template-argument</em></code>,</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_222" id="pnum_222">(7.3)</a></span>
+each <code class="sourceCode cpp"><em>template-argument</em></code>
+matches the corresponding
+<code class="sourceCode cpp"><em>template-parameter</em></code>
+(<span>13.4 <a href="https://wg21.link/temp.arg">[temp.arg]</a></span>),</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_223" id="pnum_223">(7.4)</a></span>
+substitution of each template argument into the following template
+parameters (if any) succeeds, and</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_224" id="pnum_224">(7.5)</a></span>
+if the <code class="sourceCode cpp"><em>template-id</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+is non-dependent, the associated constraints are satisfied as specified
+in the next paragraph.</li>
+</ul>
+<p>A <code class="sourceCode cpp"><em>simple-template-id</em></code>
+<span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+shall be valid unless it names a function template specialization
+(<span>13.10.3 <a href="https://wg21.link/temp.deduct">[temp.deduct]</a></span>).</p>
+</blockquote>
+</div>
+<p>Extend paragraph 8 to require constraints to also be satisfied by
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_193" id="pnum_193">8</a></span>
-When the <code class="sourceCode cpp"><em>template-name</em></code>
-<span class="addu">or splicer</span> of a
-<code class="sourceCode cpp"><em>simple-template-id</em></code> <span class="rm" style="color: #bf0303"><del>names</del></span> <span class="addu">designates</span> a constrained non-function template or a
-constrained template
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_225" id="pnum_225">8</a></span>
+When the <code class="sourceCode cpp"><em>template-name</em></code> of a
+<code class="sourceCode cpp"><em>simple-template-id</em></code> <span class="addu">or the
+<code class="sourceCode cpp"><em>splice-specifier</em></code> of a
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+designates</span> <span class="rm" style="color: #bf0303"><del>names</del></span> a constrained
+non-function template or a constrained template
 <code class="sourceCode cpp"><em>template-parameter</em></code>, and all
 <code class="sourceCode cpp"><em>template-arguments</em></code> in the
-<code class="sourceCode cpp"><em>simple-template-id</em></code> are
-non-dependent ([temp.dep.temp]), the associated contraints
-([temp.constr.decl]) of the constrained template shall be satisfied
-([temp.constr.constr]).</p>
+<code class="sourceCode cpp"><em>simple-template-id</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+are non-dependent (<span>13.8.3.5 <a href="https://wg21.link/temp.dep.temp">[temp.dep.temp]</a></span>), the
+associated constraints (<span>13.5.3 <a href="https://wg21.link/temp.constr.decl">[temp.constr.decl]</a></span>)
+of the constrained template shall be satisfied (<span>13.5.2 <a href="https://wg21.link/temp.constr.constr">[temp.constr.constr]</a></span>).</p>
 </blockquote>
 </div>
-<p>Change paragraph 9 to allow splicing into a <em>concept-id</em>:</p>
+<p>Modify footnote 111 to account for
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_194" id="pnum_194">9</a></span>
-A <em>concept-id</em> is a
-<code class="sourceCode cpp"><em>simple-template-id</em></code> where
-<span class="addu">either</span> the
-<code class="sourceCode cpp"><em>template-name</em></code> is a
-<code class="sourceCode cpp"><em>concept-name</em></code> <span class="addu">or the
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>
-designates a concept</span>. A concept-id is a prvalue of type
-<code class="sourceCode cpp"><span class="dt">bool</span></code>, and
-does not name a template specialization. A concept-id evaluates to
-<code class="sourceCode cpp"><span class="kw">true</span></code> if the
-concept’s normalized
-<code class="sourceCode cpp"><em>constraint-expression</em></code>
-([temp.constr.decl]) is satisfied ([temp.constr.constr]) by the
-specified template arguments and
-<code class="sourceCode cpp"><span class="kw">false</span></code>
-otherwise.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_226" id="pnum_226">111)</a></span>
+A <code class="sourceCode cpp"><span class="op">&gt;</span></code> that
+encloses the <code class="sourceCode cpp"><em>type-id</em></code> of a
+<code class="sourceCode cpp"><span class="kw">dynamic_cast</span></code>,
+<code class="sourceCode cpp"><span class="kw">static_cast</span></code>,
+<code class="sourceCode cpp"><span class="kw">reinterpret_cast</span></code>
+or
+<code class="sourceCode cpp"><span class="kw">const_cast</span></code>,
+or which encloses the
+<code class="sourceCode cpp"><em>template-argument</em></code>s of a
+subsequent <code class="sourceCode cpp"><em>template-id</em></code>
+<span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>,
+is considered nested for the purpose of this description.</p>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="temp.arg.general-general"><span>13.4.1 <a href="https://wg21.link/temp.arg.general">[temp.arg.general]</a></span>
 General<a href="#temp.arg.general-general" class="self-link"></a></h3>
-<p>Adjust paragraph 3 of [temp.arg.general] to not apply to splice
-template arguments:</p>
+<p>Modify paragraph 1; there are now <em>four</em> forms of
+<code class="sourceCode cpp"><em>template-argument</em></code>.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_195" id="pnum_195">3</a></span>
-In a <code class="sourceCode cpp"><em>template-argument</em></code>
-<span class="addu">that is not a
-<code class="sourceCode cpp"><em>splice-specifier</em></code></span>, an
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_227" id="pnum_227">1</a></span>
+There are <span class="rm" style="color: #bf0303"><del>three</del></span> <span class="addu">four</span> forms of
+<code class="sourceCode cpp"><em>template-argument</em></code>, <span class="addu">three of which</span> correspond<span class="rm" style="color: #bf0303"><del>ing</del></span> to the three forms of
+<code class="sourceCode cpp"><em>template-parameter</em></code>: type,
+non-type and template. <span class="addu">The fourth argument form,
+splice template argument, is considered to match the form of any
+template parameter.</span> The type and form of each
+<code class="sourceCode cpp"><em>template-argument</em></code> specified
+in a <code class="sourceCode cpp"><em>template-id</em></code> <span class="addu">or in a
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+shall match the type and form specified for the corresponding parameter
+declared by the template in its
+<code class="sourceCode cpp"><em>template-parameter-list</em></code>.</p>
+</blockquote>
+</div>
+<p>Clarify ambiguity between
+<code class="sourceCode cpp"><em>splice-expression</em></code>s and
+<code class="sourceCode cpp"><em>splice-template-argument</em></code>s
+in paragraph 3:</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_228" id="pnum_228">3</a></span>
+<span class="addu">A
+<code class="sourceCode cpp"><em>template-argument</em></code> of the
+form <code class="sourceCode cpp"><em>splice-specifier</em></code> is
+interpreted as a
+<code class="sourceCode cpp"><em>splice-template-argument</em></code>.</span>
+<span class="rm" style="color: #bf0303"><del>In a</del></span> <span class="addu">For any other</span>
+<code class="sourceCode cpp"><em>template-argument</em></code>, an
 ambiguity between a <code class="sourceCode cpp"><em>type-id</em></code>
 and an expression is resolved to a
 <code class="sourceCode cpp"><em>type-id</em></code>, regardless of the
@@ -7231,34 +7767,50 @@ <h3 class="unnumbered" id="temp.arg.general-general"><span>13.4.1 <a href="https
 <div class="example2">
 <span>[ <em>Example 2:</em> </span>
 <div>
-<div class="sourceCode" id="cb129"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb129-1"><a href="#cb129-1" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt; void f(); <span class="addu">  // #1</span></span>
-<span id="cb129-2"><a href="#cb129-2" aria-hidden="true" tabindex="-1"></a>  template&lt;int I&gt; void f(); <span class="addu">    // #2</span></span>
-<span id="cb129-3"><a href="#cb129-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb129-4"><a href="#cb129-4" aria-hidden="true" tabindex="-1"></a>  void g() {</span>
-<span id="cb129-5"><a href="#cb129-5" aria-hidden="true" tabindex="-1"></a>    f&lt;int()&gt;();       // int() is a type-id: call<span class="addu">s (#1)</span> <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default">the first f()</code></span></del></span></span>
-<span id="cb129-6"><a href="#cb129-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb129-7"><a href="#cb129-7" aria-hidden="true" tabindex="-1"></a><span class="va">+   constexpr int x = 42;</span></span>
-<span id="cb129-8"><a href="#cb129-8" aria-hidden="true" tabindex="-1"></a><span class="va">+   f&lt;[:^^int:]&gt;();    // splice-specifier: calls (#1)</span></span>
-<span id="cb129-9"><a href="#cb129-9" aria-hidden="true" tabindex="-1"></a><span class="va">+   f&lt;[:^^x:]&gt;();      // splice-specifier: calls (#2)</span></span>
-<span id="cb129-10"><a href="#cb129-10" aria-hidden="true" tabindex="-1"></a>  }</span></code></pre></div>
+<div class="sourceCode" id="cb134"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb134-1"><a href="#cb134-1" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt; void f(); <span class="addu">  // #1</span></span>
+<span id="cb134-2"><a href="#cb134-2" aria-hidden="true" tabindex="-1"></a>  template&lt;int I&gt; void f(); <span class="addu">    // #2</span></span>
+<span id="cb134-3"><a href="#cb134-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-4"><a href="#cb134-4" aria-hidden="true" tabindex="-1"></a>  void g() {</span>
+<span id="cb134-5"><a href="#cb134-5" aria-hidden="true" tabindex="-1"></a>    f&lt;int()&gt;();       // int() is a type-id: call<span class="addu">s (#1)</span> <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default">the first f()</code></span></del></span></span>
+<span id="cb134-6"><a href="#cb134-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-7"><a href="#cb134-7" aria-hidden="true" tabindex="-1"></a><span class="va">+   constexpr int x = 42;</span></span>
+<span id="cb134-8"><a href="#cb134-8" aria-hidden="true" tabindex="-1"></a><span class="va">+   f&lt;[:^^int:]&gt;();    // splice-template-argument: calls (#1)</span></span>
+<span id="cb134-9"><a href="#cb134-9" aria-hidden="true" tabindex="-1"></a><span class="va">+   f&lt;[:^^x:]&gt;();      // splice-template-argument: calls (#2)</span></span>
+<span id="cb134-10"><a href="#cb134-10" aria-hidden="true" tabindex="-1"></a>  }</span></code></pre></div>
 </div>
 <span> — <em>end example</em> ]</span>
 </div>
 </blockquote>
 </div>
+<p>Clarify in paragraph 9 that default template arguments also apply to
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s:</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_229" id="pnum_229">9</a></span>
+When a <code class="sourceCode cpp"><em>simple-template-id</em></code>
+<span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+does not <span class="rm" style="color: #bf0303"><del>name</del></span>
+<span class="addu">designate</span> a function, a default
+<code class="sourceCode cpp"><em>template-argument</em></code> is
+implicitly instantiated when the value of that default argument is
+needed.</p>
+</blockquote>
+</div>
 <h3 class="unnumbered" id="temp.arg.type-template-type-arguments"><span>13.4.2 <a href="https://wg21.link/temp.arg.type">[temp.arg.type]</a></span>
 Template type arguments<a href="#temp.arg.type-template-type-arguments" class="self-link"></a></h3>
 <p>Extend <span>13.4.2 <a href="https://wg21.link/temp.arg.type">[temp.arg.type]</a></span>/1 to
 cover splice template arguments:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_196" id="pnum_196">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_230" id="pnum_230">1</a></span>
 A <code class="sourceCode cpp"><em>template-argument</em></code> for a
 <code class="sourceCode cpp"><em>template-parameter</em></code> which is
 a type shall <span class="addu">either</span> be a
 <code class="sourceCode cpp"><em>type-id</em></code> <span class="addu">or a
-<code class="sourceCode cpp"><em>splice-specifier</em></code> that is
-either dependent or designates a type</span>.</p>
+<code class="sourceCode cpp"><em>splice-template-argument</em></code>
+whose <code class="sourceCode cpp"><em>splice-specifier</em></code>
+designates a type</span>.</p>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="temp.arg.nontype-template-non-type-arguments"><span>13.4.3 <a href="https://wg21.link/temp.arg.nontype">[temp.arg.nontype]</a></span>
@@ -7273,22 +7825,22 @@ <h3 class="unnumbered" id="temp.arg.nontype-template-non-type-arguments"><span>1
 already worded ]</span></p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_197" id="pnum_197">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_231" id="pnum_231">1</a></span>
 If the type <code class="sourceCode cpp">T</code> of a
 <em>template-parameter</em> ([temp.param]) contains a placeholder type
 ([dcl.spec.auto]) or a placeholder for a deduced class type
 ([dcl.type.class.deduct]), the type of the parameter is the type deduced
 for the variable x in the invented declaration</p>
-<div class="sourceCode" id="cb130"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb130-1"><a href="#cb130-1" aria-hidden="true" tabindex="-1"></a>T x <span class="op">=</span> <em>E</em> ;</span></code></pre></div>
+<div class="sourceCode" id="cb135"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb135-1"><a href="#cb135-1" aria-hidden="true" tabindex="-1"></a>T x <span class="op">=</span> <em>E</em> ;</span></code></pre></div>
 <p>where <code class="sourceCode cpp"><em>E</em></code> is the template
 argument provided for the parameter.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_198" id="pnum_198">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_232" id="pnum_232">2</a></span>
 The value of a non-type <em>template-parameter</em>
 <code class="sourceCode cpp">P</code> of (possibly deduced) type
 <code class="sourceCode cpp">T</code> […]</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_199" id="pnum_199">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_233" id="pnum_233">3</a></span>
 Otherwise, a temporary variable</p>
-<div class="sourceCode" id="cb131"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb131-1"><a href="#cb131-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> T v <span class="op">=</span> <em>A</em>;</span></code></pre></div>
+<div class="sourceCode" id="cb136"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb136-1"><a href="#cb136-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> T v <span class="op">=</span> <em>A</em>;</span></code></pre></div>
 <p>is introduced.</p>
 </blockquote>
 </div>
@@ -7298,69 +7850,77 @@ <h3 class="unnumbered" id="temp.arg.template-template-template-arguments"><span>
 to cover splice template arguments:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_200" id="pnum_200">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_234" id="pnum_234">1</a></span>
 A <code class="sourceCode cpp"><em>template-argument</em></code> for a
 template <code class="sourceCode cpp"><em>template-parameter</em></code>
 shall be <span class="rm" style="color: #bf0303"><del>the name
 of</del></span> a class template or an alias template, expressed as
 <span class="addu">an</span>
-<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or a (possibly dependent) splicer</span>. Only primary
-templates are considered when matching the template argument with the
-corresponding parameter; partial specializations are not considered even
-if their parameter lists match that of the template template
-parameter.</p>
+<code class="sourceCode cpp"><em>id-expression</em></code> <span class="addu">or a
+<code class="sourceCode cpp"><em>splice-template-argument</em></code></span>.
+Only primary templates are considered when matching the template
+argument with the corresponding parameter; partial specializations are
+not considered even if their parameter lists match that of the template
+template parameter.</p>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="temp.type-type-equivalence"><span>13.6 <a href="https://wg21.link/temp.type">[temp.type]</a></span> Type
 equivalence<a href="#temp.type-type-equivalence" class="self-link"></a></h3>
-<p>Extend <code class="sourceCode cpp"><em>template-id</em></code>
-equivalence as defined by paragraph 1 to cover splicers.</p>
+<p>Extend paragraph 1 to also define the “sameness” of
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_201" id="pnum_201">1</a></span>
-Two <code class="sourceCode cpp"><em>template-id</em></code>s are the
-same if</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_235" id="pnum_235">1</a></span>
+Two <code class="sourceCode cpp"><em>template-id</em></code>s <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s</span>
+are the same if</p>
 <ul>
-<li>their <code class="sourceCode cpp"><em>template-name</em></code>s,
-<span class="addu"><code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>s,
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s,</span>
-<code class="sourceCode cpp"><em>operator-function-id</em></code>s, or
-<code class="sourceCode cpp"><em>literal-operator-id</em></code>s refer
-to the same template, and</li>
-<li>their corresponding type
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_236" id="pnum_236">(1.1)</a></span>
+their <code class="sourceCode cpp"><em>template-name</em></code>s,
+<code class="sourceCode cpp"><em>operator-function-id</em></code>s,
+<span class="rm" style="color: #bf0303"><del>or</del></span>
+<code class="sourceCode cpp"><em>literal-operator-id</em></code>s<span class="addu">, or
+<code class="sourceCode cpp"><em>splice-specifier</em></code>s</span>
+refer to the same template, and</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_237" id="pnum_237">(1.2)</a></span>
+their corresponding type
 <code class="sourceCode cpp"><em>template-argument</em></code>s are the
 same type, and</li>
-<li>the template parameter values determined by their corresponding
-non-type template arguments ([temp.arg.nontype]) are
-template-argument-equivalent (see below), and</li>
-<li>their corresponding template
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_238" id="pnum_238">(1.3)</a></span>
+the template parameter values determined by their corresponding non-type
+template arguments (<span>13.4.3 <a href="https://wg21.link/temp.arg.nontype">[temp.arg.nontype]</a></span>)
+are template-argument-equivalent (see below), and</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_239" id="pnum_239">(1.4)</a></span>
+their corresponding template
 <code class="sourceCode cpp"><em>template-argument</em></code>s refer to
 the same template.</li>
 </ul>
-<p>Two <code class="sourceCode cpp"><em>template-id</em></code>s that
-are the same refer to the same class, function, or variable.</p>
+<p>Two <code class="sourceCode cpp"><em>template-id</em></code>s <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s</span>
+that are the same refer to the same class, function, or variable.</p>
 </blockquote>
 </div>
-<p>Extend <em>template-argument-equivalent</em> to handle <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>:</p>
+<p>Extend <em>template-argument-equivalent</em> in paragraph 2 to handle
+<code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_202" id="pnum_202">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_240" id="pnum_240">2</a></span>
 Two values are <em>template-argument-equivalent</em> if they are of the
 same type and</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_203" id="pnum_203">(2.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_241" id="pnum_241">(2.1)</a></span>
 they are of integral type and their values are the same, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_204" id="pnum_204">(2.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_242" id="pnum_242">(2.2)</a></span>
 they are of floating-point type and their values are identical, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_205" id="pnum_205">(2.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_243" id="pnum_243">(2.3)</a></span>
 they are of type <code class="sourceCode cpp">std<span class="op">::</span>nullptr_t</code>,
 or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_206" id="pnum_206">(2.*)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_244" id="pnum_244">(2.*)</a></span>
 <span class="addu">they are of type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>
 and their values are the same, or</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_207" id="pnum_207">(2.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_245" id="pnum_245">(2.4)</a></span>
 they are of enumeration type and their values are the same, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_208" id="pnum_208">(2.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_246" id="pnum_246">(2.5)</a></span>
 […]</li>
 </ul>
 </blockquote>
@@ -7372,44 +7932,37 @@ <h3 class="unnumbered" id="temp.deduct.guide-deduction-guides"><span>13.7.2.3 <a
 also leverage deduction guides.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_209" id="pnum_209">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_247" id="pnum_247">1</a></span>
 Deduction guides are used when a
 <code class="sourceCode cpp"><em>template-name</em></code> <span class="addu">or
 <code class="sourceCode cpp"><em>splice-type-specifier</em></code></span>
-appears as a type specifier for a deduced class type
-([dcl.type.class.deduct]). Deduction guides are not found by name
-lookup. Instead, when performing class template argument deduction
-([over.match.class.deduct]), all reachable deduction guides declared for
-the class template are considered.</p>
-</blockquote>
-</div>
-<p>Notwithstanding the above, extend paragraph 3 to clarify that
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s
-cannot themselves appear in deduction guides.</p>
-<div class="std">
-<blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_210" id="pnum_210">3</a></span>
-The same restrictions apply to the
-<code class="sourceCode cpp"><em>parameter-declaration-clause</em></code>
-of a deduction guide as in a function declaration ([dcl.fct]), except
-that a generic parameter type placeholder ([dcl.spec.auto]) shall not
-appear in the
-<code class="sourceCode cpp"><em>parameter-declaration-clause</em></code>
-of a deduction guide. The
-<code class="sourceCode cpp"><em>simple-template-id</em></code> shall
-name a class template specialization <span class="addu">and shall
-contain a
-<code class="sourceCode cpp"><em>template-name</em></code></span>. The
-<code class="sourceCode cpp"><em>template-name</em></code> shall be the
-same <code class="sourceCode cpp"><em>identifier</em></code> as the
-<code class="sourceCode cpp"><em>template-name</em></code> of the
-<code class="sourceCode cpp"><em>simple-template-id</em></code>. A
-<code class="sourceCode cpp"><em>deduction-guide</em></code> shall
-inhabit the scope to which the corresponding class template belongs and,
-for a member class template, have the same access. Two deduction guide
-declarations for the same class template shall not have equivalent
-<code class="sourceCode cpp"><em>parameter-declaration-clauses</em></code>
-if either is reachable from the other.</p>
+appears as a type specifier for a deduced class type (<span>9.2.9.8 <a href="https://wg21.link/dcl.type.class.deduct">[dcl.type.class.deduct]</a></span>).
+Deduction guides are not found by name lookup. Instead, when performing
+class template argument deduction (<span>12.2.2.9 <a href="https://wg21.link/over.match.class.deduct">[over.match.class.deduct]</a></span>),
+all reachable deduction guides declared for the class template are
+considered.</p>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="temp.mem-member-templates"><span>13.7.3 <a href="https://wg21.link/temp.mem">[temp.mem]</a></span> Member
+templates<a href="#temp.mem-member-templates" class="self-link"></a></h3>
+<p>Clarify in Note 1 that a specialization of a conversion function
+template can be formed through a
+<code class="sourceCode cpp"><em>splice-expression</em></code>.</p>
+<div class="std">
+<blockquote>
+<div class="note">
+<p><span>[ <em>Note 1:</em> </span>A specialization of a conversion
+function template is referenced in the same way as a non-template
+conversion function that converts to the same type (<span>11.4.8.3 <a href="https://wg21.link/class.conv.fct">[class.conv.fct]</a></span>).</p>
+<p>…</p>
+<p><span class="addu">An expression designating a particular
+specialization of a conversion function template can only be formed with
+a <code class="sourceCode cpp"><em>splice-expression</em></code>.</span>
+There is no <span class="addu">analogous</span> syntax to form a
+<code class="sourceCode cpp"><em>template-id</em></code> (<span>13.3 <a href="https://wg21.link/temp.names">[temp.names]</a></span>) <span class="addu">for such a function</span> by providing an explicit
+template argument list (<span>13.10.2 <a href="https://wg21.link/temp.arg.explicit">[temp.arg.explicit]</a></span>).<span>
+— <em>end note</em> ]</span></p>
+</div>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="temp.alias-alias-templates"><span>13.7.8 <a href="https://wg21.link/temp.alias">[temp.alias]</a></span> Alias
@@ -7418,7 +7971,7 @@ <h3 class="unnumbered" id="temp.alias-alias-templates"><span>13.7.8 <a href="htt
 specializations.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_211" id="pnum_211">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_248" id="pnum_248">2</a></span>
 <span class="rm" style="color: #bf0303"><del>When</del></span> <span class="addu">Except when used as the operand of a
 <code class="sourceCode cpp"><em>reflect-expression</em></code>,</span>
 a <code class="sourceCode cpp"><em>template-id</em></code> <span class="rm" style="color: #bf0303"><del>refers</del></span> <span class="addu">referring</span> to a specialization of an alias
@@ -7432,153 +7985,166 @@ <h3 class="unnumbered" id="temp.alias-alias-templates"><span>13.7.8 <a href="htt
 </div>
 <h3 class="unnumbered" id="temp.res.general-general"><span>13.8.1 <a href="https://wg21.link/temp.res.general">[temp.res.general]</a></span>
 General<a href="#temp.res.general-general" class="self-link"></a></h3>
-<p>Disallow
-<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s from
-appearing in
-<code class="sourceCode cpp"><em>typename-specifier</em></code>s, since
-splicers can’t follow
-<code class="sourceCode cpp"><em>nested-name-specifier</em></code>s.</p>
-<div class="std">
-<blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_212" id="pnum_212">3</a></span>
-The component names of a
-<code class="sourceCode cpp"><em>typename-specifier</em></code> are its
-<code class="sourceCode cpp"><em>identifier</em></code> (if any) and
-those of its
-<code class="sourceCode cpp"><em>nested-name-specifier</em></code> and
-<code class="sourceCode cpp"><em>simple-template-id</em></code> (if
-any). <span class="addu">The
-<code class="sourceCode cpp"><em>simple-template-id</em></code> shall
-not contain a splicer.</span></p>
-</blockquote>
-</div>
-<p>Add a parargraph after the definition of <em>type-only context</em>
-to define what it means for a splicer to appear in a type-only
-context.</p>
+<p>Extend paragraph 4 to define what it means for a
+<code class="sourceCode cpp"><em>splice-specifier</em></code> to appear
+in a type-only context.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_213" id="pnum_213">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_249" id="pnum_249">4</a></span>
 A qualified or unqualified name is said to be in a
 <code class="sourceCode cpp"><em>type-only context</em></code> if it is
 the terminal name of</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_214" id="pnum_214">(4.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_250" id="pnum_250">(4.1)</a></span>
 a <code class="sourceCode cpp"><em>typename-specifier</em></code>,
 <code class="sourceCode cpp"><em>type-requirement</em></code>,
 <code class="sourceCode cpp"><em>nested-name-specifier</em></code>,
 <code class="sourceCode cpp"><em>elaborated-type-specifier</em></code>,
 <code class="sourceCode cpp"><em>class-or-decltype</em></code>, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_215" id="pnum_215">(4.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_251" id="pnum_251">(4.2)</a></span>
 […]
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_216" id="pnum_216">(4.4.6)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_252" id="pnum_252">(4.4.6)</a></span>
 <code class="sourceCode cpp"><em>parameter-declaration</em></code> of a
 (non-type)
 <code class="sourceCode cpp"><em>template-parameter</em></code>.</li>
 </ul></li>
 </ul>
-<p><span class="addu">A splicer ([expr.prim.id.splice]) is said to be in
-a <em>type-only context</em> if a hypothetical qualified name appearing
-in the same position would be in a type-only context.</span></p>
+<p><span class="addu">A
+<code class="sourceCode cpp"><em>splice-specifier</em></code> or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+([basic.splice]) is said to be in a <em>type-only context</em> if a
+hypothetical qualified name appearing in the same position would be in a
+type-only context.</span></p>
 <div class="example5">
 <span>[ <em>Example 5:</em> </span>
-<div class="sourceCode" id="cb132"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb132-1"><a href="#cb132-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> T<span class="op">::</span>R f<span class="op">()</span>;</span>
-<span id="cb132-2"><a href="#cb132-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="dt">void</span> f<span class="op">(</span>T<span class="op">::</span>R<span class="op">)</span>;   <span class="co">// ill-formed, no diagnostic required: attempt to</span></span>
-<span id="cb132-3"><a href="#cb132-3" aria-hidden="true" tabindex="-1"></a>                                  <span class="co">// declare a `void` variable template</span></span>
-<span id="cb132-4"><a href="#cb132-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-5"><a href="#cb132-5" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">struct</span> S <span class="op">{</span></span>
-<span id="cb132-6"><a href="#cb132-6" aria-hidden="true" tabindex="-1"></a>  <span class="kw">using</span> Ptr <span class="op">=</span> PtrTraits<span class="op">&lt;</span>T<span class="op">&gt;::</span>Ptr;  <span class="co">// OK, in a <em>defining-type-id</em></span></span>
-<span id="cb132-7"><a href="#cb132-7" aria-hidden="true" tabindex="-1"></a>  <span class="addu"><code class="sourceCode cpp"><span class="kw">using</span> Alias <span class="op">=</span> <span class="op">[:^^</span><span class="dt">int</span><span class="op">]</span>;          <span class="co">// OK, in a <em>defining-type-id</em></span></code></span></span>
-<span id="cb132-8"><a href="#cb132-8" aria-hidden="true" tabindex="-1"></a>  T<span class="op">::</span>R f<span class="op">(</span>T<span class="op">::</span>P p<span class="op">)</span> <span class="op">{</span>                <span class="co">// OK, class scope</span></span>
-<span id="cb132-9"><a href="#cb132-9" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="kw">static_cast</span><span class="op">&lt;</span>T<span class="op">::</span>R<span class="op">&gt;(</span>p<span class="op">)</span>;  <span class="co">// OK, <em>type-id</em> of a `static_cast`</span></span>
-<span id="cb132-10"><a href="#cb132-10" aria-hidden="true" tabindex="-1"></a>  <span class="op">}</span></span>
-<span id="cb132-11"><a href="#cb132-11" aria-hidden="true" tabindex="-1"></a>  <span class="kw">auto</span> g<span class="op">()</span> <span class="op">-&gt;</span> S<span class="op">&lt;</span>T<span class="op">*&gt;::</span>Ptr;         <span class="co">// OK, <em>trailing-return-type</em></span></span>
-<span id="cb132-12"><a href="#cb132-12" aria-hidden="true" tabindex="-1"></a>  <span class="addu"><code class="sourceCode cpp"><span class="kw">auto</span> h<span class="op">()</span> <span class="op">-&gt;</span> <span class="op">[:^^</span>S<span class="op">:]&lt;</span>T<span class="op">*&gt;</span>;         <span class="co">// OK, <em>trailing-return-type</em></span></code></span></span>
-<span id="cb132-13"><a href="#cb132-13" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
-<span id="cb132-14"><a href="#cb132-14" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> f<span class="op">()</span> <span class="op">{</span></span>
-<span id="cb132-15"><a href="#cb132-15" aria-hidden="true" tabindex="-1"></a>  <span class="dt">void</span> <span class="op">(*</span>pf<span class="op">)(</span>T<span class="op">::</span>X<span class="op">)</span>;               <span class="co">// variable `pf` of type `void*` initialized</span></span>
-<span id="cb132-16"><a href="#cb132-16" aria-hidden="true" tabindex="-1"></a>                                  <span class="co">// with `T::X`</span></span>
-<span id="cb132-17"><a href="#cb132-17" aria-hidden="true" tabindex="-1"></a>  <span class="dt">void</span> g<span class="op">(</span>T<span class="op">::</span>X<span class="op">)</span>;                   <span class="co">// error: `T::X` at block scope does not denote</span></span>
-<span id="cb132-18"><a href="#cb132-18" aria-hidden="true" tabindex="-1"></a>                                  <span class="co">// a type (attempt to declare a `void` variable)</span></span>
-<span id="cb132-19"><a href="#cb132-19" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb137"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb137-1"><a href="#cb137-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> T<span class="op">::</span>R f<span class="op">()</span>;</span>
+<span id="cb137-2"><a href="#cb137-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="dt">void</span> f<span class="op">(</span>T<span class="op">::</span>R<span class="op">)</span>;   <span class="co">// ill-formed, no diagnostic required: attempt to</span></span>
+<span id="cb137-3"><a href="#cb137-3" aria-hidden="true" tabindex="-1"></a>                                  <span class="co">// declare a `void` variable template</span></span>
+<span id="cb137-4"><a href="#cb137-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb137-5"><a href="#cb137-5" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">struct</span> S <span class="op">{</span></span>
+<span id="cb137-6"><a href="#cb137-6" aria-hidden="true" tabindex="-1"></a>  <span class="kw">using</span> Ptr <span class="op">=</span> PtrTraits<span class="op">&lt;</span>T<span class="op">&gt;::</span>Ptr;  <span class="co">// OK, in a <em>defining-type-id</em></span></span>
+<span id="cb137-7"><a href="#cb137-7" aria-hidden="true" tabindex="-1"></a>  <span class="addu"><code class="sourceCode cpp"><span class="kw">using</span> Alias <span class="op">=</span> <span class="op">[:^^</span><span class="dt">int</span><span class="op">]</span>;          <span class="co">// OK, in a <em>defining-type-id</em></span></code></span></span>
+<span id="cb137-8"><a href="#cb137-8" aria-hidden="true" tabindex="-1"></a>  T<span class="op">::</span>R f<span class="op">(</span>T<span class="op">::</span>P p<span class="op">)</span> <span class="op">{</span>                <span class="co">// OK, class scope</span></span>
+<span id="cb137-9"><a href="#cb137-9" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="kw">static_cast</span><span class="op">&lt;</span>T<span class="op">::</span>R<span class="op">&gt;(</span>p<span class="op">)</span>;  <span class="co">// OK, <em>type-id</em> of a `static_cast`</span></span>
+<span id="cb137-10"><a href="#cb137-10" aria-hidden="true" tabindex="-1"></a>  <span class="op">}</span></span>
+<span id="cb137-11"><a href="#cb137-11" aria-hidden="true" tabindex="-1"></a>  <span class="kw">auto</span> g<span class="op">()</span> <span class="op">-&gt;</span> S<span class="op">&lt;</span>T<span class="op">*&gt;::</span>Ptr;         <span class="co">// OK, <em>trailing-return-type</em></span></span>
+<span id="cb137-12"><a href="#cb137-12" aria-hidden="true" tabindex="-1"></a>  <span class="addu"><code class="sourceCode cpp"><span class="kw">auto</span> h<span class="op">()</span> <span class="op">-&gt;</span> <span class="op">[:^^</span>S<span class="op">:]&lt;</span>T<span class="op">*&gt;</span>;         <span class="co">// OK, <em>trailing-return-type</em></span></code></span></span>
+<span id="cb137-13"><a href="#cb137-13" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
+<span id="cb137-14"><a href="#cb137-14" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> f<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb137-15"><a href="#cb137-15" aria-hidden="true" tabindex="-1"></a>  <span class="dt">void</span> <span class="op">(*</span>pf<span class="op">)(</span>T<span class="op">::</span>X<span class="op">)</span>;               <span class="co">// variable `pf` of type `void*` initialized</span></span>
+<span id="cb137-16"><a href="#cb137-16" aria-hidden="true" tabindex="-1"></a>                                  <span class="co">// with `T::X`</span></span>
+<span id="cb137-17"><a href="#cb137-17" aria-hidden="true" tabindex="-1"></a>  <span class="dt">void</span> g<span class="op">(</span>T<span class="op">::</span>X<span class="op">)</span>;                   <span class="co">// error: `T::X` at block scope does not denote</span></span>
+<span id="cb137-18"><a href="#cb137-18" aria-hidden="true" tabindex="-1"></a>                                  <span class="co">// a type (attempt to declare a `void` variable)</span></span>
+<span id="cb137-19"><a href="#cb137-19" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
 </blockquote>
 </div>
-<p>Add a new case to the list of IFNDR conditions related to template
-instantiation.</p>
+<h3 class="unnumbered" id="temp.dep.type-dependent-types"><span>13.8.3.2
+<a href="https://wg21.link/temp.dep.type">[temp.dep.type]</a></span>
+Dependent types<a href="#temp.dep.type-dependent-types" class="self-link"></a></h3>
+<p>Account for dependent
+<code class="sourceCode cpp"><em>splice-specifier</em></code>s in
+paragraph 7.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_253" id="pnum_253">7</a></span>
+An initializer is dependent if any constituent expression (<span>6.9.1
+<a href="https://wg21.link/intro.execution">[intro.execution]</a></span>)
+of the initializer is type-dependent. A placeholder type
+(<span>9.2.9.7.1 <a href="https://wg21.link/dcl.spec.auto.general">[dcl.spec.auto.general]</a></span>)
+is dependent if it designates a type deduced from a dependent
+initializer <span class="addu">or if its
+<code class="sourceCode cpp"><em>type-constraint</em></code> (if any)
+contains a dependent
+<code class="sourceCode cpp"><em>splice-specifier</em></code>
+([temp.dep.splice])</span>.</p>
+</blockquote>
+</div>
+<p>Apply a drive-by fix to paragraph 8 to account for placeholders for
+deduced class types whose template is dependent, while extending the
+definition to apply to
+<code class="sourceCode cpp"><em>splice-specifier</em></code>s.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_254" id="pnum_254">8</a></span>
+A placeholder for a deduced class type (<span>9.2.9.8 <a href="https://wg21.link/dcl.type.class.deduct">[dcl.type.class.deduct]</a></span>)
+is dependent if</p>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_255" id="pnum_255">(8.1)</a></span>
+it has a dependent initializer, <span class="rm" style="color: #bf0303"><del>or</del></span></li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_256" id="pnum_256">(8.2)</a></span>
+it has a dependent
+<code class="sourceCode cpp"><em>template-name</em></code> or a
+dependent <code class="sourceCode cpp"><em>splice-specifier</em></code>,
+or</span></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_257" id="pnum_257">(8.3)</a></span>
+it refers to an alias template that is a member of the current
+instantiation and whose
+<code class="sourceCode cpp"><em>defining-type-id</em></code> is
+dependent after class template argument deduction (<span>12.2.2.9 <a href="https://wg21.link/over.match.class.deduct">[over.match.class.deduct]</a></span>)
+and substitution (<span>13.7.8 <a href="https://wg21.link/temp.alias">[temp.alias]</a></span>).</li>
+</ul>
+</blockquote>
+</div>
+<p>Account for dependent
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code>s in
+paragraph 10:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_217" id="pnum_217">6</a></span>
-The validity of a templated entity may be checked prior to any
-instantiation.</p>
-<p><span class="note3"><span>[ <em>Note 3:</em> </span>Knowing which
-names are type names allows the syntax of every template to be checked
-in this way.<span> — <em>end note</em> ]</span></span></p>
-<p>The program is ill-formed, no diagnostic required, if</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_258" id="pnum_258">10</a></span>
+A type is dependent if it is</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_218" id="pnum_218">(6.1)</a></span>
-no valid specialization, ignoring
-<code class="sourceCode cpp"><em>static_assert-declaration</em></code>s
-that fail ([dcl.pre]), can be generated for a templated entity or a
-substatement of a constexpr if statement ([stmt.if]) within a templaetd
-entity and the innermost enclosing template is not instantiated, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_219" id="pnum_219">(6.2)</a></span>
-no valid specialization, ignoring
-<code class="sourceCode cpp"><em>static_assert-declaration</em></code>s
-that fail, can be generated for a default
-<code class="sourceCode cpp"><em>template-argument</em></code> and the
-default <code class="sourceCode cpp"><em>template-argument</em></code>
-is not used in any instantiation, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_220" id="pnum_220">(6.3)</a></span>
-no specialization of an alias template ([temp.alias]) is valid and no
-specialization of the alias template is named in the program, or</li>
-<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_221" id="pnum_221">(6.4)</a></span>
-any non-dependent plainly constant-evaluated expression within a
-templated entity produces an injected declaration ([expr.const]),
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_259" id="pnum_259">(10.1)</a></span>
+a template parameter,</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_260" id="pnum_260">(10.2)</a></span>
+…</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_261" id="pnum_261">(10.11)</a></span>
+denoted by a
+<code class="sourceCode cpp"><em>simple-template-id</em></code> in which
+either the template name is a template parameter or any of the template
+arguments is a dependent type or an expression that is type-dependent or
+value-dependent or is a pack expansion,<sup>121</sup></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_262" id="pnum_262">(10.12)</a></span>
+a <code class="sourceCode cpp"><em>pack-index-specifier</em></code>,
+<span class="rm" style="color: #bf0303"><del>or</del></span></li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_263" id="pnum_263">(10.13)</a></span>
+denoted by <code class="sourceCode cpp"><span class="kw">decltype</span><span class="op">(</span><em>expression</em><span class="op">)</span></code>,
+where <code class="sourceCode cpp"><em>expression</em></code> is
+type-dependent<span class="rm" style="color: #bf0303"><del>.</del></span><span class="addu">,
 or</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_222" id="pnum_222">(6.5)</a></span>
-any <code class="sourceCode cpp"><em>constraint-expression</em></code>
-in the program, introduced or otherwise, has (in its normal form) an
-atomic constraint <code class="sourceCode cpp"><em>A</em></code> where
-no satisfaction check of <code class="sourceCode cpp"><em>A</em></code>
-could be well-formed and no satisfaction check of
-<code class="sourceCode cpp"><em>A</em></code> is performed, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_223" id="pnum_223">(6.6)</a></span>
-every valid specialization of a variadic template requires an empty
-template parameter pack, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_224" id="pnum_224">(6.7)</a></span>
-a hypothetical instantiation of a templated entity immediately following
-its definition would be ill-formed due to a construct (other than a
-<code class="sourceCode cpp"><em>static_assert-declaration</em></code>
-that fails) that does not depend on a template parameter, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_225" id="pnum_225">(6.8)</a></span>
-the interpretation of such a construct in the hypothetical instantiation
-is different from the interpretation of the corresponding construct in
-any actual instantiation of the templated entity.</li>
+<li><span class="addu"><span class="marginalizedparent"><a class="marginalized" href="#pnum_264" id="pnum_264">(10.14)</a></span>
+denoted by a
+<code class="sourceCode cpp"><em>splice-type-specifier</em></code> in
+which either the
+<code class="sourceCode cpp"><em>splice-specifier</em></code> is
+dependent or any of the template arguments is a dependent type or an
+expression that is type-dependent or value-dependent or is a pack
+expansion.</span></li>
 </ul>
 </blockquote>
 </div>
 <h3 class="unnumbered" id="temp.dep.expr-type-dependent-expressions"><span>13.8.3.3 <a href="https://wg21.link/temp.dep.expr">[temp.dep.expr]</a></span>
 Type-dependent expressions<a href="#temp.dep.expr-type-dependent-expressions" class="self-link"></a></h3>
-<p>Add to the list of never-type-dependent expression forms in
-<span>13.8.3.3 <a href="https://wg21.link/temp.dep.expr">[temp.dep.expr]</a></span>/4:</p>
+<p>Add to the list of never-type-dependent expression forms in paragraph
+4:</p>
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb133"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb133-1"><a href="#cb133-1" aria-hidden="true" tabindex="-1"></a>     <em>literal</em></span>
-<span id="cb133-2"><a href="#cb133-2" aria-hidden="true" tabindex="-1"></a>     sizeof <em>unary-expression</em></span>
-<span id="cb133-3"><a href="#cb133-3" aria-hidden="true" tabindex="-1"></a>     sizeof ( <em>type-id</em> )</span>
-<span id="cb133-4"><a href="#cb133-4" aria-hidden="true" tabindex="-1"></a>     sizeof ... ( <em>identifier</em> )</span>
-<span id="cb133-5"><a href="#cb133-5" aria-hidden="true" tabindex="-1"></a>     alignof ( <em>type-id</em> )</span>
-<span id="cb133-6"><a href="#cb133-6" aria-hidden="true" tabindex="-1"></a>     typeid ( <em>expression</em> )</span>
-<span id="cb133-7"><a href="#cb133-7" aria-hidden="true" tabindex="-1"></a>     typeid ( <em>type-id</em> )</span>
-<span id="cb133-8"><a href="#cb133-8" aria-hidden="true" tabindex="-1"></a>     ::<sub><em>opt</em></sub> delete <em>cast-expression</em></span>
-<span id="cb133-9"><a href="#cb133-9" aria-hidden="true" tabindex="-1"></a>     ::<sub><em>opt</em></sub> delete [ ] <em>cast-expression</em></span>
-<span id="cb133-10"><a href="#cb133-10" aria-hidden="true" tabindex="-1"></a>     throw <em>assignment-expression</em><sub><em>opt</em></sub></span>
-<span id="cb133-11"><a href="#cb133-11" aria-hidden="true" tabindex="-1"></a>     noexcept ( <em>expression</em> )</span>
-<span id="cb133-12"><a href="#cb133-12" aria-hidden="true" tabindex="-1"></a>     <em>requires-expression</em></span>
-<span id="cb133-13"><a href="#cb133-13" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>reflect-expression</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb138"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb138-1"><a href="#cb138-1" aria-hidden="true" tabindex="-1"></a>     <em>literal</em></span>
+<span id="cb138-2"><a href="#cb138-2" aria-hidden="true" tabindex="-1"></a>     sizeof <em>unary-expression</em></span>
+<span id="cb138-3"><a href="#cb138-3" aria-hidden="true" tabindex="-1"></a>     sizeof ( <em>type-id</em> )</span>
+<span id="cb138-4"><a href="#cb138-4" aria-hidden="true" tabindex="-1"></a>     sizeof ... ( <em>identifier</em> )</span>
+<span id="cb138-5"><a href="#cb138-5" aria-hidden="true" tabindex="-1"></a>     alignof ( <em>type-id</em> )</span>
+<span id="cb138-6"><a href="#cb138-6" aria-hidden="true" tabindex="-1"></a>     typeid ( <em>expression</em> )</span>
+<span id="cb138-7"><a href="#cb138-7" aria-hidden="true" tabindex="-1"></a>     typeid ( <em>type-id</em> )</span>
+<span id="cb138-8"><a href="#cb138-8" aria-hidden="true" tabindex="-1"></a>     ::<sub><em>opt</em></sub> delete <em>cast-expression</em></span>
+<span id="cb138-9"><a href="#cb138-9" aria-hidden="true" tabindex="-1"></a>     ::<sub><em>opt</em></sub> delete [ ] <em>cast-expression</em></span>
+<span id="cb138-10"><a href="#cb138-10" aria-hidden="true" tabindex="-1"></a>     throw <em>assignment-expression</em><sub><em>opt</em></sub></span>
+<span id="cb138-11"><a href="#cb138-11" aria-hidden="true" tabindex="-1"></a>     noexcept ( <em>expression</em> )</span>
+<span id="cb138-12"><a href="#cb138-12" aria-hidden="true" tabindex="-1"></a>     <em>requires-expression</em></span>
+<span id="cb138-13"><a href="#cb138-13" aria-hidden="true" tabindex="-1"></a><span class="va">+    <em>reflect-expression</em></span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -7586,17 +8152,16 @@ <h3 class="unnumbered" id="temp.dep.expr-type-dependent-expressions"><span>13.8.
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_226" id="pnum_226">9</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_265" id="pnum_265">9</a></span>
 A <code class="sourceCode cpp"><em>primary-expression</em></code> of the
 form <code class="sourceCode cpp"><em>splice-specifier</em></code> or
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em> <span class="op">&lt;</span> <em>template-argument-list</em><sub><em>opt</em></sub> <span class="op">&gt;</span></code>
+<code class="sourceCode cpp"><span class="kw">template</span> <em>splice-specifier</em> <span class="op">&lt;</span> <em>template-argument-list</em><sub><em>opt</em></sub> <span class="op">&gt;</span></code>
 is type-dependent if</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_227" id="pnum_227">(9.1)</a></span>
-the <code class="sourceCode cpp"><em>splice-specifier</em></code> or
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>
-is dependent, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_228" id="pnum_228">(9.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_266" id="pnum_266">(9.1)</a></span>
+the <code class="sourceCode cpp"><em>splice-specifier</em></code> is
+dependent, or</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_267" id="pnum_267">(9.2)</a></span>
 the optional
 <code class="sourceCode cpp"><em>template-argument-list</em></code>
 contains a dependent type argument, a value-dependent non-type argument,
@@ -7612,44 +8177,47 @@ <h3 class="unnumbered" id="temp.dep.constexpr-value-dependent-expressions"><span
 (before the note):</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_229" id="pnum_229">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_268" id="pnum_268">2</a></span>
 An <em>id-expression</em> is value-dependent if:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_230" id="pnum_230">(2.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_269" id="pnum_269">(2.1)</a></span>
 […]</li>
 </ul>
 <p>Expressions of the following form are value-dependent if the
 <em>unary-expression</em> or <em>expression</em> is type-dependent or
 the <em>type-id</em> is dependent:</p>
-<div class="sourceCode" id="cb134"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb134-1"><a href="#cb134-1" aria-hidden="true" tabindex="-1"></a>sizeof unary-expression</span>
-<span id="cb134-2"><a href="#cb134-2" aria-hidden="true" tabindex="-1"></a>sizeof ( type-id )</span>
-<span id="cb134-3"><a href="#cb134-3" aria-hidden="true" tabindex="-1"></a>typeid ( expression )</span>
-<span id="cb134-4"><a href="#cb134-4" aria-hidden="true" tabindex="-1"></a>typeid ( type-id )</span>
-<span id="cb134-5"><a href="#cb134-5" aria-hidden="true" tabindex="-1"></a>alignof ( type-id )</span>
-<span id="cb134-6"><a href="#cb134-6" aria-hidden="true" tabindex="-1"></a>noexcept ( expression )</span></code></pre></div>
+<div class="sourceCode" id="cb139"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb139-1"><a href="#cb139-1" aria-hidden="true" tabindex="-1"></a>sizeof unary-expression</span>
+<span id="cb139-2"><a href="#cb139-2" aria-hidden="true" tabindex="-1"></a>sizeof ( type-id )</span>
+<span id="cb139-3"><a href="#cb139-3" aria-hidden="true" tabindex="-1"></a>typeid ( expression )</span>
+<span id="cb139-4"><a href="#cb139-4" aria-hidden="true" tabindex="-1"></a>typeid ( type-id )</span>
+<span id="cb139-5"><a href="#cb139-5" aria-hidden="true" tabindex="-1"></a>alignof ( type-id )</span>
+<span id="cb139-6"><a href="#cb139-6" aria-hidden="true" tabindex="-1"></a>noexcept ( expression )</span></code></pre></div>
 <p><span class="addu">A
 <code class="sourceCode cpp"><em>reflect-expression</em></code> is
-value-dependent if the operand following
-<code class="sourceCode cpp"><span class="op">^^</span></code> is a
-dependent name, names a dependent type, or contains a dependent
-<code class="sourceCode cpp"><em>pack-index-expression</em></code>.</span></p>
+value-dependent if its
+<code class="sourceCode cpp"><em>nested-name-specifier</em></code> (if
+any) is dependent or if it has a dependent
+<code class="sourceCode cpp"><em>type-id</em></code>, a dependent
+<code class="sourceCode cpp"><em>qualified-namespace-specifier</em></code>,
+a dependent <code class="sourceCode cpp"><em>template-name</em></code>,
+or a value-dependent or type-dependent
+<code class="sourceCode cpp"><em>id-expression</em></code>.</span></p>
 </blockquote>
 </div>
 <p>Add a new paragraph after <span>13.8.3.4 <a href="https://wg21.link/temp.dep.constexpr">[temp.dep.constexpr]</a></span>/5:</p>
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_231" id="pnum_231">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_270" id="pnum_270">6</a></span>
 A <code class="sourceCode cpp"><em>primary-expression</em></code> of the
 form <code class="sourceCode cpp"><em>splice-specifier</em></code> or
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em> <span class="op">&lt;</span> <em>template-argument-list</em><sub><em>opt</em></sub> <span class="op">&gt;</span></code>
+<code class="sourceCode cpp"><span class="kw">template</span> <em>splice-specifier</em> <span class="op">&lt;</span> <em>template-argument-list</em><sub><em>opt</em></sub> <span class="op">&gt;</span></code>
 is value-dependent if</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_232" id="pnum_232">(6.1)</a></span>
-the <code class="sourceCode cpp"><em>splice-specifier</em></code> or
-<code class="sourceCode cpp"><em>splice-expr-template-specifier</em></code>
-is dependent, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_233" id="pnum_233">(6.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_271" id="pnum_271">(6.1)</a></span>
+the <code class="sourceCode cpp"><em>splice-specifier</em></code> is
+dependent, or</li>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_272" id="pnum_272">(6.2)</a></span>
 the optional
 <code class="sourceCode cpp"><em>template-argument-list</em></code>
 contains a dependent type argument, a value-dependent non-type argument,
@@ -7659,6 +8227,145 @@ <h3 class="unnumbered" id="temp.dep.constexpr-value-dependent-expressions"><span
 </div>
 </blockquote>
 </div>
+<h3 class="unnumbered" id="temp.dep.splice-dependent-splice-specifiers">13.8.3.4+
+[temp.dep.splice] Dependent splice specifiers<a href="#temp.dep.splice-dependent-splice-specifiers" class="self-link"></a></h3>
+<p>Add a new subsection of <span>13.8.3 <a href="https://wg21.link/temp.dep">[temp.dep]</a></span> following
+<span>13.8.3.4 <a href="https://wg21.link/temp.dep.constexpr">[temp.dep.constexpr]</a></span>,
+and renumber accordingly.</p>
+<div class="std">
+<blockquote>
+<div class="addu">
+<p><strong>Dependent splice specifiers [temp.dep.splice]</strong></p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_273" id="pnum_273">1</a></span>
+A <code class="sourceCode cpp"><em>splice-specifier</em></code> is
+dependent if its converted
+<code class="sourceCode cpp"><em>constant-expression</em></code> is
+value-dependent. A
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>
+or <code class="sourceCode cpp"><em>splice-scope-specifier</em></code>
+is dependent if its
+<code class="sourceCode cpp"><em>splice-specifier</em></code> is
+dependent.</p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_274" id="pnum_274">2</a></span></p>
+<div class="example">
+<span>[ <em>Example 1:</em> </span>
+<div class="sourceCode" id="cb140"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb140-1"><a href="#cb140-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span> T, <span class="kw">auto</span> NS, <span class="kw">auto</span> C, <span class="kw">auto</span> V<span class="op">&gt;</span></span>
+<span id="cb140-2"><a href="#cb140-2" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> fn<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb140-3"><a href="#cb140-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">using</span> a <span class="op">=</span> <span class="op">[:</span>T<span class="op">:]&lt;</span><span class="dv">0</span><span class="op">&gt;</span>;  <span class="co">// [:T:] and [:T:]&lt;V&gt; are dependent</span></span>
+<span id="cb140-4"><a href="#cb140-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb140-5"><a href="#cb140-5" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static_assert</span><span class="op">(</span><span class="kw">template</span> <span class="op">[:</span>C<span class="op">:]&lt;</span><span class="kw">typename</span> <span class="op">[:</span>NS<span class="op">:]::</span><span class="kw">template</span> TCls<span class="op">&lt;</span><span class="dv">0</span><span class="op">&gt;&gt;)</span>;</span>
+<span id="cb140-6"><a href="#cb140-6" aria-hidden="true" tabindex="-1"></a>    <span class="co">// [:C:] and [:NS:] are dependent</span></span>
+<span id="cb140-7"><a href="#cb140-7" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb140-8"><a href="#cb140-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb140-9"><a href="#cb140-9" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> NS <span class="op">{</span></span>
+<span id="cb140-10"><a href="#cb140-10" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">auto</span> V<span class="op">&gt;</span> <span class="kw">struct</span> TCls <span class="op">{}</span>;</span>
+<span id="cb140-11"><a href="#cb140-11" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span><span class="op">&gt;</span> <span class="kw">concept</span> Concept <span class="op">=</span> <span class="kw">requires</span> <span class="op">{</span> <span class="kw">requires</span> <span class="kw">true</span>; <span class="op">}</span>;</span>
+<span id="cb140-12"><a href="#cb140-12" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb140-13"><a href="#cb140-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb140-14"><a href="#cb140-14" aria-hidden="true" tabindex="-1"></a><span class="dt">int</span> main<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb140-15"><a href="#cb140-15" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> v <span class="op">=</span> <span class="dv">1</span>;</span>
+<span id="cb140-16"><a href="#cb140-16" aria-hidden="true" tabindex="-1"></a>  fn<span class="op">&lt;^^</span>NS<span class="op">::</span>TCls, <span class="op">^^</span>NS, <span class="op">^^</span>NS<span class="op">::</span>Concept, <span class="op">^^</span>v<span class="op">&gt;()</span>;</span>
+<span id="cb140-17"><a href="#cb140-17" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
+<span> — <em>end example</em> ]</span>
+</div>
+</div>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="temp.expl.spec-explicit-specialization"><span>13.9.4 <a href="https://wg21.link/temp.expl.spec">[temp.expl.spec]</a></span>
+Explicit specialization<a href="#temp.expl.spec-explicit-specialization" class="self-link"></a></h3>
+<p>Modify paragraph 9 to allow
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s
+to be used like incompletely-defined classes.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_275" id="pnum_275">9</a></span>
+A <code class="sourceCode cpp"><em>simple-template-id</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+that <span class="rm" style="color: #bf0303"><del>names</del></span>
+<span class="addu">designates</span> a class template explicit
+specialization that has been declared but not defined can be used
+exactly like the names of other incompletely-defined classes (<span>6.8
+<a href="https://wg21.link/basic.types">[basic.types]</a></span>).</p>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="temp.deduct.general-general"><span>13.10.3.1
+<a href="https://wg21.link/temp.deduct.general">[temp.deduct.general]</a></span>
+General<a href="#temp.deduct.general-general" class="self-link"></a></h3>
+<p>Cover
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s
+in paragraph 2:</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_276" id="pnum_276">2</a></span>
+When an explicit template argument list is specified, if the given
+<code class="sourceCode cpp"><em>template-id</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>
+is not valid (<span>13.3 <a href="https://wg21.link/temp.names">[temp.names]</a></span>), type
+deduction fails. Otherwise, the specified template argument values are
+substituted for the corresponding template parameters as specified
+below.</p>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="temp.deduct.call-deducing-template-arguments-from-a-function-call"><span>13.10.3.2
+<a href="https://wg21.link/temp.deduct.call">[temp.deduct.call]</a></span>
+Deducing template arguments from a function call<a href="#temp.deduct.call-deducing-template-arguments-from-a-function-call" class="self-link"></a></h3>
+<p>Modify paragraph 4.3 to treat parameter types of function templates
+that are specified using
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>s
+the same as parameter types that are specified using
+<code class="sourceCode cpp"><em>simple-template-id</em></code>s.</p>
+<div class="std">
+<blockquote>
+<ul>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_277" id="pnum_277">(4.3)</a></span>
+If <code class="sourceCode cpp">P</code> is a class and
+<code class="sourceCode cpp">P</code> has the form
+<code class="sourceCode cpp"><em>simple-template-id</em></code> <span class="addu">or <code class="sourceCode cpp">typename<sub><em>opt</em></sub> <em>splice-specialization-specifier</em></code></span>,
+then the transformed <code class="sourceCode cpp">A</code> can be a
+dervied class <code class="sourceCode cpp">D</code> of the deduced
+<code class="sourceCode cpp">A</code>. Likewise, if
+<code class="sourceCode cpp">P</code> is a pointer to a class of the
+form <code class="sourceCode cpp"><em>simple-template-id</em></code>
+<span class="addu">or <code class="sourceCode cpp">typename<sub><em>opt</em></sub> <em>splice-specialization-specifier</em></code></span>,
+the transformed <code class="sourceCode cpp">A</code> can be a pointer
+to a derived class <code class="sourceCode cpp">D</code> pointed to by
+the deduced <code class="sourceCode cpp">A</code>. However, if there is
+a class <code class="sourceCode cpp">C</code> that is a (direct or
+indirect) base class of <code class="sourceCode cpp">D</code> and
+derived (directly or indirectly) from a class
+<code class="sourceCode cpp">B</code> and that would be a valid deduced
+<code class="sourceCode cpp">A</code>, the deduced
+<code class="sourceCode cpp">A</code> cannot be
+<code class="sourceCode cpp">B1</code> or pointer to
+<code class="sourceCode cpp">B</code>, respectively.</li>
+</ul>
+</blockquote>
+</div>
+<h3 class="unnumbered" id="temp.deduct.type-deducing-template-arguments-from-a-type"><span>13.10.3.6
+<a href="https://wg21.link/temp.deduct.type">[temp.deduct.type]</a></span>
+Deducing template arguments from a type<a href="#temp.deduct.type-deducing-template-arguments-from-a-type" class="self-link"></a></h3>
+<p>Modify paragraph 20 to clarify that the construct enclosing a
+template argument might also be a
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code>.</p>
+<div class="std">
+<blockquote>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_278" id="pnum_278">20</a></span>
+If <code class="sourceCode cpp">P</code> has a form that contains <code class="sourceCode cpp"><span class="op">&lt;</span>i<span class="op">&gt;</span></code>,
+and if the type of <code class="sourceCode cpp">i</code> differs from
+the type of the corresponding template parameter of the template named
+by the enclosing
+<code class="sourceCode cpp"><em>simple-template-id</em></code> <span class="addu">or
+<code class="sourceCode cpp"><em>splice-specialization-specifier</em></code></span>,
+deduction fails. If <code class="sourceCode cpp">P</code> has a form
+that contains <code class="sourceCode cpp"><span class="op">[</span>i<span class="op">]</span></code>,
+and if the type of <code class="sourceCode cpp">i</code> is not an
+integral type, deduction fails.<sup>123</sup> If
+<code class="sourceCode cpp">P</code> has a form that includes <code class="sourceCode cpp"><span class="kw">noexcept</span><span class="op">(</span>i<span class="op">)</span></code>
+and the type of <code class="sourceCode cpp">i</code> is not
+<code class="sourceCode cpp"><span class="dt">bool</span></code>,
+deduction fails.</p>
+</blockquote>
+</div>
 <h3 class="unnumbered" id="cpp.cond-conditional-inclusion"><span>15.2 <a href="https://wg21.link/cpp.cond">[cpp.cond]</a></span> Conditional
 inclusion<a href="#cpp.cond-conditional-inclusion" class="self-link"></a></h3>
 <p>Extend paragraph 9 to clarify that
@@ -7667,10 +8374,10 @@ <h3 class="unnumbered" id="cpp.cond-conditional-inclusion"><span>15.2 <a href="h
 to disallow lambdas in the same context.</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_234" id="pnum_234">9</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_279" id="pnum_279">9</a></span>
 Preprocessing directives of the forms</p>
-<div class="sourceCode" id="cb135"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb135-1"><a href="#cb135-1" aria-hidden="true" tabindex="-1"></a>     <span class="pp"># if      <em>constant-expression</em> <em>new-line</em> <em>group</em><sub><em>opt</em></sub></span></span>
-<span id="cb135-2"><a href="#cb135-2" aria-hidden="true" tabindex="-1"></a>     <span class="pp"># elif    <em>constant-expression</em> <em>new-line</em> <em>group</em><sub><em>opt</em></sub></span></span></code></pre></div>
+<div class="sourceCode" id="cb141"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb141-1"><a href="#cb141-1" aria-hidden="true" tabindex="-1"></a>     <span class="pp"># if      <em>constant-expression</em> <em>new-line</em> <em>group</em><sub><em>opt</em></sub></span></span>
+<span id="cb141-2"><a href="#cb141-2" aria-hidden="true" tabindex="-1"></a>     <span class="pp"># elif    <em>constant-expression</em> <em>new-line</em> <em>group</em><sub><em>opt</em></sub></span></span></code></pre></div>
 <p>check whether the controlling constant expression evaluates to
 nonzero. <span class="addu">The program is ill-formed if a
 <code class="sourceCode cpp"><em>splice-specifier</em></code> or
@@ -7685,24 +8392,24 @@ <h3 class="unnumbered" id="structure.specifications-detailed-specifications"><sp
 <span>16.3.2.4 <a href="https://wg21.link/structure.specifications">[structure.specifications]</a></span>/3:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_235" id="pnum_235">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_280" id="pnum_280">3</a></span>
 Descriptions of function semantics contain the following elements (as
 appropriate):</p>
 <ul>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_236" id="pnum_236">(3.1)</a></span>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_281" id="pnum_281">(3.1)</a></span>
 <em>Constraints</em>: […]</p></li>
-<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_237" id="pnum_237">(3.2)</a></span>
+<li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_282" id="pnum_282">(3.2)</a></span>
 <em>Mandates</em>: the conditions that, if not met, render the program
 ill-formed. […]</p></li>
 </ul>
 <div class="addu">
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_238" id="pnum_238">(3.2+1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_283" id="pnum_283">(3.2+1)</a></span>
 <em>Constant When</em>: the conditions that are required for a call to
 this function to be a core constant expression ([expr.const]).</li>
 </ul>
 </div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_239" id="pnum_239">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_284" id="pnum_284">4</a></span>
 […] Next, the semantics of the code sequence are determined by the
 <em>Constraints</em>, <em>Mandates</em>, <span class="addu"><em>Constant
 When</em>,</span> <em>Preconditions</em>, <em>Effects</em>,
@@ -7718,7 +8425,7 @@ <h3 class="unnumbered" id="namespace.std-namespace-std"><span>16.4.5.2.1
 <p>Insert before paragraph 7:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_240" id="pnum_240">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_285" id="pnum_285">6</a></span>
 Let F denote a standard library function ([global.functions]), a
 standard library static member function, or an instantiation of a
 standard library function template. Unless F is designated an
@@ -7726,7 +8433,7 @@ <h3 class="unnumbered" id="namespace.std-namespace-std"><span>16.4.5.2.1
 unspecified (possibly ill-formed) if it explicitly or implicitly
 attempts to form a pointer to F. […]</p>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_241" id="pnum_241">6a</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_286" id="pnum_286">6a</a></span>
 Let F denote a standard library function, member function, or function
 template. If F does not designate an addressable function, it is
 unspecified if or how a reflection value designating the associated
@@ -7735,14 +8442,14 @@ <h3 class="unnumbered" id="namespace.std-namespace-std"><span>16.4.5.2.1
 might not return reflections of standard functions that an
 implementation handles through an extra-linguistic mechanism.<span>
 — <em>end note</em> ]</span></span></p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_242" id="pnum_242">6b</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_287" id="pnum_287">6b</a></span>
 Let <code class="sourceCode cpp">C</code> denote a standard library
 class or class template specialization. It is unspecified if or how a
 reflection value can be formed to any private member of
 <code class="sourceCode cpp">C</code>, or what the names of such members
 may be.</p>
 </div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_243" id="pnum_243">7</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_288" id="pnum_288">7</a></span>
 A translation unit shall not declare namespace std to be an inline
 namespace ([namespace.def]).</p>
 </blockquote>
@@ -7757,20 +8464,20 @@ <h3 class="unnumbered" id="meta.type.synop-header-type_traits-synopsis"><span>21
 synopsis</strong></p>
 <p>…</p>
 <div>
-<div class="sourceCode" id="cb136"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb136-1"><a href="#cb136-1" aria-hidden="true" tabindex="-1"></a>    // [meta.unary.cat], primary type categories</span>
-<span id="cb136-2"><a href="#cb136-2" aria-hidden="true" tabindex="-1"></a>    template&lt;class T&gt; struct is_void;</span>
-<span id="cb136-3"><a href="#cb136-3" aria-hidden="true" tabindex="-1"></a>...</span>
-<span id="cb136-4"><a href="#cb136-4" aria-hidden="true" tabindex="-1"></a>    template&lt;class T&gt; struct is_function;</span>
-<span id="cb136-5"><a href="#cb136-5" aria-hidden="true" tabindex="-1"></a><span class="va">+   template&lt;class T&gt; struct is_reflection;</span></span>
-<span id="cb136-6"><a href="#cb136-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb136-7"><a href="#cb136-7" aria-hidden="true" tabindex="-1"></a>    // [meta.unary.cat], primary type categories</span>
-<span id="cb136-8"><a href="#cb136-8" aria-hidden="true" tabindex="-1"></a>    template&lt;class T&gt;</span>
-<span id="cb136-9"><a href="#cb136-9" aria-hidden="true" tabindex="-1"></a>      constexpr bool is_void_v = is_void&lt;T&gt;::value;</span>
-<span id="cb136-10"><a href="#cb136-10" aria-hidden="true" tabindex="-1"></a>...</span>
-<span id="cb136-11"><a href="#cb136-11" aria-hidden="true" tabindex="-1"></a>    template&lt;class T&gt;</span>
-<span id="cb136-12"><a href="#cb136-12" aria-hidden="true" tabindex="-1"></a>      constexpr bool is_function_v = is_function&lt;T&gt;::value;</span>
-<span id="cb136-13"><a href="#cb136-13" aria-hidden="true" tabindex="-1"></a><span class="va">+   template&lt;class T&gt;</span></span>
-<span id="cb136-14"><a href="#cb136-14" aria-hidden="true" tabindex="-1"></a><span class="va">+     constexpr bool is_reflection_v = is_reflection&lt;T&gt;::value;</span></span></code></pre></div>
+<div class="sourceCode" id="cb142"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb142-1"><a href="#cb142-1" aria-hidden="true" tabindex="-1"></a>    // [meta.unary.cat], primary type categories</span>
+<span id="cb142-2"><a href="#cb142-2" aria-hidden="true" tabindex="-1"></a>    template&lt;class T&gt; struct is_void;</span>
+<span id="cb142-3"><a href="#cb142-3" aria-hidden="true" tabindex="-1"></a>...</span>
+<span id="cb142-4"><a href="#cb142-4" aria-hidden="true" tabindex="-1"></a>    template&lt;class T&gt; struct is_function;</span>
+<span id="cb142-5"><a href="#cb142-5" aria-hidden="true" tabindex="-1"></a><span class="va">+   template&lt;class T&gt; struct is_reflection;</span></span>
+<span id="cb142-6"><a href="#cb142-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb142-7"><a href="#cb142-7" aria-hidden="true" tabindex="-1"></a>    // [meta.unary.cat], primary type categories</span>
+<span id="cb142-8"><a href="#cb142-8" aria-hidden="true" tabindex="-1"></a>    template&lt;class T&gt;</span>
+<span id="cb142-9"><a href="#cb142-9" aria-hidden="true" tabindex="-1"></a>      constexpr bool is_void_v = is_void&lt;T&gt;::value;</span>
+<span id="cb142-10"><a href="#cb142-10" aria-hidden="true" tabindex="-1"></a>...</span>
+<span id="cb142-11"><a href="#cb142-11" aria-hidden="true" tabindex="-1"></a>    template&lt;class T&gt;</span>
+<span id="cb142-12"><a href="#cb142-12" aria-hidden="true" tabindex="-1"></a>      constexpr bool is_function_v = is_function&lt;T&gt;::value;</span>
+<span id="cb142-13"><a href="#cb142-13" aria-hidden="true" tabindex="-1"></a><span class="va">+   template&lt;class T&gt;</span></span>
+<span id="cb142-14"><a href="#cb142-14" aria-hidden="true" tabindex="-1"></a><span class="va">+     constexpr bool is_reflection_v = is_reflection&lt;T&gt;::value;</span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -7792,8 +8499,8 @@ <h3 class="unnumbered" id="meta.unary.cat-primary-type-categories"><span>21.3.5.
 </tr>
 <tr>
 <td>
-<div class="sourceCode" id="cb137"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb137-1"><a href="#cb137-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
-<span id="cb137-2"><a href="#cb137-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> is_void;</span></code></pre></div>
+<div class="sourceCode" id="cb143"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb143-1"><a href="#cb143-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
+<span id="cb143-2"><a href="#cb143-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> is_void;</span></code></pre></div>
 </td>
 <td style="text-align:center; vertical-align: middle">
 <code class="sourceCode cpp">T</code> is
@@ -7816,8 +8523,8 @@ <h3 class="unnumbered" id="meta.unary.cat-primary-type-categories"><span>21.3.5.
 <tr>
 <td>
 <div class="addu">
-<div class="sourceCode" id="cb138"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb138-1"><a href="#cb138-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
-<span id="cb138-2"><a href="#cb138-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> is_reflection;</span></code></pre></div>
+<div class="sourceCode" id="cb144"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb144-1"><a href="#cb144-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
+<span id="cb144-2"><a href="#cb144-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> is_reflection;</span></code></pre></div>
 </div>
 </td>
 <td style="text-align:center; vertical-align: middle">
@@ -7841,359 +8548,359 @@ <h3 class="unnumbered" id="meta.reflection.synop-header-meta-synopsis">[meta.ref
 <div class="addu">
 <p><strong>Header <code class="sourceCode cpp"><span class="op">&lt;</span>meta<span class="op">&gt;</span></code>
 synopsis</strong></p>
-<div class="sourceCode" id="cb139"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb139-1"><a href="#cb139-1" aria-hidden="true" tabindex="-1"></a>#include &lt;initializer_list&gt;</span>
-<span id="cb139-2"><a href="#cb139-2" aria-hidden="true" tabindex="-1"></a>#include &lt;ranges&gt;</span>
-<span id="cb139-3"><a href="#cb139-3" aria-hidden="true" tabindex="-1"></a>#include &lt;string_view&gt;</span>
-<span id="cb139-4"><a href="#cb139-4" aria-hidden="true" tabindex="-1"></a>#include &lt;vector&gt;</span>
-<span id="cb139-5"><a href="#cb139-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-6"><a href="#cb139-6" aria-hidden="true" tabindex="-1"></a>namespace std::meta {</span>
-<span id="cb139-7"><a href="#cb139-7" aria-hidden="true" tabindex="-1"></a>  using info = decltype(^^::);</span>
-<span id="cb139-8"><a href="#cb139-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-9"><a href="#cb139-9" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.operators], operator representations</span>
-<span id="cb139-10"><a href="#cb139-10" aria-hidden="true" tabindex="-1"></a>  enum class operators {</span>
-<span id="cb139-11"><a href="#cb139-11" aria-hidden="true" tabindex="-1"></a>    <em>see below</em>;</span>
-<span id="cb139-12"><a href="#cb139-12" aria-hidden="true" tabindex="-1"></a>  };</span>
-<span id="cb139-13"><a href="#cb139-13" aria-hidden="true" tabindex="-1"></a>  using enum operators;</span>
-<span id="cb139-14"><a href="#cb139-14" aria-hidden="true" tabindex="-1"></a>  consteval operators operator_of(info r);</span>
-<span id="cb139-15"><a href="#cb139-15" aria-hidden="true" tabindex="-1"></a>  consteval string_view symbol_of(operators op);</span>
-<span id="cb139-16"><a href="#cb139-16" aria-hidden="true" tabindex="-1"></a>  consteval u8string_view u8symbol_of(operators op);</span>
-<span id="cb139-17"><a href="#cb139-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-18"><a href="#cb139-18" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.names], reflection names and locations</span>
-<span id="cb139-19"><a href="#cb139-19" aria-hidden="true" tabindex="-1"></a>  consteval bool has_identifier(info r);</span>
-<span id="cb139-20"><a href="#cb139-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-21"><a href="#cb139-21" aria-hidden="true" tabindex="-1"></a>  consteval string_view identifier_of(info r);</span>
-<span id="cb139-22"><a href="#cb139-22" aria-hidden="true" tabindex="-1"></a>  consteval u8string_view u8identifier_of(info r);</span>
-<span id="cb139-23"><a href="#cb139-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-24"><a href="#cb139-24" aria-hidden="true" tabindex="-1"></a>  consteval string_view display_string_of(info r);</span>
-<span id="cb139-25"><a href="#cb139-25" aria-hidden="true" tabindex="-1"></a>  consteval u8string_view u8display_string_of(info r);</span>
-<span id="cb139-26"><a href="#cb139-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-27"><a href="#cb139-27" aria-hidden="true" tabindex="-1"></a>  consteval source_location source_location_of(info r);</span>
-<span id="cb139-28"><a href="#cb139-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-29"><a href="#cb139-29" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.queries], reflection queries</span>
-<span id="cb139-30"><a href="#cb139-30" aria-hidden="true" tabindex="-1"></a>  consteval bool is_public(info r);</span>
-<span id="cb139-31"><a href="#cb139-31" aria-hidden="true" tabindex="-1"></a>  consteval bool is_protected(info r);</span>
-<span id="cb139-32"><a href="#cb139-32" aria-hidden="true" tabindex="-1"></a>  consteval bool is_private(info r);</span>
-<span id="cb139-33"><a href="#cb139-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-34"><a href="#cb139-34" aria-hidden="true" tabindex="-1"></a>  consteval bool is_virtual(info r);</span>
-<span id="cb139-35"><a href="#cb139-35" aria-hidden="true" tabindex="-1"></a>  consteval bool is_pure_virtual(info r);</span>
-<span id="cb139-36"><a href="#cb139-36" aria-hidden="true" tabindex="-1"></a>  consteval bool is_override(info r);</span>
-<span id="cb139-37"><a href="#cb139-37" aria-hidden="true" tabindex="-1"></a>  consteval bool is_final(info r);</span>
-<span id="cb139-38"><a href="#cb139-38" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-39"><a href="#cb139-39" aria-hidden="true" tabindex="-1"></a>  consteval bool is_deleted(info r);</span>
-<span id="cb139-40"><a href="#cb139-40" aria-hidden="true" tabindex="-1"></a>  consteval bool is_defaulted(info r);</span>
-<span id="cb139-41"><a href="#cb139-41" aria-hidden="true" tabindex="-1"></a>  consteval bool is_user_provided(info r);</span>
-<span id="cb139-42"><a href="#cb139-42" aria-hidden="true" tabindex="-1"></a>  consteval bool is_user_declared(info r);</span>
-<span id="cb139-43"><a href="#cb139-43" aria-hidden="true" tabindex="-1"></a>  consteval bool is_explicit(info r);</span>
-<span id="cb139-44"><a href="#cb139-44" aria-hidden="true" tabindex="-1"></a>  consteval bool is_noexcept(info r);</span>
-<span id="cb139-45"><a href="#cb139-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-46"><a href="#cb139-46" aria-hidden="true" tabindex="-1"></a>  consteval bool is_bit_field(info r);</span>
-<span id="cb139-47"><a href="#cb139-47" aria-hidden="true" tabindex="-1"></a>  consteval bool is_enumerator(info r);</span>
-<span id="cb139-48"><a href="#cb139-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-49"><a href="#cb139-49" aria-hidden="true" tabindex="-1"></a>  consteval bool is_const(info r);</span>
-<span id="cb139-50"><a href="#cb139-50" aria-hidden="true" tabindex="-1"></a>  consteval bool is_volatile(info r);</span>
-<span id="cb139-51"><a href="#cb139-51" aria-hidden="true" tabindex="-1"></a>  consteval bool is_mutable_member(info r);</span>
-<span id="cb139-52"><a href="#cb139-52" aria-hidden="true" tabindex="-1"></a>  consteval bool is_lvalue_reference_qualified(info r);</span>
-<span id="cb139-53"><a href="#cb139-53" aria-hidden="true" tabindex="-1"></a>  consteval bool is_rvalue_reference_qualified(info r);</span>
-<span id="cb139-54"><a href="#cb139-54" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-55"><a href="#cb139-55" aria-hidden="true" tabindex="-1"></a>  consteval bool has_static_storage_duration(info r);</span>
-<span id="cb139-56"><a href="#cb139-56" aria-hidden="true" tabindex="-1"></a>  consteval bool has_thread_storage_duration(info r);</span>
-<span id="cb139-57"><a href="#cb139-57" aria-hidden="true" tabindex="-1"></a>  consteval bool has_automatic_storage_duration(info r);</span>
-<span id="cb139-58"><a href="#cb139-58" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-59"><a href="#cb139-59" aria-hidden="true" tabindex="-1"></a>  consteval bool has_internal_linkage(info r);</span>
-<span id="cb139-60"><a href="#cb139-60" aria-hidden="true" tabindex="-1"></a>  consteval bool has_module_linkage(info r);</span>
-<span id="cb139-61"><a href="#cb139-61" aria-hidden="true" tabindex="-1"></a>  consteval bool has_external_linkage(info r);</span>
-<span id="cb139-62"><a href="#cb139-62" aria-hidden="true" tabindex="-1"></a>  consteval bool has_linkage(info r);</span>
-<span id="cb139-63"><a href="#cb139-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-64"><a href="#cb139-64" aria-hidden="true" tabindex="-1"></a>  consteval bool is_complete_type(info r);</span>
-<span id="cb139-65"><a href="#cb139-65" aria-hidden="true" tabindex="-1"></a>  consteval bool has_complete_definition(info r);</span>
-<span id="cb139-66"><a href="#cb139-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-67"><a href="#cb139-67" aria-hidden="true" tabindex="-1"></a>  consteval bool is_namespace(info r);</span>
-<span id="cb139-68"><a href="#cb139-68" aria-hidden="true" tabindex="-1"></a>  consteval bool is_variable(info r);</span>
-<span id="cb139-69"><a href="#cb139-69" aria-hidden="true" tabindex="-1"></a>  consteval bool is_type(info r);</span>
-<span id="cb139-70"><a href="#cb139-70" aria-hidden="true" tabindex="-1"></a>  consteval bool is_type_alias(info r);</span>
-<span id="cb139-71"><a href="#cb139-71" aria-hidden="true" tabindex="-1"></a>  consteval bool is_namespace_alias(info r);</span>
-<span id="cb139-72"><a href="#cb139-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-73"><a href="#cb139-73" aria-hidden="true" tabindex="-1"></a>  consteval bool is_function(info r);</span>
-<span id="cb139-74"><a href="#cb139-74" aria-hidden="true" tabindex="-1"></a>  consteval bool is_conversion_function(info r);</span>
-<span id="cb139-75"><a href="#cb139-75" aria-hidden="true" tabindex="-1"></a>  consteval bool is_operator_function(info r);</span>
-<span id="cb139-76"><a href="#cb139-76" aria-hidden="true" tabindex="-1"></a>  consteval bool is_literal_operator(info r);</span>
-<span id="cb139-77"><a href="#cb139-77" aria-hidden="true" tabindex="-1"></a>  consteval bool is_special_member_function(info r);</span>
-<span id="cb139-78"><a href="#cb139-78" aria-hidden="true" tabindex="-1"></a>  consteval bool is_constructor(info r);</span>
-<span id="cb139-79"><a href="#cb139-79" aria-hidden="true" tabindex="-1"></a>  consteval bool is_default_constructor(info r);</span>
-<span id="cb139-80"><a href="#cb139-80" aria-hidden="true" tabindex="-1"></a>  consteval bool is_copy_constructor(info r);</span>
-<span id="cb139-81"><a href="#cb139-81" aria-hidden="true" tabindex="-1"></a>  consteval bool is_move_constructor(info r);</span>
-<span id="cb139-82"><a href="#cb139-82" aria-hidden="true" tabindex="-1"></a>  consteval bool is_assignment(info r);</span>
-<span id="cb139-83"><a href="#cb139-83" aria-hidden="true" tabindex="-1"></a>  consteval bool is_copy_assignment(info r);</span>
-<span id="cb139-84"><a href="#cb139-84" aria-hidden="true" tabindex="-1"></a>  consteval bool is_move_assignment(info r);</span>
-<span id="cb139-85"><a href="#cb139-85" aria-hidden="true" tabindex="-1"></a>  consteval bool is_destructor(info r);</span>
-<span id="cb139-86"><a href="#cb139-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-87"><a href="#cb139-87" aria-hidden="true" tabindex="-1"></a>  consteval bool is_template(info r);</span>
-<span id="cb139-88"><a href="#cb139-88" aria-hidden="true" tabindex="-1"></a>  consteval bool is_function_template(info r);</span>
-<span id="cb139-89"><a href="#cb139-89" aria-hidden="true" tabindex="-1"></a>  consteval bool is_variable_template(info r);</span>
-<span id="cb139-90"><a href="#cb139-90" aria-hidden="true" tabindex="-1"></a>  consteval bool is_class_template(info r);</span>
-<span id="cb139-91"><a href="#cb139-91" aria-hidden="true" tabindex="-1"></a>  consteval bool is_alias_template(info r);</span>
-<span id="cb139-92"><a href="#cb139-92" aria-hidden="true" tabindex="-1"></a>  consteval bool is_conversion_function_template(info r);</span>
-<span id="cb139-93"><a href="#cb139-93" aria-hidden="true" tabindex="-1"></a>  consteval bool is_operator_function_template(info r);</span>
-<span id="cb139-94"><a href="#cb139-94" aria-hidden="true" tabindex="-1"></a>  consteval bool is_literal_operator_template(info r);</span>
-<span id="cb139-95"><a href="#cb139-95" aria-hidden="true" tabindex="-1"></a>  consteval bool is_constructor_template(info r);</span>
-<span id="cb139-96"><a href="#cb139-96" aria-hidden="true" tabindex="-1"></a>  consteval bool is_concept(info r);</span>
-<span id="cb139-97"><a href="#cb139-97" aria-hidden="true" tabindex="-1"></a>  consteval bool has_template_arguments(info r);</span>
-<span id="cb139-98"><a href="#cb139-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-99"><a href="#cb139-99" aria-hidden="true" tabindex="-1"></a>  consteval bool is_value(info r);</span>
-<span id="cb139-100"><a href="#cb139-100" aria-hidden="true" tabindex="-1"></a>  consteval bool is_object(info r);</span>
-<span id="cb139-101"><a href="#cb139-101" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-102"><a href="#cb139-102" aria-hidden="true" tabindex="-1"></a>  consteval bool is_structured_binding(info r);</span>
-<span id="cb139-103"><a href="#cb139-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-104"><a href="#cb139-104" aria-hidden="true" tabindex="-1"></a>  consteval bool is_class_member(info r);</span>
-<span id="cb139-105"><a href="#cb139-105" aria-hidden="true" tabindex="-1"></a>  consteval bool is_namespace_member(info r);</span>
-<span id="cb139-106"><a href="#cb139-106" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nonstatic_data_member(info r);</span>
-<span id="cb139-107"><a href="#cb139-107" aria-hidden="true" tabindex="-1"></a>  consteval bool is_static_member(info r);</span>
-<span id="cb139-108"><a href="#cb139-108" aria-hidden="true" tabindex="-1"></a>  consteval bool is_base(info r);</span>
-<span id="cb139-109"><a href="#cb139-109" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-110"><a href="#cb139-110" aria-hidden="true" tabindex="-1"></a>  consteval bool has_default_member_initializer(info r);</span>
-<span id="cb139-111"><a href="#cb139-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-112"><a href="#cb139-112" aria-hidden="true" tabindex="-1"></a>  consteval info type_of(info r);</span>
-<span id="cb139-113"><a href="#cb139-113" aria-hidden="true" tabindex="-1"></a>  consteval info object_of(info r);</span>
-<span id="cb139-114"><a href="#cb139-114" aria-hidden="true" tabindex="-1"></a>  consteval info value_of(info r);</span>
-<span id="cb139-115"><a href="#cb139-115" aria-hidden="true" tabindex="-1"></a>  consteval info parent_of(info r);</span>
-<span id="cb139-116"><a href="#cb139-116" aria-hidden="true" tabindex="-1"></a>  consteval info dealias(info r);</span>
-<span id="cb139-117"><a href="#cb139-117" aria-hidden="true" tabindex="-1"></a>  consteval info template_of(info r);</span>
-<span id="cb139-118"><a href="#cb139-118" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; template_arguments_of(info r);</span>
-<span id="cb139-119"><a href="#cb139-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-120"><a href="#cb139-120" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.member.queries], reflection member queries</span>
-<span id="cb139-121"><a href="#cb139-121" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; members_of(info r);</span>
-<span id="cb139-122"><a href="#cb139-122" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; bases_of(info type);</span>
-<span id="cb139-123"><a href="#cb139-123" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; static_data_members_of(info type);</span>
-<span id="cb139-124"><a href="#cb139-124" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; nonstatic_data_members_of(info type);</span>
-<span id="cb139-125"><a href="#cb139-125" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; enumerators_of(info type_enum);</span>
-<span id="cb139-126"><a href="#cb139-126" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-127"><a href="#cb139-127" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; get_public_members(info type);</span>
-<span id="cb139-128"><a href="#cb139-128" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; get_public_bases(info type);</span>
-<span id="cb139-129"><a href="#cb139-129" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; get_public_static_data_members(info type);</span>
-<span id="cb139-130"><a href="#cb139-130" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; get_public_nonstatic_data_members(info type);</span>
-<span id="cb139-131"><a href="#cb139-131" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-132"><a href="#cb139-132" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.layout], reflection layout queries</span>
-<span id="cb139-133"><a href="#cb139-133" aria-hidden="true" tabindex="-1"></a>  struct member_offset {</span>
-<span id="cb139-134"><a href="#cb139-134" aria-hidden="true" tabindex="-1"></a>    ptrdiff_t bytes;</span>
-<span id="cb139-135"><a href="#cb139-135" aria-hidden="true" tabindex="-1"></a>    ptrdiff_t bits;</span>
-<span id="cb139-136"><a href="#cb139-136" aria-hidden="true" tabindex="-1"></a>    constexpr ptrdiff_t total_bits() const;</span>
-<span id="cb139-137"><a href="#cb139-137" aria-hidden="true" tabindex="-1"></a>    auto operator&lt;=&gt;(member_offset const&amp;) const = default;</span>
-<span id="cb139-138"><a href="#cb139-138" aria-hidden="true" tabindex="-1"></a>  };</span>
-<span id="cb139-139"><a href="#cb139-139" aria-hidden="true" tabindex="-1"></a>  consteval member_offset offset_of(info r);</span>
-<span id="cb139-140"><a href="#cb139-140" aria-hidden="true" tabindex="-1"></a>  consteval size_t size_of(info r);</span>
-<span id="cb139-141"><a href="#cb139-141" aria-hidden="true" tabindex="-1"></a>  consteval size_t alignment_of(info r);</span>
-<span id="cb139-142"><a href="#cb139-142" aria-hidden="true" tabindex="-1"></a>  consteval size_t bit_size_of(info r);</span>
-<span id="cb139-143"><a href="#cb139-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-144"><a href="#cb139-144" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.extract], value extraction</span>
-<span id="cb139-145"><a href="#cb139-145" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt;</span>
-<span id="cb139-146"><a href="#cb139-146" aria-hidden="true" tabindex="-1"></a>    consteval T extract(info);</span>
-<span id="cb139-147"><a href="#cb139-147" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-148"><a href="#cb139-148" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.substitute], reflection substitution</span>
-<span id="cb139-149"><a href="#cb139-149" aria-hidden="true" tabindex="-1"></a>  template &lt;class R&gt;</span>
-<span id="cb139-150"><a href="#cb139-150" aria-hidden="true" tabindex="-1"></a>    concept reflection_range = <em>see below</em>;</span>
-<span id="cb139-151"><a href="#cb139-151" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-152"><a href="#cb139-152" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-153"><a href="#cb139-153" aria-hidden="true" tabindex="-1"></a>    consteval bool can_substitute(info templ, R&amp;&amp; arguments);</span>
-<span id="cb139-154"><a href="#cb139-154" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-155"><a href="#cb139-155" aria-hidden="true" tabindex="-1"></a>    consteval info substitute(info templ, R&amp;&amp; arguments);</span>
-<span id="cb139-156"><a href="#cb139-156" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-157"><a href="#cb139-157" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.result], expression result reflection</span>
-<span id="cb139-158"><a href="#cb139-158" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt;</span>
-<span id="cb139-159"><a href="#cb139-159" aria-hidden="true" tabindex="-1"></a>    consteval info reflect_value(const T&amp; value);</span>
-<span id="cb139-160"><a href="#cb139-160" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt;</span>
-<span id="cb139-161"><a href="#cb139-161" aria-hidden="true" tabindex="-1"></a>    consteval info reflect_object(T&amp; object);</span>
-<span id="cb139-162"><a href="#cb139-162" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt;</span>
-<span id="cb139-163"><a href="#cb139-163" aria-hidden="true" tabindex="-1"></a>    consteval info reflect_function(T&amp; fn);</span>
-<span id="cb139-164"><a href="#cb139-164" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-165"><a href="#cb139-165" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.define.aggregate], class definition generation</span>
-<span id="cb139-166"><a href="#cb139-166" aria-hidden="true" tabindex="-1"></a>  struct data_member_options {</span>
-<span id="cb139-167"><a href="#cb139-167" aria-hidden="true" tabindex="-1"></a>    struct name_type {</span>
-<span id="cb139-168"><a href="#cb139-168" aria-hidden="true" tabindex="-1"></a>      template&lt;class T&gt; requires constructible_from&lt;u8string, T&gt;</span>
-<span id="cb139-169"><a href="#cb139-169" aria-hidden="true" tabindex="-1"></a>        consteval name_type(T &amp;&amp;);</span>
-<span id="cb139-170"><a href="#cb139-170" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-171"><a href="#cb139-171" aria-hidden="true" tabindex="-1"></a>      template&lt;class T&gt; requires constructible_from&lt;string, T&gt;</span>
-<span id="cb139-172"><a href="#cb139-172" aria-hidden="true" tabindex="-1"></a>        consteval name_type(T &amp;&amp;);</span>
-<span id="cb139-173"><a href="#cb139-173" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-174"><a href="#cb139-174" aria-hidden="true" tabindex="-1"></a>      variant&lt;u8string, string&gt; <em>contents</em>;    // <em>exposition only</em></span>
-<span id="cb139-175"><a href="#cb139-175" aria-hidden="true" tabindex="-1"></a>    };</span>
-<span id="cb139-176"><a href="#cb139-176" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-177"><a href="#cb139-177" aria-hidden="true" tabindex="-1"></a>    optional&lt;name_type&gt; name;</span>
-<span id="cb139-178"><a href="#cb139-178" aria-hidden="true" tabindex="-1"></a>    optional&lt;int&gt; alignment;</span>
-<span id="cb139-179"><a href="#cb139-179" aria-hidden="true" tabindex="-1"></a>    optional&lt;int&gt; bit_width;</span>
-<span id="cb139-180"><a href="#cb139-180" aria-hidden="true" tabindex="-1"></a>    bool no_unique_address = false;</span>
-<span id="cb139-181"><a href="#cb139-181" aria-hidden="true" tabindex="-1"></a>  };</span>
-<span id="cb139-182"><a href="#cb139-182" aria-hidden="true" tabindex="-1"></a>  consteval info data_member_spec(info type,</span>
-<span id="cb139-183"><a href="#cb139-183" aria-hidden="true" tabindex="-1"></a>                                  data_member_options options = {});</span>
-<span id="cb139-184"><a href="#cb139-184" aria-hidden="true" tabindex="-1"></a>  consteval bool is_data_member_spec(info r);</span>
-<span id="cb139-185"><a href="#cb139-185" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-186"><a href="#cb139-186" aria-hidden="true" tabindex="-1"></a>  consteval info define_aggregate(info type_class, R&amp;&amp;);</span>
-<span id="cb139-187"><a href="#cb139-187" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-188"><a href="#cb139-188" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.unary.cat], primary type categories</span>
-<span id="cb139-189"><a href="#cb139-189" aria-hidden="true" tabindex="-1"></a>  consteval bool is_void_type(info type);</span>
-<span id="cb139-190"><a href="#cb139-190" aria-hidden="true" tabindex="-1"></a>  consteval bool is_null_pointer_type(info type);</span>
-<span id="cb139-191"><a href="#cb139-191" aria-hidden="true" tabindex="-1"></a>  consteval bool is_integral_type(info type);</span>
-<span id="cb139-192"><a href="#cb139-192" aria-hidden="true" tabindex="-1"></a>  consteval bool is_floating_point_type(info type);</span>
-<span id="cb139-193"><a href="#cb139-193" aria-hidden="true" tabindex="-1"></a>  consteval bool is_array_type(info type);</span>
-<span id="cb139-194"><a href="#cb139-194" aria-hidden="true" tabindex="-1"></a>  consteval bool is_pointer_type(info type);</span>
-<span id="cb139-195"><a href="#cb139-195" aria-hidden="true" tabindex="-1"></a>  consteval bool is_lvalue_reference_type(info type);</span>
-<span id="cb139-196"><a href="#cb139-196" aria-hidden="true" tabindex="-1"></a>  consteval bool is_rvalue_reference_type(info type);</span>
-<span id="cb139-197"><a href="#cb139-197" aria-hidden="true" tabindex="-1"></a>  consteval bool is_member_object_pointer_type(info type);</span>
-<span id="cb139-198"><a href="#cb139-198" aria-hidden="true" tabindex="-1"></a>  consteval bool is_member_function_pointer_type(info type);</span>
-<span id="cb139-199"><a href="#cb139-199" aria-hidden="true" tabindex="-1"></a>  consteval bool is_enum_type(info type);</span>
-<span id="cb139-200"><a href="#cb139-200" aria-hidden="true" tabindex="-1"></a>  consteval bool is_union_type(info type);</span>
-<span id="cb139-201"><a href="#cb139-201" aria-hidden="true" tabindex="-1"></a>  consteval bool is_class_type(info type);</span>
-<span id="cb139-202"><a href="#cb139-202" aria-hidden="true" tabindex="-1"></a>  consteval bool is_function_type(info type);</span>
-<span id="cb139-203"><a href="#cb139-203" aria-hidden="true" tabindex="-1"></a>  consteval bool is_reflection_type(info type);</span>
-<span id="cb139-204"><a href="#cb139-204" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-205"><a href="#cb139-205" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.unary.comp], composite type categories</span>
-<span id="cb139-206"><a href="#cb139-206" aria-hidden="true" tabindex="-1"></a>  consteval bool is_reference_type(info type);</span>
-<span id="cb139-207"><a href="#cb139-207" aria-hidden="true" tabindex="-1"></a>  consteval bool is_arithmetic_type(info type);</span>
-<span id="cb139-208"><a href="#cb139-208" aria-hidden="true" tabindex="-1"></a>  consteval bool is_fundamental_type(info type);</span>
-<span id="cb139-209"><a href="#cb139-209" aria-hidden="true" tabindex="-1"></a>  consteval bool is_object_type(info type);</span>
-<span id="cb139-210"><a href="#cb139-210" aria-hidden="true" tabindex="-1"></a>  consteval bool is_scalar_type(info type);</span>
-<span id="cb139-211"><a href="#cb139-211" aria-hidden="true" tabindex="-1"></a>  consteval bool is_compound_type(info type);</span>
-<span id="cb139-212"><a href="#cb139-212" aria-hidden="true" tabindex="-1"></a>  consteval bool is_member_pointer_type(info type);</span>
-<span id="cb139-213"><a href="#cb139-213" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-214"><a href="#cb139-214" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection unary.prop], type properties</span>
-<span id="cb139-215"><a href="#cb139-215" aria-hidden="true" tabindex="-1"></a>  consteval bool is_const_type(info type);</span>
-<span id="cb139-216"><a href="#cb139-216" aria-hidden="true" tabindex="-1"></a>  consteval bool is_volatile_type(info type);</span>
-<span id="cb139-217"><a href="#cb139-217" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivial_type(info type);</span>
-<span id="cb139-218"><a href="#cb139-218" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_copyable_type(info type);</span>
-<span id="cb139-219"><a href="#cb139-219" aria-hidden="true" tabindex="-1"></a>  consteval bool is_standard_layout_type(info type);</span>
-<span id="cb139-220"><a href="#cb139-220" aria-hidden="true" tabindex="-1"></a>  consteval bool is_empty_type(info type);</span>
-<span id="cb139-221"><a href="#cb139-221" aria-hidden="true" tabindex="-1"></a>  consteval bool is_polymorphic_type(info type);</span>
-<span id="cb139-222"><a href="#cb139-222" aria-hidden="true" tabindex="-1"></a>  consteval bool is_abstract_type(info type);</span>
-<span id="cb139-223"><a href="#cb139-223" aria-hidden="true" tabindex="-1"></a>  consteval bool is_final_type(info type);</span>
-<span id="cb139-224"><a href="#cb139-224" aria-hidden="true" tabindex="-1"></a>  consteval bool is_aggregate_type(info type);</span>
-<span id="cb139-225"><a href="#cb139-225" aria-hidden="true" tabindex="-1"></a>  consteval bool is_signed_type(info type);</span>
-<span id="cb139-226"><a href="#cb139-226" aria-hidden="true" tabindex="-1"></a>  consteval bool is_unsigned_type(info type);</span>
-<span id="cb139-227"><a href="#cb139-227" aria-hidden="true" tabindex="-1"></a>  consteval bool is_bounded_array_type(info type);</span>
-<span id="cb139-228"><a href="#cb139-228" aria-hidden="true" tabindex="-1"></a>  consteval bool is_unbounded_array_type(info type);</span>
-<span id="cb139-229"><a href="#cb139-229" aria-hidden="true" tabindex="-1"></a>  consteval bool is_scoped_enum_type(info type);</span>
-<span id="cb139-230"><a href="#cb139-230" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-231"><a href="#cb139-231" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-232"><a href="#cb139-232" aria-hidden="true" tabindex="-1"></a>    consteval bool is_constructible_type(info type, R&amp;&amp; type_args);</span>
-<span id="cb139-233"><a href="#cb139-233" aria-hidden="true" tabindex="-1"></a>  consteval bool is_default_constructible_type(info type);</span>
-<span id="cb139-234"><a href="#cb139-234" aria-hidden="true" tabindex="-1"></a>  consteval bool is_copy_constructible_type(info type);</span>
-<span id="cb139-235"><a href="#cb139-235" aria-hidden="true" tabindex="-1"></a>  consteval bool is_move_constructible_type(info type);</span>
-<span id="cb139-236"><a href="#cb139-236" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-237"><a href="#cb139-237" aria-hidden="true" tabindex="-1"></a>  consteval bool is_assignable_type(info type_dst, info type_src);</span>
-<span id="cb139-238"><a href="#cb139-238" aria-hidden="true" tabindex="-1"></a>  consteval bool is_copy_assignable_type(info type);</span>
-<span id="cb139-239"><a href="#cb139-239" aria-hidden="true" tabindex="-1"></a>  consteval bool is_move_assignable_type(info type);</span>
-<span id="cb139-240"><a href="#cb139-240" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-241"><a href="#cb139-241" aria-hidden="true" tabindex="-1"></a>  consteval bool is_swappable_with_type(info type_dst, info type_src);</span>
-<span id="cb139-242"><a href="#cb139-242" aria-hidden="true" tabindex="-1"></a>  consteval bool is_swappable_type(info type);</span>
-<span id="cb139-243"><a href="#cb139-243" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-244"><a href="#cb139-244" aria-hidden="true" tabindex="-1"></a>  consteval bool is_destructible_type(info type);</span>
-<span id="cb139-245"><a href="#cb139-245" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-246"><a href="#cb139-246" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-247"><a href="#cb139-247" aria-hidden="true" tabindex="-1"></a>    consteval bool is_trivially_constructible_type(info type, R&amp;&amp; type_args);</span>
-<span id="cb139-248"><a href="#cb139-248" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_default_constructible_type(info type);</span>
-<span id="cb139-249"><a href="#cb139-249" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_copy_constructible_type(info type);</span>
-<span id="cb139-250"><a href="#cb139-250" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_move_constructible_type(info type);</span>
-<span id="cb139-251"><a href="#cb139-251" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-252"><a href="#cb139-252" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_assignable_type(info type_dst, info type_src);</span>
-<span id="cb139-253"><a href="#cb139-253" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_copy_assignable_type(info type);</span>
-<span id="cb139-254"><a href="#cb139-254" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_move_assignable_type(info type);</span>
-<span id="cb139-255"><a href="#cb139-255" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_destructible_type(info type);</span>
-<span id="cb139-256"><a href="#cb139-256" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-257"><a href="#cb139-257" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-258"><a href="#cb139-258" aria-hidden="true" tabindex="-1"></a>    consteval bool is_nothrow_constructible_type(info type, R&amp;&amp; type_args);</span>
-<span id="cb139-259"><a href="#cb139-259" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_default_constructible_type(info type);</span>
-<span id="cb139-260"><a href="#cb139-260" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_copy_constructible_type(info type);</span>
-<span id="cb139-261"><a href="#cb139-261" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_move_constructible_type(info type);</span>
-<span id="cb139-262"><a href="#cb139-262" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-263"><a href="#cb139-263" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_assignable_type(info type_dst, info type_src);</span>
-<span id="cb139-264"><a href="#cb139-264" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_copy_assignable_type(info type);</span>
-<span id="cb139-265"><a href="#cb139-265" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_move_assignable_type(info type);</span>
-<span id="cb139-266"><a href="#cb139-266" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-267"><a href="#cb139-267" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_swappable_with_type(info type_dst, info type_src);</span>
-<span id="cb139-268"><a href="#cb139-268" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_swappable_type(info type);</span>
-<span id="cb139-269"><a href="#cb139-269" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-270"><a href="#cb139-270" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_destructible_type(info type);</span>
-<span id="cb139-271"><a href="#cb139-271" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-272"><a href="#cb139-272" aria-hidden="true" tabindex="-1"></a>  consteval bool is_implicit_lifetime_type(info type);</span>
-<span id="cb139-273"><a href="#cb139-273" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-274"><a href="#cb139-274" aria-hidden="true" tabindex="-1"></a>  consteval bool has_virtual_destructor(info type);</span>
-<span id="cb139-275"><a href="#cb139-275" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-276"><a href="#cb139-276" aria-hidden="true" tabindex="-1"></a>  consteval bool has_unique_object_representations(info type);</span>
-<span id="cb139-277"><a href="#cb139-277" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-278"><a href="#cb139-278" aria-hidden="true" tabindex="-1"></a>  consteval bool reference_constructs_from_temporary(info type_dst, info type_src);</span>
-<span id="cb139-279"><a href="#cb139-279" aria-hidden="true" tabindex="-1"></a>  consteval bool reference_converts_from_temporary(info type_dst, info type_src);</span>
-<span id="cb139-280"><a href="#cb139-280" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-281"><a href="#cb139-281" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.unary.prop.query], type property queries</span>
-<span id="cb139-282"><a href="#cb139-282" aria-hidden="true" tabindex="-1"></a>  consteval size_t rank(info type);</span>
-<span id="cb139-283"><a href="#cb139-283" aria-hidden="true" tabindex="-1"></a>  consteval size_t extent(info type, unsigned i = 0);</span>
-<span id="cb139-284"><a href="#cb139-284" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-285"><a href="#cb139-285" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.rel], type relations</span>
-<span id="cb139-286"><a href="#cb139-286" aria-hidden="true" tabindex="-1"></a>  consteval bool is_same_type(info type1, info type2);</span>
-<span id="cb139-287"><a href="#cb139-287" aria-hidden="true" tabindex="-1"></a>  consteval bool is_base_of_type(info type_base, info type_derived);</span>
-<span id="cb139-288"><a href="#cb139-288" aria-hidden="true" tabindex="-1"></a>  consteval bool is_virtual_base_of_type(info type_base, info type_derived);</span>
-<span id="cb139-289"><a href="#cb139-289" aria-hidden="true" tabindex="-1"></a>  consteval bool is_convertible_type(info type_src, info type_dst);</span>
-<span id="cb139-290"><a href="#cb139-290" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_convertible_type(info type_src, info type_dst);</span>
-<span id="cb139-291"><a href="#cb139-291" aria-hidden="true" tabindex="-1"></a>  consteval bool is_layout_compatible_type(info type1, info type2);</span>
-<span id="cb139-292"><a href="#cb139-292" aria-hidden="true" tabindex="-1"></a>  consteval bool is_pointer_interconvertible_base_of_type(info type_base, info type_derived);</span>
-<span id="cb139-293"><a href="#cb139-293" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-294"><a href="#cb139-294" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-295"><a href="#cb139-295" aria-hidden="true" tabindex="-1"></a>    consteval bool is_invocable_type(info type, R&amp;&amp; type_args);</span>
-<span id="cb139-296"><a href="#cb139-296" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-297"><a href="#cb139-297" aria-hidden="true" tabindex="-1"></a>    consteval bool is_invocable_r_type(info type_result, info type, R&amp;&amp; type_args);</span>
-<span id="cb139-298"><a href="#cb139-298" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-299"><a href="#cb139-299" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-300"><a href="#cb139-300" aria-hidden="true" tabindex="-1"></a>    consteval bool is_nothrow_invocable_type(info type, R&amp;&amp; type_args);</span>
-<span id="cb139-301"><a href="#cb139-301" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-302"><a href="#cb139-302" aria-hidden="true" tabindex="-1"></a>    consteval bool is_nothrow_invocable_r_type(info type_result, info type, R&amp;&amp; type_args);</span>
-<span id="cb139-303"><a href="#cb139-303" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-304"><a href="#cb139-304" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.cv], const-volatile modifications</span>
-<span id="cb139-305"><a href="#cb139-305" aria-hidden="true" tabindex="-1"></a>  consteval info remove_const(info type);</span>
-<span id="cb139-306"><a href="#cb139-306" aria-hidden="true" tabindex="-1"></a>  consteval info remove_volatile(info type);</span>
-<span id="cb139-307"><a href="#cb139-307" aria-hidden="true" tabindex="-1"></a>  consteval info remove_cv(info type);</span>
-<span id="cb139-308"><a href="#cb139-308" aria-hidden="true" tabindex="-1"></a>  consteval info add_const(info type);</span>
-<span id="cb139-309"><a href="#cb139-309" aria-hidden="true" tabindex="-1"></a>  consteval info add_volatile(info type);</span>
-<span id="cb139-310"><a href="#cb139-310" aria-hidden="true" tabindex="-1"></a>  consteval info add_cv(info type);</span>
-<span id="cb139-311"><a href="#cb139-311" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-312"><a href="#cb139-312" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.ref], reference modifications</span>
-<span id="cb139-313"><a href="#cb139-313" aria-hidden="true" tabindex="-1"></a>  consteval info remove_reference(info type);</span>
-<span id="cb139-314"><a href="#cb139-314" aria-hidden="true" tabindex="-1"></a>  consteval info add_lvalue_reference(info type);</span>
-<span id="cb139-315"><a href="#cb139-315" aria-hidden="true" tabindex="-1"></a>  consteval info add_rvalue_reference(info type);</span>
-<span id="cb139-316"><a href="#cb139-316" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-317"><a href="#cb139-317" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.sign], sign modifications</span>
-<span id="cb139-318"><a href="#cb139-318" aria-hidden="true" tabindex="-1"></a>  consteval info make_signed(info type);</span>
-<span id="cb139-319"><a href="#cb139-319" aria-hidden="true" tabindex="-1"></a>  consteval info make_unsigned(info type);</span>
-<span id="cb139-320"><a href="#cb139-320" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-321"><a href="#cb139-321" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.arr], array modifications</span>
-<span id="cb139-322"><a href="#cb139-322" aria-hidden="true" tabindex="-1"></a>  consteval info remove_extent(info type);</span>
-<span id="cb139-323"><a href="#cb139-323" aria-hidden="true" tabindex="-1"></a>  consteval info remove_all_extents(info type);</span>
-<span id="cb139-324"><a href="#cb139-324" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-325"><a href="#cb139-325" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.ptr], pointer modifications</span>
-<span id="cb139-326"><a href="#cb139-326" aria-hidden="true" tabindex="-1"></a>  consteval info remove_pointer(info type);</span>
-<span id="cb139-327"><a href="#cb139-327" aria-hidden="true" tabindex="-1"></a>  consteval info add_pointer(info type);</span>
-<span id="cb139-328"><a href="#cb139-328" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-329"><a href="#cb139-329" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.other], other transformations</span>
-<span id="cb139-330"><a href="#cb139-330" aria-hidden="true" tabindex="-1"></a>  consteval info remove_cvref(info type);</span>
-<span id="cb139-331"><a href="#cb139-331" aria-hidden="true" tabindex="-1"></a>  consteval info decay(info type);</span>
-<span id="cb139-332"><a href="#cb139-332" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-333"><a href="#cb139-333" aria-hidden="true" tabindex="-1"></a>    consteval info common_type(R&amp;&amp; type_args);</span>
-<span id="cb139-334"><a href="#cb139-334" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-335"><a href="#cb139-335" aria-hidden="true" tabindex="-1"></a>    consteval info common_reference(R&amp;&amp; type_args);</span>
-<span id="cb139-336"><a href="#cb139-336" aria-hidden="true" tabindex="-1"></a>  consteval info type_underlying_type(info type);</span>
-<span id="cb139-337"><a href="#cb139-337" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
-<span id="cb139-338"><a href="#cb139-338" aria-hidden="true" tabindex="-1"></a>    `consteval info invoke_result(info type, R&amp;&amp; type_args);</span>
-<span id="cb139-339"><a href="#cb139-339" aria-hidden="true" tabindex="-1"></a>  consteval info unwrap_reference(info type);</span>
-<span id="cb139-340"><a href="#cb139-340" aria-hidden="true" tabindex="-1"></a>  consteval info unwrap_ref_decay(info type);</span>
-<span id="cb139-341"><a href="#cb139-341" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-342"><a href="#cb139-342" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.tuple.variant], tuple and variant queries</span>
-<span id="cb139-343"><a href="#cb139-343" aria-hidden="true" tabindex="-1"></a>  consteval size_t tuple_size(info type);</span>
-<span id="cb139-344"><a href="#cb139-344" aria-hidden="true" tabindex="-1"></a>  consteval info tuple_element(size_t index, info type);</span>
-<span id="cb139-345"><a href="#cb139-345" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-346"><a href="#cb139-346" aria-hidden="true" tabindex="-1"></a>  consteval size_t variant_size(info type);</span>
-<span id="cb139-347"><a href="#cb139-347" aria-hidden="true" tabindex="-1"></a>  consteval info variant_alternative(size_t index, info type);</span>
-<span id="cb139-348"><a href="#cb139-348" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_244" id="pnum_244">1</a></span>
+<div class="sourceCode" id="cb145"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb145-1"><a href="#cb145-1" aria-hidden="true" tabindex="-1"></a>#include &lt;initializer_list&gt;</span>
+<span id="cb145-2"><a href="#cb145-2" aria-hidden="true" tabindex="-1"></a>#include &lt;ranges&gt;</span>
+<span id="cb145-3"><a href="#cb145-3" aria-hidden="true" tabindex="-1"></a>#include &lt;string_view&gt;</span>
+<span id="cb145-4"><a href="#cb145-4" aria-hidden="true" tabindex="-1"></a>#include &lt;vector&gt;</span>
+<span id="cb145-5"><a href="#cb145-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-6"><a href="#cb145-6" aria-hidden="true" tabindex="-1"></a>namespace std::meta {</span>
+<span id="cb145-7"><a href="#cb145-7" aria-hidden="true" tabindex="-1"></a>  using info = decltype(^^::);</span>
+<span id="cb145-8"><a href="#cb145-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-9"><a href="#cb145-9" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.operators], operator representations</span>
+<span id="cb145-10"><a href="#cb145-10" aria-hidden="true" tabindex="-1"></a>  enum class operators {</span>
+<span id="cb145-11"><a href="#cb145-11" aria-hidden="true" tabindex="-1"></a>    <em>see below</em>;</span>
+<span id="cb145-12"><a href="#cb145-12" aria-hidden="true" tabindex="-1"></a>  };</span>
+<span id="cb145-13"><a href="#cb145-13" aria-hidden="true" tabindex="-1"></a>  using enum operators;</span>
+<span id="cb145-14"><a href="#cb145-14" aria-hidden="true" tabindex="-1"></a>  consteval operators operator_of(info r);</span>
+<span id="cb145-15"><a href="#cb145-15" aria-hidden="true" tabindex="-1"></a>  consteval string_view symbol_of(operators op);</span>
+<span id="cb145-16"><a href="#cb145-16" aria-hidden="true" tabindex="-1"></a>  consteval u8string_view u8symbol_of(operators op);</span>
+<span id="cb145-17"><a href="#cb145-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-18"><a href="#cb145-18" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.names], reflection names and locations</span>
+<span id="cb145-19"><a href="#cb145-19" aria-hidden="true" tabindex="-1"></a>  consteval bool has_identifier(info r);</span>
+<span id="cb145-20"><a href="#cb145-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-21"><a href="#cb145-21" aria-hidden="true" tabindex="-1"></a>  consteval string_view identifier_of(info r);</span>
+<span id="cb145-22"><a href="#cb145-22" aria-hidden="true" tabindex="-1"></a>  consteval u8string_view u8identifier_of(info r);</span>
+<span id="cb145-23"><a href="#cb145-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-24"><a href="#cb145-24" aria-hidden="true" tabindex="-1"></a>  consteval string_view display_string_of(info r);</span>
+<span id="cb145-25"><a href="#cb145-25" aria-hidden="true" tabindex="-1"></a>  consteval u8string_view u8display_string_of(info r);</span>
+<span id="cb145-26"><a href="#cb145-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-27"><a href="#cb145-27" aria-hidden="true" tabindex="-1"></a>  consteval source_location source_location_of(info r);</span>
+<span id="cb145-28"><a href="#cb145-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-29"><a href="#cb145-29" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.queries], reflection queries</span>
+<span id="cb145-30"><a href="#cb145-30" aria-hidden="true" tabindex="-1"></a>  consteval bool is_public(info r);</span>
+<span id="cb145-31"><a href="#cb145-31" aria-hidden="true" tabindex="-1"></a>  consteval bool is_protected(info r);</span>
+<span id="cb145-32"><a href="#cb145-32" aria-hidden="true" tabindex="-1"></a>  consteval bool is_private(info r);</span>
+<span id="cb145-33"><a href="#cb145-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-34"><a href="#cb145-34" aria-hidden="true" tabindex="-1"></a>  consteval bool is_virtual(info r);</span>
+<span id="cb145-35"><a href="#cb145-35" aria-hidden="true" tabindex="-1"></a>  consteval bool is_pure_virtual(info r);</span>
+<span id="cb145-36"><a href="#cb145-36" aria-hidden="true" tabindex="-1"></a>  consteval bool is_override(info r);</span>
+<span id="cb145-37"><a href="#cb145-37" aria-hidden="true" tabindex="-1"></a>  consteval bool is_final(info r);</span>
+<span id="cb145-38"><a href="#cb145-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-39"><a href="#cb145-39" aria-hidden="true" tabindex="-1"></a>  consteval bool is_deleted(info r);</span>
+<span id="cb145-40"><a href="#cb145-40" aria-hidden="true" tabindex="-1"></a>  consteval bool is_defaulted(info r);</span>
+<span id="cb145-41"><a href="#cb145-41" aria-hidden="true" tabindex="-1"></a>  consteval bool is_user_provided(info r);</span>
+<span id="cb145-42"><a href="#cb145-42" aria-hidden="true" tabindex="-1"></a>  consteval bool is_user_declared(info r);</span>
+<span id="cb145-43"><a href="#cb145-43" aria-hidden="true" tabindex="-1"></a>  consteval bool is_explicit(info r);</span>
+<span id="cb145-44"><a href="#cb145-44" aria-hidden="true" tabindex="-1"></a>  consteval bool is_noexcept(info r);</span>
+<span id="cb145-45"><a href="#cb145-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-46"><a href="#cb145-46" aria-hidden="true" tabindex="-1"></a>  consteval bool is_bit_field(info r);</span>
+<span id="cb145-47"><a href="#cb145-47" aria-hidden="true" tabindex="-1"></a>  consteval bool is_enumerator(info r);</span>
+<span id="cb145-48"><a href="#cb145-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-49"><a href="#cb145-49" aria-hidden="true" tabindex="-1"></a>  consteval bool is_const(info r);</span>
+<span id="cb145-50"><a href="#cb145-50" aria-hidden="true" tabindex="-1"></a>  consteval bool is_volatile(info r);</span>
+<span id="cb145-51"><a href="#cb145-51" aria-hidden="true" tabindex="-1"></a>  consteval bool is_mutable_member(info r);</span>
+<span id="cb145-52"><a href="#cb145-52" aria-hidden="true" tabindex="-1"></a>  consteval bool is_lvalue_reference_qualified(info r);</span>
+<span id="cb145-53"><a href="#cb145-53" aria-hidden="true" tabindex="-1"></a>  consteval bool is_rvalue_reference_qualified(info r);</span>
+<span id="cb145-54"><a href="#cb145-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-55"><a href="#cb145-55" aria-hidden="true" tabindex="-1"></a>  consteval bool has_static_storage_duration(info r);</span>
+<span id="cb145-56"><a href="#cb145-56" aria-hidden="true" tabindex="-1"></a>  consteval bool has_thread_storage_duration(info r);</span>
+<span id="cb145-57"><a href="#cb145-57" aria-hidden="true" tabindex="-1"></a>  consteval bool has_automatic_storage_duration(info r);</span>
+<span id="cb145-58"><a href="#cb145-58" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-59"><a href="#cb145-59" aria-hidden="true" tabindex="-1"></a>  consteval bool has_internal_linkage(info r);</span>
+<span id="cb145-60"><a href="#cb145-60" aria-hidden="true" tabindex="-1"></a>  consteval bool has_module_linkage(info r);</span>
+<span id="cb145-61"><a href="#cb145-61" aria-hidden="true" tabindex="-1"></a>  consteval bool has_external_linkage(info r);</span>
+<span id="cb145-62"><a href="#cb145-62" aria-hidden="true" tabindex="-1"></a>  consteval bool has_linkage(info r);</span>
+<span id="cb145-63"><a href="#cb145-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-64"><a href="#cb145-64" aria-hidden="true" tabindex="-1"></a>  consteval bool is_complete_type(info r);</span>
+<span id="cb145-65"><a href="#cb145-65" aria-hidden="true" tabindex="-1"></a>  consteval bool has_complete_definition(info r);</span>
+<span id="cb145-66"><a href="#cb145-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-67"><a href="#cb145-67" aria-hidden="true" tabindex="-1"></a>  consteval bool is_namespace(info r);</span>
+<span id="cb145-68"><a href="#cb145-68" aria-hidden="true" tabindex="-1"></a>  consteval bool is_variable(info r);</span>
+<span id="cb145-69"><a href="#cb145-69" aria-hidden="true" tabindex="-1"></a>  consteval bool is_type(info r);</span>
+<span id="cb145-70"><a href="#cb145-70" aria-hidden="true" tabindex="-1"></a>  consteval bool is_type_alias(info r);</span>
+<span id="cb145-71"><a href="#cb145-71" aria-hidden="true" tabindex="-1"></a>  consteval bool is_namespace_alias(info r);</span>
+<span id="cb145-72"><a href="#cb145-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-73"><a href="#cb145-73" aria-hidden="true" tabindex="-1"></a>  consteval bool is_function(info r);</span>
+<span id="cb145-74"><a href="#cb145-74" aria-hidden="true" tabindex="-1"></a>  consteval bool is_conversion_function(info r);</span>
+<span id="cb145-75"><a href="#cb145-75" aria-hidden="true" tabindex="-1"></a>  consteval bool is_operator_function(info r);</span>
+<span id="cb145-76"><a href="#cb145-76" aria-hidden="true" tabindex="-1"></a>  consteval bool is_literal_operator(info r);</span>
+<span id="cb145-77"><a href="#cb145-77" aria-hidden="true" tabindex="-1"></a>  consteval bool is_special_member_function(info r);</span>
+<span id="cb145-78"><a href="#cb145-78" aria-hidden="true" tabindex="-1"></a>  consteval bool is_constructor(info r);</span>
+<span id="cb145-79"><a href="#cb145-79" aria-hidden="true" tabindex="-1"></a>  consteval bool is_default_constructor(info r);</span>
+<span id="cb145-80"><a href="#cb145-80" aria-hidden="true" tabindex="-1"></a>  consteval bool is_copy_constructor(info r);</span>
+<span id="cb145-81"><a href="#cb145-81" aria-hidden="true" tabindex="-1"></a>  consteval bool is_move_constructor(info r);</span>
+<span id="cb145-82"><a href="#cb145-82" aria-hidden="true" tabindex="-1"></a>  consteval bool is_assignment(info r);</span>
+<span id="cb145-83"><a href="#cb145-83" aria-hidden="true" tabindex="-1"></a>  consteval bool is_copy_assignment(info r);</span>
+<span id="cb145-84"><a href="#cb145-84" aria-hidden="true" tabindex="-1"></a>  consteval bool is_move_assignment(info r);</span>
+<span id="cb145-85"><a href="#cb145-85" aria-hidden="true" tabindex="-1"></a>  consteval bool is_destructor(info r);</span>
+<span id="cb145-86"><a href="#cb145-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-87"><a href="#cb145-87" aria-hidden="true" tabindex="-1"></a>  consteval bool is_template(info r);</span>
+<span id="cb145-88"><a href="#cb145-88" aria-hidden="true" tabindex="-1"></a>  consteval bool is_function_template(info r);</span>
+<span id="cb145-89"><a href="#cb145-89" aria-hidden="true" tabindex="-1"></a>  consteval bool is_variable_template(info r);</span>
+<span id="cb145-90"><a href="#cb145-90" aria-hidden="true" tabindex="-1"></a>  consteval bool is_class_template(info r);</span>
+<span id="cb145-91"><a href="#cb145-91" aria-hidden="true" tabindex="-1"></a>  consteval bool is_alias_template(info r);</span>
+<span id="cb145-92"><a href="#cb145-92" aria-hidden="true" tabindex="-1"></a>  consteval bool is_conversion_function_template(info r);</span>
+<span id="cb145-93"><a href="#cb145-93" aria-hidden="true" tabindex="-1"></a>  consteval bool is_operator_function_template(info r);</span>
+<span id="cb145-94"><a href="#cb145-94" aria-hidden="true" tabindex="-1"></a>  consteval bool is_literal_operator_template(info r);</span>
+<span id="cb145-95"><a href="#cb145-95" aria-hidden="true" tabindex="-1"></a>  consteval bool is_constructor_template(info r);</span>
+<span id="cb145-96"><a href="#cb145-96" aria-hidden="true" tabindex="-1"></a>  consteval bool is_concept(info r);</span>
+<span id="cb145-97"><a href="#cb145-97" aria-hidden="true" tabindex="-1"></a>  consteval bool has_template_arguments(info r);</span>
+<span id="cb145-98"><a href="#cb145-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-99"><a href="#cb145-99" aria-hidden="true" tabindex="-1"></a>  consteval bool is_value(info r);</span>
+<span id="cb145-100"><a href="#cb145-100" aria-hidden="true" tabindex="-1"></a>  consteval bool is_object(info r);</span>
+<span id="cb145-101"><a href="#cb145-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-102"><a href="#cb145-102" aria-hidden="true" tabindex="-1"></a>  consteval bool is_structured_binding(info r);</span>
+<span id="cb145-103"><a href="#cb145-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-104"><a href="#cb145-104" aria-hidden="true" tabindex="-1"></a>  consteval bool is_class_member(info r);</span>
+<span id="cb145-105"><a href="#cb145-105" aria-hidden="true" tabindex="-1"></a>  consteval bool is_namespace_member(info r);</span>
+<span id="cb145-106"><a href="#cb145-106" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nonstatic_data_member(info r);</span>
+<span id="cb145-107"><a href="#cb145-107" aria-hidden="true" tabindex="-1"></a>  consteval bool is_static_member(info r);</span>
+<span id="cb145-108"><a href="#cb145-108" aria-hidden="true" tabindex="-1"></a>  consteval bool is_base(info r);</span>
+<span id="cb145-109"><a href="#cb145-109" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-110"><a href="#cb145-110" aria-hidden="true" tabindex="-1"></a>  consteval bool has_default_member_initializer(info r);</span>
+<span id="cb145-111"><a href="#cb145-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-112"><a href="#cb145-112" aria-hidden="true" tabindex="-1"></a>  consteval info type_of(info r);</span>
+<span id="cb145-113"><a href="#cb145-113" aria-hidden="true" tabindex="-1"></a>  consteval info object_of(info r);</span>
+<span id="cb145-114"><a href="#cb145-114" aria-hidden="true" tabindex="-1"></a>  consteval info value_of(info r);</span>
+<span id="cb145-115"><a href="#cb145-115" aria-hidden="true" tabindex="-1"></a>  consteval info parent_of(info r);</span>
+<span id="cb145-116"><a href="#cb145-116" aria-hidden="true" tabindex="-1"></a>  consteval info dealias(info r);</span>
+<span id="cb145-117"><a href="#cb145-117" aria-hidden="true" tabindex="-1"></a>  consteval info template_of(info r);</span>
+<span id="cb145-118"><a href="#cb145-118" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; template_arguments_of(info r);</span>
+<span id="cb145-119"><a href="#cb145-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-120"><a href="#cb145-120" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.member.queries], reflection member queries</span>
+<span id="cb145-121"><a href="#cb145-121" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; members_of(info r);</span>
+<span id="cb145-122"><a href="#cb145-122" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; bases_of(info type);</span>
+<span id="cb145-123"><a href="#cb145-123" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; static_data_members_of(info type);</span>
+<span id="cb145-124"><a href="#cb145-124" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; nonstatic_data_members_of(info type);</span>
+<span id="cb145-125"><a href="#cb145-125" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; enumerators_of(info type_enum);</span>
+<span id="cb145-126"><a href="#cb145-126" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-127"><a href="#cb145-127" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; get_public_members(info type);</span>
+<span id="cb145-128"><a href="#cb145-128" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; get_public_bases(info type);</span>
+<span id="cb145-129"><a href="#cb145-129" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; get_public_static_data_members(info type);</span>
+<span id="cb145-130"><a href="#cb145-130" aria-hidden="true" tabindex="-1"></a>  consteval vector&lt;info&gt; get_public_nonstatic_data_members(info type);</span>
+<span id="cb145-131"><a href="#cb145-131" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-132"><a href="#cb145-132" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.layout], reflection layout queries</span>
+<span id="cb145-133"><a href="#cb145-133" aria-hidden="true" tabindex="-1"></a>  struct member_offset {</span>
+<span id="cb145-134"><a href="#cb145-134" aria-hidden="true" tabindex="-1"></a>    ptrdiff_t bytes;</span>
+<span id="cb145-135"><a href="#cb145-135" aria-hidden="true" tabindex="-1"></a>    ptrdiff_t bits;</span>
+<span id="cb145-136"><a href="#cb145-136" aria-hidden="true" tabindex="-1"></a>    constexpr ptrdiff_t total_bits() const;</span>
+<span id="cb145-137"><a href="#cb145-137" aria-hidden="true" tabindex="-1"></a>    auto operator&lt;=&gt;(member_offset const&amp;) const = default;</span>
+<span id="cb145-138"><a href="#cb145-138" aria-hidden="true" tabindex="-1"></a>  };</span>
+<span id="cb145-139"><a href="#cb145-139" aria-hidden="true" tabindex="-1"></a>  consteval member_offset offset_of(info r);</span>
+<span id="cb145-140"><a href="#cb145-140" aria-hidden="true" tabindex="-1"></a>  consteval size_t size_of(info r);</span>
+<span id="cb145-141"><a href="#cb145-141" aria-hidden="true" tabindex="-1"></a>  consteval size_t alignment_of(info r);</span>
+<span id="cb145-142"><a href="#cb145-142" aria-hidden="true" tabindex="-1"></a>  consteval size_t bit_size_of(info r);</span>
+<span id="cb145-143"><a href="#cb145-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-144"><a href="#cb145-144" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.extract], value extraction</span>
+<span id="cb145-145"><a href="#cb145-145" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt;</span>
+<span id="cb145-146"><a href="#cb145-146" aria-hidden="true" tabindex="-1"></a>    consteval T extract(info);</span>
+<span id="cb145-147"><a href="#cb145-147" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-148"><a href="#cb145-148" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.substitute], reflection substitution</span>
+<span id="cb145-149"><a href="#cb145-149" aria-hidden="true" tabindex="-1"></a>  template &lt;class R&gt;</span>
+<span id="cb145-150"><a href="#cb145-150" aria-hidden="true" tabindex="-1"></a>    concept reflection_range = <em>see below</em>;</span>
+<span id="cb145-151"><a href="#cb145-151" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-152"><a href="#cb145-152" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-153"><a href="#cb145-153" aria-hidden="true" tabindex="-1"></a>    consteval bool can_substitute(info templ, R&amp;&amp; arguments);</span>
+<span id="cb145-154"><a href="#cb145-154" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-155"><a href="#cb145-155" aria-hidden="true" tabindex="-1"></a>    consteval info substitute(info templ, R&amp;&amp; arguments);</span>
+<span id="cb145-156"><a href="#cb145-156" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-157"><a href="#cb145-157" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.result], expression result reflection</span>
+<span id="cb145-158"><a href="#cb145-158" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt;</span>
+<span id="cb145-159"><a href="#cb145-159" aria-hidden="true" tabindex="-1"></a>    consteval info reflect_value(const T&amp; value);</span>
+<span id="cb145-160"><a href="#cb145-160" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt;</span>
+<span id="cb145-161"><a href="#cb145-161" aria-hidden="true" tabindex="-1"></a>    consteval info reflect_object(T&amp; object);</span>
+<span id="cb145-162"><a href="#cb145-162" aria-hidden="true" tabindex="-1"></a>  template&lt;class T&gt;</span>
+<span id="cb145-163"><a href="#cb145-163" aria-hidden="true" tabindex="-1"></a>    consteval info reflect_function(T&amp; fn);</span>
+<span id="cb145-164"><a href="#cb145-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-165"><a href="#cb145-165" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.define.aggregate], class definition generation</span>
+<span id="cb145-166"><a href="#cb145-166" aria-hidden="true" tabindex="-1"></a>  struct data_member_options {</span>
+<span id="cb145-167"><a href="#cb145-167" aria-hidden="true" tabindex="-1"></a>    struct name_type {</span>
+<span id="cb145-168"><a href="#cb145-168" aria-hidden="true" tabindex="-1"></a>      template&lt;class T&gt; requires constructible_from&lt;u8string, T&gt;</span>
+<span id="cb145-169"><a href="#cb145-169" aria-hidden="true" tabindex="-1"></a>        consteval name_type(T &amp;&amp;);</span>
+<span id="cb145-170"><a href="#cb145-170" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-171"><a href="#cb145-171" aria-hidden="true" tabindex="-1"></a>      template&lt;class T&gt; requires constructible_from&lt;string, T&gt;</span>
+<span id="cb145-172"><a href="#cb145-172" aria-hidden="true" tabindex="-1"></a>        consteval name_type(T &amp;&amp;);</span>
+<span id="cb145-173"><a href="#cb145-173" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-174"><a href="#cb145-174" aria-hidden="true" tabindex="-1"></a>      variant&lt;u8string, string&gt; <em>contents</em>;    // <em>exposition only</em></span>
+<span id="cb145-175"><a href="#cb145-175" aria-hidden="true" tabindex="-1"></a>    };</span>
+<span id="cb145-176"><a href="#cb145-176" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-177"><a href="#cb145-177" aria-hidden="true" tabindex="-1"></a>    optional&lt;name_type&gt; name;</span>
+<span id="cb145-178"><a href="#cb145-178" aria-hidden="true" tabindex="-1"></a>    optional&lt;int&gt; alignment;</span>
+<span id="cb145-179"><a href="#cb145-179" aria-hidden="true" tabindex="-1"></a>    optional&lt;int&gt; bit_width;</span>
+<span id="cb145-180"><a href="#cb145-180" aria-hidden="true" tabindex="-1"></a>    bool no_unique_address = false;</span>
+<span id="cb145-181"><a href="#cb145-181" aria-hidden="true" tabindex="-1"></a>  };</span>
+<span id="cb145-182"><a href="#cb145-182" aria-hidden="true" tabindex="-1"></a>  consteval info data_member_spec(info type,</span>
+<span id="cb145-183"><a href="#cb145-183" aria-hidden="true" tabindex="-1"></a>                                  data_member_options options = {});</span>
+<span id="cb145-184"><a href="#cb145-184" aria-hidden="true" tabindex="-1"></a>  consteval bool is_data_member_spec(info r);</span>
+<span id="cb145-185"><a href="#cb145-185" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-186"><a href="#cb145-186" aria-hidden="true" tabindex="-1"></a>  consteval info define_aggregate(info type_class, R&amp;&amp;);</span>
+<span id="cb145-187"><a href="#cb145-187" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-188"><a href="#cb145-188" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.unary.cat], primary type categories</span>
+<span id="cb145-189"><a href="#cb145-189" aria-hidden="true" tabindex="-1"></a>  consteval bool is_void_type(info type);</span>
+<span id="cb145-190"><a href="#cb145-190" aria-hidden="true" tabindex="-1"></a>  consteval bool is_null_pointer_type(info type);</span>
+<span id="cb145-191"><a href="#cb145-191" aria-hidden="true" tabindex="-1"></a>  consteval bool is_integral_type(info type);</span>
+<span id="cb145-192"><a href="#cb145-192" aria-hidden="true" tabindex="-1"></a>  consteval bool is_floating_point_type(info type);</span>
+<span id="cb145-193"><a href="#cb145-193" aria-hidden="true" tabindex="-1"></a>  consteval bool is_array_type(info type);</span>
+<span id="cb145-194"><a href="#cb145-194" aria-hidden="true" tabindex="-1"></a>  consteval bool is_pointer_type(info type);</span>
+<span id="cb145-195"><a href="#cb145-195" aria-hidden="true" tabindex="-1"></a>  consteval bool is_lvalue_reference_type(info type);</span>
+<span id="cb145-196"><a href="#cb145-196" aria-hidden="true" tabindex="-1"></a>  consteval bool is_rvalue_reference_type(info type);</span>
+<span id="cb145-197"><a href="#cb145-197" aria-hidden="true" tabindex="-1"></a>  consteval bool is_member_object_pointer_type(info type);</span>
+<span id="cb145-198"><a href="#cb145-198" aria-hidden="true" tabindex="-1"></a>  consteval bool is_member_function_pointer_type(info type);</span>
+<span id="cb145-199"><a href="#cb145-199" aria-hidden="true" tabindex="-1"></a>  consteval bool is_enum_type(info type);</span>
+<span id="cb145-200"><a href="#cb145-200" aria-hidden="true" tabindex="-1"></a>  consteval bool is_union_type(info type);</span>
+<span id="cb145-201"><a href="#cb145-201" aria-hidden="true" tabindex="-1"></a>  consteval bool is_class_type(info type);</span>
+<span id="cb145-202"><a href="#cb145-202" aria-hidden="true" tabindex="-1"></a>  consteval bool is_function_type(info type);</span>
+<span id="cb145-203"><a href="#cb145-203" aria-hidden="true" tabindex="-1"></a>  consteval bool is_reflection_type(info type);</span>
+<span id="cb145-204"><a href="#cb145-204" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-205"><a href="#cb145-205" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.unary.comp], composite type categories</span>
+<span id="cb145-206"><a href="#cb145-206" aria-hidden="true" tabindex="-1"></a>  consteval bool is_reference_type(info type);</span>
+<span id="cb145-207"><a href="#cb145-207" aria-hidden="true" tabindex="-1"></a>  consteval bool is_arithmetic_type(info type);</span>
+<span id="cb145-208"><a href="#cb145-208" aria-hidden="true" tabindex="-1"></a>  consteval bool is_fundamental_type(info type);</span>
+<span id="cb145-209"><a href="#cb145-209" aria-hidden="true" tabindex="-1"></a>  consteval bool is_object_type(info type);</span>
+<span id="cb145-210"><a href="#cb145-210" aria-hidden="true" tabindex="-1"></a>  consteval bool is_scalar_type(info type);</span>
+<span id="cb145-211"><a href="#cb145-211" aria-hidden="true" tabindex="-1"></a>  consteval bool is_compound_type(info type);</span>
+<span id="cb145-212"><a href="#cb145-212" aria-hidden="true" tabindex="-1"></a>  consteval bool is_member_pointer_type(info type);</span>
+<span id="cb145-213"><a href="#cb145-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-214"><a href="#cb145-214" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection unary.prop], type properties</span>
+<span id="cb145-215"><a href="#cb145-215" aria-hidden="true" tabindex="-1"></a>  consteval bool is_const_type(info type);</span>
+<span id="cb145-216"><a href="#cb145-216" aria-hidden="true" tabindex="-1"></a>  consteval bool is_volatile_type(info type);</span>
+<span id="cb145-217"><a href="#cb145-217" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivial_type(info type);</span>
+<span id="cb145-218"><a href="#cb145-218" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_copyable_type(info type);</span>
+<span id="cb145-219"><a href="#cb145-219" aria-hidden="true" tabindex="-1"></a>  consteval bool is_standard_layout_type(info type);</span>
+<span id="cb145-220"><a href="#cb145-220" aria-hidden="true" tabindex="-1"></a>  consteval bool is_empty_type(info type);</span>
+<span id="cb145-221"><a href="#cb145-221" aria-hidden="true" tabindex="-1"></a>  consteval bool is_polymorphic_type(info type);</span>
+<span id="cb145-222"><a href="#cb145-222" aria-hidden="true" tabindex="-1"></a>  consteval bool is_abstract_type(info type);</span>
+<span id="cb145-223"><a href="#cb145-223" aria-hidden="true" tabindex="-1"></a>  consteval bool is_final_type(info type);</span>
+<span id="cb145-224"><a href="#cb145-224" aria-hidden="true" tabindex="-1"></a>  consteval bool is_aggregate_type(info type);</span>
+<span id="cb145-225"><a href="#cb145-225" aria-hidden="true" tabindex="-1"></a>  consteval bool is_signed_type(info type);</span>
+<span id="cb145-226"><a href="#cb145-226" aria-hidden="true" tabindex="-1"></a>  consteval bool is_unsigned_type(info type);</span>
+<span id="cb145-227"><a href="#cb145-227" aria-hidden="true" tabindex="-1"></a>  consteval bool is_bounded_array_type(info type);</span>
+<span id="cb145-228"><a href="#cb145-228" aria-hidden="true" tabindex="-1"></a>  consteval bool is_unbounded_array_type(info type);</span>
+<span id="cb145-229"><a href="#cb145-229" aria-hidden="true" tabindex="-1"></a>  consteval bool is_scoped_enum_type(info type);</span>
+<span id="cb145-230"><a href="#cb145-230" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-231"><a href="#cb145-231" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-232"><a href="#cb145-232" aria-hidden="true" tabindex="-1"></a>    consteval bool is_constructible_type(info type, R&amp;&amp; type_args);</span>
+<span id="cb145-233"><a href="#cb145-233" aria-hidden="true" tabindex="-1"></a>  consteval bool is_default_constructible_type(info type);</span>
+<span id="cb145-234"><a href="#cb145-234" aria-hidden="true" tabindex="-1"></a>  consteval bool is_copy_constructible_type(info type);</span>
+<span id="cb145-235"><a href="#cb145-235" aria-hidden="true" tabindex="-1"></a>  consteval bool is_move_constructible_type(info type);</span>
+<span id="cb145-236"><a href="#cb145-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-237"><a href="#cb145-237" aria-hidden="true" tabindex="-1"></a>  consteval bool is_assignable_type(info type_dst, info type_src);</span>
+<span id="cb145-238"><a href="#cb145-238" aria-hidden="true" tabindex="-1"></a>  consteval bool is_copy_assignable_type(info type);</span>
+<span id="cb145-239"><a href="#cb145-239" aria-hidden="true" tabindex="-1"></a>  consteval bool is_move_assignable_type(info type);</span>
+<span id="cb145-240"><a href="#cb145-240" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-241"><a href="#cb145-241" aria-hidden="true" tabindex="-1"></a>  consteval bool is_swappable_with_type(info type_dst, info type_src);</span>
+<span id="cb145-242"><a href="#cb145-242" aria-hidden="true" tabindex="-1"></a>  consteval bool is_swappable_type(info type);</span>
+<span id="cb145-243"><a href="#cb145-243" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-244"><a href="#cb145-244" aria-hidden="true" tabindex="-1"></a>  consteval bool is_destructible_type(info type);</span>
+<span id="cb145-245"><a href="#cb145-245" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-246"><a href="#cb145-246" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-247"><a href="#cb145-247" aria-hidden="true" tabindex="-1"></a>    consteval bool is_trivially_constructible_type(info type, R&amp;&amp; type_args);</span>
+<span id="cb145-248"><a href="#cb145-248" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_default_constructible_type(info type);</span>
+<span id="cb145-249"><a href="#cb145-249" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_copy_constructible_type(info type);</span>
+<span id="cb145-250"><a href="#cb145-250" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_move_constructible_type(info type);</span>
+<span id="cb145-251"><a href="#cb145-251" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-252"><a href="#cb145-252" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_assignable_type(info type_dst, info type_src);</span>
+<span id="cb145-253"><a href="#cb145-253" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_copy_assignable_type(info type);</span>
+<span id="cb145-254"><a href="#cb145-254" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_move_assignable_type(info type);</span>
+<span id="cb145-255"><a href="#cb145-255" aria-hidden="true" tabindex="-1"></a>  consteval bool is_trivially_destructible_type(info type);</span>
+<span id="cb145-256"><a href="#cb145-256" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-257"><a href="#cb145-257" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-258"><a href="#cb145-258" aria-hidden="true" tabindex="-1"></a>    consteval bool is_nothrow_constructible_type(info type, R&amp;&amp; type_args);</span>
+<span id="cb145-259"><a href="#cb145-259" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_default_constructible_type(info type);</span>
+<span id="cb145-260"><a href="#cb145-260" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_copy_constructible_type(info type);</span>
+<span id="cb145-261"><a href="#cb145-261" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_move_constructible_type(info type);</span>
+<span id="cb145-262"><a href="#cb145-262" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-263"><a href="#cb145-263" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_assignable_type(info type_dst, info type_src);</span>
+<span id="cb145-264"><a href="#cb145-264" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_copy_assignable_type(info type);</span>
+<span id="cb145-265"><a href="#cb145-265" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_move_assignable_type(info type);</span>
+<span id="cb145-266"><a href="#cb145-266" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-267"><a href="#cb145-267" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_swappable_with_type(info type_dst, info type_src);</span>
+<span id="cb145-268"><a href="#cb145-268" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_swappable_type(info type);</span>
+<span id="cb145-269"><a href="#cb145-269" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-270"><a href="#cb145-270" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_destructible_type(info type);</span>
+<span id="cb145-271"><a href="#cb145-271" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-272"><a href="#cb145-272" aria-hidden="true" tabindex="-1"></a>  consteval bool is_implicit_lifetime_type(info type);</span>
+<span id="cb145-273"><a href="#cb145-273" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-274"><a href="#cb145-274" aria-hidden="true" tabindex="-1"></a>  consteval bool has_virtual_destructor(info type);</span>
+<span id="cb145-275"><a href="#cb145-275" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-276"><a href="#cb145-276" aria-hidden="true" tabindex="-1"></a>  consteval bool has_unique_object_representations(info type);</span>
+<span id="cb145-277"><a href="#cb145-277" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-278"><a href="#cb145-278" aria-hidden="true" tabindex="-1"></a>  consteval bool reference_constructs_from_temporary(info type_dst, info type_src);</span>
+<span id="cb145-279"><a href="#cb145-279" aria-hidden="true" tabindex="-1"></a>  consteval bool reference_converts_from_temporary(info type_dst, info type_src);</span>
+<span id="cb145-280"><a href="#cb145-280" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-281"><a href="#cb145-281" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.unary.prop.query], type property queries</span>
+<span id="cb145-282"><a href="#cb145-282" aria-hidden="true" tabindex="-1"></a>  consteval size_t rank(info type);</span>
+<span id="cb145-283"><a href="#cb145-283" aria-hidden="true" tabindex="-1"></a>  consteval size_t extent(info type, unsigned i = 0);</span>
+<span id="cb145-284"><a href="#cb145-284" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-285"><a href="#cb145-285" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.rel], type relations</span>
+<span id="cb145-286"><a href="#cb145-286" aria-hidden="true" tabindex="-1"></a>  consteval bool is_same_type(info type1, info type2);</span>
+<span id="cb145-287"><a href="#cb145-287" aria-hidden="true" tabindex="-1"></a>  consteval bool is_base_of_type(info type_base, info type_derived);</span>
+<span id="cb145-288"><a href="#cb145-288" aria-hidden="true" tabindex="-1"></a>  consteval bool is_virtual_base_of_type(info type_base, info type_derived);</span>
+<span id="cb145-289"><a href="#cb145-289" aria-hidden="true" tabindex="-1"></a>  consteval bool is_convertible_type(info type_src, info type_dst);</span>
+<span id="cb145-290"><a href="#cb145-290" aria-hidden="true" tabindex="-1"></a>  consteval bool is_nothrow_convertible_type(info type_src, info type_dst);</span>
+<span id="cb145-291"><a href="#cb145-291" aria-hidden="true" tabindex="-1"></a>  consteval bool is_layout_compatible_type(info type1, info type2);</span>
+<span id="cb145-292"><a href="#cb145-292" aria-hidden="true" tabindex="-1"></a>  consteval bool is_pointer_interconvertible_base_of_type(info type_base, info type_derived);</span>
+<span id="cb145-293"><a href="#cb145-293" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-294"><a href="#cb145-294" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-295"><a href="#cb145-295" aria-hidden="true" tabindex="-1"></a>    consteval bool is_invocable_type(info type, R&amp;&amp; type_args);</span>
+<span id="cb145-296"><a href="#cb145-296" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-297"><a href="#cb145-297" aria-hidden="true" tabindex="-1"></a>    consteval bool is_invocable_r_type(info type_result, info type, R&amp;&amp; type_args);</span>
+<span id="cb145-298"><a href="#cb145-298" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-299"><a href="#cb145-299" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-300"><a href="#cb145-300" aria-hidden="true" tabindex="-1"></a>    consteval bool is_nothrow_invocable_type(info type, R&amp;&amp; type_args);</span>
+<span id="cb145-301"><a href="#cb145-301" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-302"><a href="#cb145-302" aria-hidden="true" tabindex="-1"></a>    consteval bool is_nothrow_invocable_r_type(info type_result, info type, R&amp;&amp; type_args);</span>
+<span id="cb145-303"><a href="#cb145-303" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-304"><a href="#cb145-304" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.cv], const-volatile modifications</span>
+<span id="cb145-305"><a href="#cb145-305" aria-hidden="true" tabindex="-1"></a>  consteval info remove_const(info type);</span>
+<span id="cb145-306"><a href="#cb145-306" aria-hidden="true" tabindex="-1"></a>  consteval info remove_volatile(info type);</span>
+<span id="cb145-307"><a href="#cb145-307" aria-hidden="true" tabindex="-1"></a>  consteval info remove_cv(info type);</span>
+<span id="cb145-308"><a href="#cb145-308" aria-hidden="true" tabindex="-1"></a>  consteval info add_const(info type);</span>
+<span id="cb145-309"><a href="#cb145-309" aria-hidden="true" tabindex="-1"></a>  consteval info add_volatile(info type);</span>
+<span id="cb145-310"><a href="#cb145-310" aria-hidden="true" tabindex="-1"></a>  consteval info add_cv(info type);</span>
+<span id="cb145-311"><a href="#cb145-311" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-312"><a href="#cb145-312" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.ref], reference modifications</span>
+<span id="cb145-313"><a href="#cb145-313" aria-hidden="true" tabindex="-1"></a>  consteval info remove_reference(info type);</span>
+<span id="cb145-314"><a href="#cb145-314" aria-hidden="true" tabindex="-1"></a>  consteval info add_lvalue_reference(info type);</span>
+<span id="cb145-315"><a href="#cb145-315" aria-hidden="true" tabindex="-1"></a>  consteval info add_rvalue_reference(info type);</span>
+<span id="cb145-316"><a href="#cb145-316" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-317"><a href="#cb145-317" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.sign], sign modifications</span>
+<span id="cb145-318"><a href="#cb145-318" aria-hidden="true" tabindex="-1"></a>  consteval info make_signed(info type);</span>
+<span id="cb145-319"><a href="#cb145-319" aria-hidden="true" tabindex="-1"></a>  consteval info make_unsigned(info type);</span>
+<span id="cb145-320"><a href="#cb145-320" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-321"><a href="#cb145-321" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.arr], array modifications</span>
+<span id="cb145-322"><a href="#cb145-322" aria-hidden="true" tabindex="-1"></a>  consteval info remove_extent(info type);</span>
+<span id="cb145-323"><a href="#cb145-323" aria-hidden="true" tabindex="-1"></a>  consteval info remove_all_extents(info type);</span>
+<span id="cb145-324"><a href="#cb145-324" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-325"><a href="#cb145-325" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.ptr], pointer modifications</span>
+<span id="cb145-326"><a href="#cb145-326" aria-hidden="true" tabindex="-1"></a>  consteval info remove_pointer(info type);</span>
+<span id="cb145-327"><a href="#cb145-327" aria-hidden="true" tabindex="-1"></a>  consteval info add_pointer(info type);</span>
+<span id="cb145-328"><a href="#cb145-328" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-329"><a href="#cb145-329" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.trans.other], other transformations</span>
+<span id="cb145-330"><a href="#cb145-330" aria-hidden="true" tabindex="-1"></a>  consteval info remove_cvref(info type);</span>
+<span id="cb145-331"><a href="#cb145-331" aria-hidden="true" tabindex="-1"></a>  consteval info decay(info type);</span>
+<span id="cb145-332"><a href="#cb145-332" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-333"><a href="#cb145-333" aria-hidden="true" tabindex="-1"></a>    consteval info common_type(R&amp;&amp; type_args);</span>
+<span id="cb145-334"><a href="#cb145-334" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-335"><a href="#cb145-335" aria-hidden="true" tabindex="-1"></a>    consteval info common_reference(R&amp;&amp; type_args);</span>
+<span id="cb145-336"><a href="#cb145-336" aria-hidden="true" tabindex="-1"></a>  consteval info type_underlying_type(info type);</span>
+<span id="cb145-337"><a href="#cb145-337" aria-hidden="true" tabindex="-1"></a>  template &lt;reflection_range R = initializer_list&lt;info&gt;&gt;</span>
+<span id="cb145-338"><a href="#cb145-338" aria-hidden="true" tabindex="-1"></a>    `consteval info invoke_result(info type, R&amp;&amp; type_args);</span>
+<span id="cb145-339"><a href="#cb145-339" aria-hidden="true" tabindex="-1"></a>  consteval info unwrap_reference(info type);</span>
+<span id="cb145-340"><a href="#cb145-340" aria-hidden="true" tabindex="-1"></a>  consteval info unwrap_ref_decay(info type);</span>
+<span id="cb145-341"><a href="#cb145-341" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-342"><a href="#cb145-342" aria-hidden="true" tabindex="-1"></a>  // [meta.reflection.tuple.variant], tuple and variant queries</span>
+<span id="cb145-343"><a href="#cb145-343" aria-hidden="true" tabindex="-1"></a>  consteval size_t tuple_size(info type);</span>
+<span id="cb145-344"><a href="#cb145-344" aria-hidden="true" tabindex="-1"></a>  consteval info tuple_element(size_t index, info type);</span>
+<span id="cb145-345"><a href="#cb145-345" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-346"><a href="#cb145-346" aria-hidden="true" tabindex="-1"></a>  consteval size_t variant_size(info type);</span>
+<span id="cb145-347"><a href="#cb145-347" aria-hidden="true" tabindex="-1"></a>  consteval info variant_alternative(size_t index, info type);</span>
+<span id="cb145-348"><a href="#cb145-348" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_289" id="pnum_289">1</a></span>
 Each function, and each instantiation of each function template,
 specified in this header is a designated addressable function
 ([namespace.std]).</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_245" id="pnum_245">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_290" id="pnum_290">2</a></span>
 The behavior of any function specified in namespace
 <code class="sourceCode cpp">std<span class="op">::</span>meta</code> is
 implementation-defined when a reflection of a construct not otherwise
@@ -8213,12 +8920,12 @@ <h3 class="unnumbered" id="meta.reflection.synop-header-meta-synopsis">[meta.ref
 definition, the specialization is implicitly instantiated.</p>
 <div class="example">
 <span>[ <em>Example 1:</em> </span>
-<div class="sourceCode" id="cb140"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb140-1"><a href="#cb140-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
-<span id="cb140-2"><a href="#cb140-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> X <span class="op">{</span></span>
-<span id="cb140-3"><a href="#cb140-3" aria-hidden="true" tabindex="-1"></a>  T mem;</span>
-<span id="cb140-4"><a href="#cb140-4" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
-<span id="cb140-5"><a href="#cb140-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb140-6"><a href="#cb140-6" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>size_of<span class="op">(^^</span>X<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;)</span> <span class="op">==</span> <span class="kw">sizeof</span><span class="op">(</span><span class="dt">int</span><span class="op">))</span>; <span class="co">// instantiates X&lt;int&gt;</span></span></code></pre></div>
+<div class="sourceCode" id="cb146"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb146-1"><a href="#cb146-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
+<span id="cb146-2"><a href="#cb146-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> X <span class="op">{</span></span>
+<span id="cb146-3"><a href="#cb146-3" aria-hidden="true" tabindex="-1"></a>  T mem;</span>
+<span id="cb146-4"><a href="#cb146-4" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
+<span id="cb146-5"><a href="#cb146-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb146-6"><a href="#cb146-6" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>size_of<span class="op">(^^</span>X<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;)</span> <span class="op">==</span> <span class="kw">sizeof</span><span class="op">(</span><span class="dt">int</span><span class="op">))</span>; <span class="co">// instantiates X&lt;int&gt;</span></span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
 <span> — <em>end note</em> ]</span>
@@ -8231,11 +8938,11 @@ <h3 class="unnumbered" id="meta.reflection.operators-operator-representations">[
 <div class="std">
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb141"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb141-1"><a href="#cb141-1" aria-hidden="true" tabindex="-1"></a><span class="kw">enum</span> <span class="kw">class</span> operators <span class="op">{</span></span>
-<span id="cb141-2"><a href="#cb141-2" aria-hidden="true" tabindex="-1"></a>  <em>see below</em>;</span>
-<span id="cb141-3"><a href="#cb141-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
-<span id="cb141-4"><a href="#cb141-4" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> <span class="kw">enum</span> operators;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_246" id="pnum_246">1</a></span>
+<div class="sourceCode" id="cb147"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb147-1"><a href="#cb147-1" aria-hidden="true" tabindex="-1"></a><span class="kw">enum</span> <span class="kw">class</span> operators <span class="op">{</span></span>
+<span id="cb147-2"><a href="#cb147-2" aria-hidden="true" tabindex="-1"></a>  <em>see below</em>;</span>
+<span id="cb147-3"><a href="#cb147-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span>
+<span id="cb147-4"><a href="#cb147-4" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> <span class="kw">enum</span> operators;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_291" id="pnum_291">1</a></span>
 This enum class specifies constants used to identify operators that can
 be overloaded, with the meanings listed in Table 1. The values of the
 constants are distinct.</p>
@@ -8487,23 +9194,23 @@ <h3 class="unnumbered" id="meta.reflection.operators-operator-representations">[
 </tr>
 </tbody>
 </table>
-<div class="sourceCode" id="cb142"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb142-1"><a href="#cb142-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> operators operator_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_247" id="pnum_247">2</a></span>
+<div class="sourceCode" id="cb148"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb148-1"><a href="#cb148-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> operators operator_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_292" id="pnum_292">2</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">r</code> represents
 an operator function or operator function template.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_248" id="pnum_248">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_293" id="pnum_293">3</a></span>
 <em>Returns</em>: The value of the enumerator from
 <code class="sourceCode cpp">operators</code> whose corresponding
 <code class="sourceCode cpp"><em>operator-function-id</em></code> is the
 unqualified name of the entity represented by
 <code class="sourceCode cpp">r</code>.</p>
-<div class="sourceCode" id="cb143"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb143-1"><a href="#cb143-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> string_view symbol_of<span class="op">(</span>operators op<span class="op">)</span>;</span>
-<span id="cb143-2"><a href="#cb143-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> u8string_view u8symbol_of<span class="op">(</span>operators op<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_249" id="pnum_249">4</a></span>
+<div class="sourceCode" id="cb149"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb149-1"><a href="#cb149-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> string_view symbol_of<span class="op">(</span>operators op<span class="op">)</span>;</span>
+<span id="cb149-2"><a href="#cb149-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> u8string_view u8symbol_of<span class="op">(</span>operators op<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_294" id="pnum_294">4</a></span>
 <em>Constant When</em>: The value of
 <code class="sourceCode cpp">op</code> corresponds to one of the
 enumerators in <code class="sourceCode cpp">operators</code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_250" id="pnum_250">5</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_295" id="pnum_295">5</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">string_view</code> or
 <code class="sourceCode cpp">u8string_view</code> containing the
 characters of the operator symbol name corresponding to
@@ -8517,11 +9224,11 @@ <h3 class="unnumbered" id="meta.reflection.names-reflection-names-and-locations"
 <div class="std">
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb144"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb144-1"><a href="#cb144-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_identifier<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_251" id="pnum_251">1</a></span>
+<div class="sourceCode" id="cb150"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb150-1"><a href="#cb150-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_identifier<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_296" id="pnum_296">1</a></span>
 <em>Returns</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_252" id="pnum_252">(1.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_297" id="pnum_297">(1.1)</a></span>
 If <code class="sourceCode cpp">r</code> represents a class type
 <code class="sourceCode cpp"><em>C</em></code>, then
 <code class="sourceCode cpp"><span class="kw">true</span></code> when
@@ -8531,18 +9238,18 @@ <h3 class="unnumbered" id="meta.reflection.names-reflection-names-and-locations"
 the declaration of <code class="sourceCode cpp"><em>C</em></code> is an
 identifier. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_253" id="pnum_253">(1.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_298" id="pnum_298">(1.2)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents an
 unnamed entity, then
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_254" id="pnum_254">(1.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_299" id="pnum_299">(1.3)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a
 function, then
 <code class="sourceCode cpp"><span class="kw">true</span></code> if the
 function is not a function template specialization, constructor,
 destructor, operator function, or conversion function. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_255" id="pnum_255">(1.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_300" id="pnum_300">(1.4)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a
 function template, then
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
@@ -8550,21 +9257,21 @@ <h3 class="unnumbered" id="meta.reflection.names-reflection-names-and-locations"
 template, operator function template, or conversion function template.
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_256" id="pnum_256">(1.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_301" id="pnum_301">(1.5)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a
 <code class="sourceCode cpp"><em>typedef-name</em></code>, then
 <code class="sourceCode cpp"><span class="kw">true</span></code> when
 the <code class="sourceCode cpp"><em>typedef-name</em></code> is an
 identifier. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_257" id="pnum_257">(1.6)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_302" id="pnum_302">(1.6)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a
 variable, then
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> does not represent a variable
 template specialization. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_258" id="pnum_258">(1.7)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_303" id="pnum_303">(1.7)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a
 structured binding, enumerator, non-static data member, template,
 namespace, or
@@ -8572,14 +9279,14 @@ <h3 class="unnumbered" id="meta.reflection.names-reflection-names-and-locations"
 <code class="sourceCode cpp"><span class="kw">true</span></code>.
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_259" id="pnum_259">(1.8)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_304" id="pnum_304">(1.8)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a base
 class specifier, then
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">has_identifier<span class="op">(</span>type_of<span class="op">(</span>r<span class="op">))</span></code>.
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_260" id="pnum_260">(1.9)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_305" id="pnum_305">(1.9)</a></span>
 Otherwise if <code class="sourceCode cpp">r</code> represents a
 description of a declaration of a non-static data member, then letting
 <code class="sourceCode cpp"><em>o</em></code> be a
@@ -8589,45 +9296,45 @@ <h3 class="unnumbered" id="meta.reflection.names-reflection-names-and-locations"
 <code class="sourceCode cpp"><em>o</em><span class="op">.</span>name</code>
 contains a value. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_261" id="pnum_261">(1.10)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_306" id="pnum_306">(1.10)</a></span>
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
 </ul>
-<div class="sourceCode" id="cb145"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb145-1"><a href="#cb145-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> string_view identifier_of<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb145-2"><a href="#cb145-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> u8string_view u8identifier_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_262" id="pnum_262">2</a></span>
+<div class="sourceCode" id="cb151"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb151-1"><a href="#cb151-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> string_view identifier_of<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb151-2"><a href="#cb151-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> u8string_view u8identifier_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_307" id="pnum_307">2</a></span>
 Let <em>E</em> be UTF-8 if returning a
 <code class="sourceCode cpp">u8string_view</code>, and otherwise the
 ordinary literal encoding.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_263" id="pnum_263">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_308" id="pnum_308">3</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">has_identifier<span class="op">(</span>r<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code> and
 the identifier that would be returned (see below) is representable by
 <code class="sourceCode cpp"><em>E</em></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_264" id="pnum_264">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_309" id="pnum_309">4</a></span>
 <em>Returns</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_265" id="pnum_265">(4.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_310" id="pnum_310">(4.1)</a></span>
 If <code class="sourceCode cpp">r</code> represents a literal operator
 or literal operator template, then the
 <code class="sourceCode cpp"><em>ud-suffix</em></code> of the operator
 or operator template.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_266" id="pnum_266">(4.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_311" id="pnum_311">(4.2)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a class
 type, then either the typedef name for linkage purposes or the
 identifier introduced by the declaration of the represented type.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_267" id="pnum_267">(4.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_312" id="pnum_312">(4.3)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents an
 entity, <code class="sourceCode cpp"><em>typedef-name</em></code>, or
 <code class="sourceCode cpp"><em>namespace-alias</em></code>, then the
 identifier introduced by the declaration of what is represented by
 <code class="sourceCode cpp">r</code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_268" id="pnum_268">(4.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_313" id="pnum_313">(4.4)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a base
 class specifier, then <code class="sourceCode cpp">identifier_of<span class="op">(</span>type_of<span class="op">(</span>r<span class="op">))</span></code>
 or <code class="sourceCode cpp">u8identifier_of<span class="op">(</span>type_of<span class="op">(</span>r<span class="op">))</span></code>,
 respectively.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_269" id="pnum_269">(4.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_314" id="pnum_314">(4.5)</a></span>
 Otherwise (if <code class="sourceCode cpp">r</code> represents a
 description of a declaration of a non-static data member), then letting
 <code class="sourceCode cpp"><em>o</em></code> be a
@@ -8637,23 +9344,23 @@ <h3 class="unnumbered" id="meta.reflection.names-reflection-names-and-locations"
 <code class="sourceCode cpp">u8string</code> contents of <code class="sourceCode cpp"><em>o</em><span class="op">.</span>name<span class="op">.</span><em>contents</em></code>
 encoded with <code class="sourceCode cpp"><em>E</em></code>.</li>
 </ul>
-<div class="sourceCode" id="cb146"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb146-1"><a href="#cb146-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> string_view display_string_of<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb146-2"><a href="#cb146-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> u8string_view u8display_string_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_270" id="pnum_270">5</a></span>
+<div class="sourceCode" id="cb152"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb152-1"><a href="#cb152-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> string_view display_string_of<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb152-2"><a href="#cb152-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> u8string_view u8display_string_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_315" id="pnum_315">5</a></span>
 <em>Returns</em>: An implementation-defined
 <code class="sourceCode cpp">string_view</code> or
 <code class="sourceCode cpp">u8string_view</code>, respectively.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_271" id="pnum_271">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_316" id="pnum_316">6</a></span>
 <em>Recommended practice</em>: Where possible, implementations should
 return a string suitable for identifying the represented construct.</p>
-<div class="sourceCode" id="cb147"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb147-1"><a href="#cb147-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> source_location source_location_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_272" id="pnum_272">7</a></span>
+<div class="sourceCode" id="cb153"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb153-1"><a href="#cb153-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> source_location source_location_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_317" id="pnum_317">7</a></span>
 <em>Returns</em>: If <code class="sourceCode cpp">r</code> represents a
 value, a non-class type, the global namespace, or a description of a
 declaration of a non-static data member, then <code class="sourceCode cpp">source_location<span class="op">{}</span></code>.
 Otherwise, an implementation-defined
 <code class="sourceCode cpp">source_location</code> value.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_273" id="pnum_273">8</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_318" id="pnum_318">8</a></span>
 <em>Recommended practice</em>: If <code class="sourceCode cpp">r</code>
 represents an entity, name, or base specifier that was introduced by a
 declaration, implementations should return a value corresponding to a
@@ -8668,59 +9375,59 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 <div class="std">
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb148"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb148-1"><a href="#cb148-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_public<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb148-2"><a href="#cb148-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_protected<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb148-3"><a href="#cb148-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_private<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_274" id="pnum_274">1</a></span>
+<div class="sourceCode" id="cb154"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb154-1"><a href="#cb154-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_public<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb154-2"><a href="#cb154-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_protected<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb154-3"><a href="#cb154-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_private<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_319" id="pnum_319">1</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a class member or base
 class specifier that is public, protected, or private, respectively.
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb149"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb149-1"><a href="#cb149-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_virtual<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_275" id="pnum_275">2</a></span>
+<div class="sourceCode" id="cb155"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb155-1"><a href="#cb155-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_virtual<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_320" id="pnum_320">2</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents either a virtual member
 function or a virtual base class specifier. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb150"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb150-1"><a href="#cb150-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pure_virtual<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb150-2"><a href="#cb150-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_override<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_276" id="pnum_276">3</a></span>
+<div class="sourceCode" id="cb156"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb156-1"><a href="#cb156-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pure_virtual<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb156-2"><a href="#cb156-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_override<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_321" id="pnum_321">3</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a member function that
 is pure virtual or overrides another member function, respectively.
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb151"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb151-1"><a href="#cb151-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_final<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_277" id="pnum_277">4</a></span>
+<div class="sourceCode" id="cb157"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb157-1"><a href="#cb157-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_final<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_322" id="pnum_322">4</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a final class or a
 final member function. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb152"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb152-1"><a href="#cb152-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_deleted<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb152-2"><a href="#cb152-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_defaulted<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_278" id="pnum_278">5</a></span>
+<div class="sourceCode" id="cb158"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb158-1"><a href="#cb158-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_deleted<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb158-2"><a href="#cb158-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_defaulted<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_323" id="pnum_323">5</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a function that is a
 deleted function ([dcl.fct.def.delete]) or defined as defaulted
 ([dcl.fct.def.default]), respectively. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb153"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb153-1"><a href="#cb153-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_user_provided<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb153-2"><a href="#cb153-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_user_declared<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_279" id="pnum_279">6</a></span>
+<div class="sourceCode" id="cb159"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb159-1"><a href="#cb159-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_user_provided<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb159-2"><a href="#cb159-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_user_declared<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_324" id="pnum_324">6</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a function that is
 user-provided or user-declared (<span>9.5.2 <a href="https://wg21.link/dcl.fct.def.default">[dcl.fct.def.default]</a></span>),
 respectively. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb154"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb154-1"><a href="#cb154-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_explicit<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_280" id="pnum_280">7</a></span>
+<div class="sourceCode" id="cb160"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb160-1"><a href="#cb160-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_explicit<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_325" id="pnum_325">7</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a member function that
@@ -8734,8 +9441,8 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 <code class="sourceCode cpp"><span class="kw">false</span></code>
 because in general such queries for templates cannot be answered.<span>
 — <em>end note</em> ]</span></span></p>
-<div class="sourceCode" id="cb155"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb155-1"><a href="#cb155-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_noexcept<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_281" id="pnum_281">8</a></span>
+<div class="sourceCode" id="cb161"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb161-1"><a href="#cb161-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_noexcept<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_326" id="pnum_326">8</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a
@@ -8751,8 +9458,8 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 <code class="sourceCode cpp"><span class="kw">false</span></code>
 because in general such queries for templates cannot be answered.<span>
 — <em>end note</em> ]</span></span></p>
-<div class="sourceCode" id="cb156"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb156-1"><a href="#cb156-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_bit_field<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_282" id="pnum_282">9</a></span>
+<div class="sourceCode" id="cb162"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb162-1"><a href="#cb162-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_bit_field<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_327" id="pnum_327">9</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a bit-field, or if
@@ -8761,16 +9468,16 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 declared with the properties represented by
 <code class="sourceCode cpp">r</code> would be a bit-field. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb157"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb157-1"><a href="#cb157-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_enumerator<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_283" id="pnum_283">10</a></span>
+<div class="sourceCode" id="cb163"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb163-1"><a href="#cb163-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_enumerator<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_328" id="pnum_328">10</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents an enumerator.
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb158"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb158-1"><a href="#cb158-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_const<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb158-2"><a href="#cb158-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_volatile<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_284" id="pnum_284">11</a></span>
+<div class="sourceCode" id="cb164"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb164-1"><a href="#cb164-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_const<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb164-2"><a href="#cb164-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_volatile<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_329" id="pnum_329">11</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a const or volatile
@@ -8778,38 +9485,38 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 (respectively), or an object, variable, non-static data member, or
 function with such a type. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb159"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb159-1"><a href="#cb159-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_mutable_member<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_285" id="pnum_285">12</a></span>
+<div class="sourceCode" id="cb165"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb165-1"><a href="#cb165-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_mutable_member<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_330" id="pnum_330">12</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a
 <code class="sourceCode cpp"><span class="kw">mutable</span></code>
 non-static data member. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb160"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb160-1"><a href="#cb160-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_lvalue_reference_qualified<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb160-2"><a href="#cb160-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_rvalue_reference_qualified<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_286" id="pnum_286">13</a></span>
+<div class="sourceCode" id="cb166"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb166-1"><a href="#cb166-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_lvalue_reference_qualified<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb166-2"><a href="#cb166-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_rvalue_reference_qualified<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_331" id="pnum_331">13</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a lvalue- or
 rvalue-reference qualified function type (respectively), or a member
 function with such a type. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb161"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb161-1"><a href="#cb161-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_static_storage_duration<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb161-2"><a href="#cb161-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_thread_storage_duration<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb161-3"><a href="#cb161-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_automatic_storage_duration<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_287" id="pnum_287">14</a></span>
+<div class="sourceCode" id="cb167"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb167-1"><a href="#cb167-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_static_storage_duration<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb167-2"><a href="#cb167-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_thread_storage_duration<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb167-3"><a href="#cb167-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_automatic_storage_duration<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_332" id="pnum_332">14</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents an object or variable
 that has static, thread, or automatic storage duration, respectively
 ([basic.stc]). Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb162"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb162-1"><a href="#cb162-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_internal_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb162-2"><a href="#cb162-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_module_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb162-3"><a href="#cb162-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_external_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb162-4"><a href="#cb162-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_linkage<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_288" id="pnum_288">15</a></span>
+<div class="sourceCode" id="cb168"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb168-1"><a href="#cb168-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_internal_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb168-2"><a href="#cb168-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_module_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb168-3"><a href="#cb168-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_external_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb168-4"><a href="#cb168-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_linkage<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_333" id="pnum_333">15</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a variable, function,
@@ -8817,8 +9524,8 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 linkage, external linkage, or any linkage, respectively ([basic.link]).
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb163"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb163-1"><a href="#cb163-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_complete_type<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_289" id="pnum_289">16</a></span>
+<div class="sourceCode" id="cb169"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb169-1"><a href="#cb169-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_complete_type<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_334" id="pnum_334">16</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">is_type<span class="op">(</span>r<span class="op">)</span></code>
@@ -8827,8 +9534,8 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 represented by <code class="sourceCode cpp">dealias<span class="op">(</span>r<span class="op">)</span></code>
 is not an incomplete type ([basic.types]). Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb164"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb164-1"><a href="#cb164-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_complete_definition<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_290" id="pnum_290">17</a></span>
+<div class="sourceCode" id="cb170"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb170-1"><a href="#cb170-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_complete_definition<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_335" id="pnum_335">17</a></span>
 Returns:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a function, class type,
@@ -8836,29 +9543,29 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 introduced within the scope of the entity represented by
 <code class="sourceCode cpp">r</code>. Otherwise
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb165"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb165-1"><a href="#cb165-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_namespace<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_291" id="pnum_291">18</a></span>
+<div class="sourceCode" id="cb171"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb171-1"><a href="#cb171-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_namespace<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_336" id="pnum_336">18</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a namespace or
 <code class="sourceCode cpp"><em>namespace-alias</em></code>. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb166"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb166-1"><a href="#cb166-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_variable<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_292" id="pnum_292">19</a></span>
+<div class="sourceCode" id="cb172"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb172-1"><a href="#cb172-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_variable<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_337" id="pnum_337">19</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a variable. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb167"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb167-1"><a href="#cb167-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_type<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_293" id="pnum_293">20</a></span>
+<div class="sourceCode" id="cb173"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb173-1"><a href="#cb173-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_type<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_338" id="pnum_338">20</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a type or a
 <code class="sourceCode cpp"><em>typedef-name</em></code>. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb168"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb168-1"><a href="#cb168-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_type_alias<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb168-2"><a href="#cb168-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_namespace_alias<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_294" id="pnum_294">21</a></span>
+<div class="sourceCode" id="cb174"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb174-1"><a href="#cb174-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_type_alias<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb174-2"><a href="#cb174-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_namespace_alias<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_339" id="pnum_339">21</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a
@@ -8869,31 +9576,31 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 <code class="sourceCode cpp"><em>typedef-name</em></code><span>
 — <em>end note</em> ]</span></span>. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb169"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb169-1"><a href="#cb169-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_295" id="pnum_295">22</a></span>
+<div class="sourceCode" id="cb175"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb175-1"><a href="#cb175-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_340" id="pnum_340">22</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a function. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb170"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb170-1"><a href="#cb170-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_conversion_function<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb170-2"><a href="#cb170-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_operator_function<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb170-3"><a href="#cb170-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_literal_operator<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_296" id="pnum_296">23</a></span>
+<div class="sourceCode" id="cb176"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb176-1"><a href="#cb176-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_conversion_function<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb176-2"><a href="#cb176-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_operator_function<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb176-3"><a href="#cb176-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_literal_operator<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_341" id="pnum_341">23</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a conversion function,
 operator function, or literal operator, respectively. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb171"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb171-1"><a href="#cb171-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_special_member_function<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb171-2"><a href="#cb171-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb171-3"><a href="#cb171-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_default_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb171-4"><a href="#cb171-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb171-5"><a href="#cb171-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb171-6"><a href="#cb171-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_assignment<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb171-7"><a href="#cb171-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_assignment<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb171-8"><a href="#cb171-8" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_assignment<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb171-9"><a href="#cb171-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_destructor<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_297" id="pnum_297">24</a></span>
+<div class="sourceCode" id="cb177"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb177-1"><a href="#cb177-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_special_member_function<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb177-2"><a href="#cb177-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb177-3"><a href="#cb177-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_default_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb177-4"><a href="#cb177-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb177-5"><a href="#cb177-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb177-6"><a href="#cb177-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_assignment<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb177-7"><a href="#cb177-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_assignment<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb177-8"><a href="#cb177-8" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_assignment<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb177-9"><a href="#cb177-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_destructor<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_342" id="pnum_342">24</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a function that is a
@@ -8902,15 +9609,15 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 operator, a copy assignment operator, a move assignment operator, or a
 destructor, respectively. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb172"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb172-1"><a href="#cb172-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_template<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_298" id="pnum_298">25</a></span>
+<div class="sourceCode" id="cb178"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb178-1"><a href="#cb178-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_template<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_343" id="pnum_343">25</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a function template,
 class template, variable template, alias template, or concept.
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_299" id="pnum_299">26</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_344" id="pnum_344">26</a></span>
 <span class="note"><span>[ <em>Note 4:</em> </span>A template
 specialization is not a template. <code class="sourceCode cpp">is_template<span class="op">(^^</span>std<span class="op">::</span>vector<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code> but
@@ -8918,16 +9625,16 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 is
 <code class="sourceCode cpp"><span class="kw">false</span></code>.<span>
 — <em>end note</em> ]</span></span></p>
-<div class="sourceCode" id="cb173"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb173-1"><a href="#cb173-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb173-2"><a href="#cb173-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_variable_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb173-3"><a href="#cb173-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb173-4"><a href="#cb173-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_alias_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb173-5"><a href="#cb173-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_conversion_function_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb173-6"><a href="#cb173-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_operator_function_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb173-7"><a href="#cb173-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_literal_operator_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb173-8"><a href="#cb173-8" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructor_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb173-9"><a href="#cb173-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_concept<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_300" id="pnum_300">27</a></span>
+<div class="sourceCode" id="cb179"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb179-1"><a href="#cb179-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb179-2"><a href="#cb179-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_variable_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb179-3"><a href="#cb179-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb179-4"><a href="#cb179-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_alias_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb179-5"><a href="#cb179-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_conversion_function_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb179-6"><a href="#cb179-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_operator_function_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb179-7"><a href="#cb179-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_literal_operator_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb179-8"><a href="#cb179-8" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructor_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb179-9"><a href="#cb179-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_concept<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_345" id="pnum_345">27</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a function template,
@@ -8935,56 +9642,56 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 template, operator function template, literal operator template,
 constructor template, or concept respectively. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb174"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb174-1"><a href="#cb174-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_template_arguments<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_301" id="pnum_301">28</a></span>
+<div class="sourceCode" id="cb180"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb180-1"><a href="#cb180-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_template_arguments<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_346" id="pnum_346">28</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a specialization of a
 function template, variable template, class template, or an alias
 template. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb175"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb175-1"><a href="#cb175-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_value<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb175-2"><a href="#cb175-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_object<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_302" id="pnum_302">29</a></span>
+<div class="sourceCode" id="cb181"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb181-1"><a href="#cb181-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_value<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb181-2"><a href="#cb181-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_object<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_347" id="pnum_347">29</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a value or object,
 respectively. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb176"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb176-1"><a href="#cb176-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_structured_binding<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_303" id="pnum_303">30</a></span>
+<div class="sourceCode" id="cb182"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb182-1"><a href="#cb182-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_structured_binding<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_348" id="pnum_348">30</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a structured binding.
 Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb177"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb177-1"><a href="#cb177-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class_member<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb177-2"><a href="#cb177-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_namespace_member<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb177-3"><a href="#cb177-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nonstatic_data_member<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb177-4"><a href="#cb177-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_static_member<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb177-5"><a href="#cb177-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_base<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_304" id="pnum_304">31</a></span>
+<div class="sourceCode" id="cb183"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb183-1"><a href="#cb183-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class_member<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb183-2"><a href="#cb183-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_namespace_member<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb183-3"><a href="#cb183-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nonstatic_data_member<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb183-4"><a href="#cb183-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_static_member<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb183-5"><a href="#cb183-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_base<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_349" id="pnum_349">31</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a class member,
 namespace member, non-static data member, static member, base class
 specifier, respectively. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb178"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb178-1"><a href="#cb178-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_default_member_initializer<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_305" id="pnum_305">32</a></span>
+<div class="sourceCode" id="cb184"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb184-1"><a href="#cb184-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_default_member_initializer<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_350" id="pnum_350">32</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a non-static data
 member that has a default member initializer. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb179"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb179-1"><a href="#cb179-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info type_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_306" id="pnum_306">33</a></span>
+<div class="sourceCode" id="cb185"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb185-1"><a href="#cb185-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info type_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_351" id="pnum_351">33</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">r</code> represents
 a value, object, variable, function that is not a constructor or
 destructor, enumerator, non-static data member, bit-field, base class
 specifier, or description of a declaration of a non-static data
 member.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_307" id="pnum_307">34</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_352" id="pnum_352">34</a></span>
 <em>Returns</em>: If <code class="sourceCode cpp">r</code> represents an
 entity, object, or value, then the type of what is represented by
 <code class="sourceCode cpp">r</code>. Otherwise, if
@@ -8992,70 +9699,70 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 then the type of the base class. Otherwise, the type of any data member
 declared with the properties represented by
 <code class="sourceCode cpp">r</code>.</p>
-<div class="sourceCode" id="cb180"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb180-1"><a href="#cb180-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info object_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_308" id="pnum_308">35</a></span>
+<div class="sourceCode" id="cb186"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb186-1"><a href="#cb186-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info object_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_353" id="pnum_353">35</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">r</code> is a
 reflection representing either an object or a variable denoting an
 object with static storage duration ([expr.const]).</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_309" id="pnum_309">36</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_354" id="pnum_354">36</a></span>
 <em>Returns</em>: If <code class="sourceCode cpp">r</code> is a
 reflection of a variable, then a reflection of the object denoted by the
 variable. Otherwise, <code class="sourceCode cpp">r</code>.</p>
 <div class="example">
 <span>[ <em>Example 1:</em> </span>
-<div class="sourceCode" id="cb181"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb181-1"><a href="#cb181-1" aria-hidden="true" tabindex="-1"></a><span class="dt">int</span> x;</span>
-<span id="cb181-2"><a href="#cb181-2" aria-hidden="true" tabindex="-1"></a><span class="dt">int</span><span class="op">&amp;</span> y <span class="op">=</span> x;</span>
-<span id="cb181-3"><a href="#cb181-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb181-4"><a href="#cb181-4" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(^^</span>x <span class="op">!=</span> <span class="op">^^</span>y<span class="op">)</span>;                       <span class="co">// OK, x and y are different variables so their</span></span>
-<span id="cb181-5"><a href="#cb181-5" aria-hidden="true" tabindex="-1"></a>                                                 <span class="co">// reflections compare different</span></span>
-<span id="cb181-6"><a href="#cb181-6" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>object_of<span class="op">(^^</span>x<span class="op">)</span> <span class="op">==</span> object_of<span class="op">(^^</span>y<span class="op">))</span>; <span class="co">// OK, because y is a reference</span></span>
-<span id="cb181-7"><a href="#cb181-7" aria-hidden="true" tabindex="-1"></a>                                                 <span class="co">// to x, their underlying objects are the same</span></span></code></pre></div>
+<div class="sourceCode" id="cb187"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb187-1"><a href="#cb187-1" aria-hidden="true" tabindex="-1"></a><span class="dt">int</span> x;</span>
+<span id="cb187-2"><a href="#cb187-2" aria-hidden="true" tabindex="-1"></a><span class="dt">int</span><span class="op">&amp;</span> y <span class="op">=</span> x;</span>
+<span id="cb187-3"><a href="#cb187-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb187-4"><a href="#cb187-4" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(^^</span>x <span class="op">!=</span> <span class="op">^^</span>y<span class="op">)</span>;                       <span class="co">// OK, x and y are different variables so their</span></span>
+<span id="cb187-5"><a href="#cb187-5" aria-hidden="true" tabindex="-1"></a>                                                 <span class="co">// reflections compare different</span></span>
+<span id="cb187-6"><a href="#cb187-6" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>object_of<span class="op">(^^</span>x<span class="op">)</span> <span class="op">==</span> object_of<span class="op">(^^</span>y<span class="op">))</span>; <span class="co">// OK, because y is a reference</span></span>
+<span id="cb187-7"><a href="#cb187-7" aria-hidden="true" tabindex="-1"></a>                                                 <span class="co">// to x, their underlying objects are the same</span></span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
-<div class="sourceCode" id="cb182"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb182-1"><a href="#cb182-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info value_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_310" id="pnum_310">37</a></span>
+<div class="sourceCode" id="cb188"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb188-1"><a href="#cb188-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info value_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_355" id="pnum_355">37</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">r</code> is a
 reflection representing</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_311" id="pnum_311">(37.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_356" id="pnum_356">(37.1)</a></span>
 either an object or variable, usable in constant expressions from some
 point in the evaluation context ([expr.const]), whose type is a
 structural type ([temp.type]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_312" id="pnum_312">(37.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_357" id="pnum_357">(37.2)</a></span>
 an enumerator, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_313" id="pnum_313">(37.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_358" id="pnum_358">(37.3)</a></span>
 a value.</li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_314" id="pnum_314">38</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_359" id="pnum_359">38</a></span>
 <em>Returns</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_315" id="pnum_315">(38.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_360" id="pnum_360">(38.1)</a></span>
 If <code class="sourceCode cpp">r</code> is a reflection of an object
 <code class="sourceCode cpp">o</code>, or a reflection of a variable
 which designates an object <code class="sourceCode cpp">o</code>, then a
 reflection of the value held by <code class="sourceCode cpp">o</code>.
 The reflected value has type <code class="sourceCode cpp">type_of<span class="op">(</span>o<span class="op">)</span></code>,
 with the cv-qualifiers removed if this is a scalar type</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_316" id="pnum_316">(38.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_361" id="pnum_361">(38.2)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> is a reflection of
 an enumerator, then a reflection of the value of the enumerator.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_317" id="pnum_317">(38.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_362" id="pnum_362">(38.3)</a></span>
 Otherwise, <code class="sourceCode cpp">r</code>.</li>
 </ul>
 <div class="example">
 <span>[ <em>Example 2:</em> </span>
-<div class="sourceCode" id="cb183"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb183-1"><a href="#cb183-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> x <span class="op">=</span> <span class="dv">0</span>;</span>
-<span id="cb183-2"><a href="#cb183-2" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> y <span class="op">=</span> <span class="dv">0</span>;</span>
-<span id="cb183-3"><a href="#cb183-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-4"><a href="#cb183-4" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(^^</span>x <span class="op">!=</span> <span class="op">^^</span>y<span class="op">)</span>;                         <span class="co">// OK, x and y are different variables so their</span></span>
-<span id="cb183-5"><a href="#cb183-5" aria-hidden="true" tabindex="-1"></a>                                                 <span class="co">// reflections compare different</span></span>
-<span id="cb183-6"><a href="#cb183-6" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>value_of<span class="op">(^^</span>x<span class="op">)</span> <span class="op">==</span> value_of<span class="op">(^^</span>y<span class="op">))</span>;     <span class="co">// OK, both value_of(^^x) and value_of(^^y) represent</span></span>
-<span id="cb183-7"><a href="#cb183-7" aria-hidden="true" tabindex="-1"></a>                                                 <span class="co">// the value 0</span></span>
-<span id="cb183-8"><a href="#cb183-8" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>value_of<span class="op">(^^</span>x<span class="op">)</span> <span class="op">==</span> reflect_value<span class="op">(</span><span class="dv">0</span><span class="op">))</span>; <span class="co">// OK, likewise</span></span></code></pre></div>
+<div class="sourceCode" id="cb189"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb189-1"><a href="#cb189-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> x <span class="op">=</span> <span class="dv">0</span>;</span>
+<span id="cb189-2"><a href="#cb189-2" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">int</span> y <span class="op">=</span> <span class="dv">0</span>;</span>
+<span id="cb189-3"><a href="#cb189-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb189-4"><a href="#cb189-4" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(^^</span>x <span class="op">!=</span> <span class="op">^^</span>y<span class="op">)</span>;                         <span class="co">// OK, x and y are different variables so their</span></span>
+<span id="cb189-5"><a href="#cb189-5" aria-hidden="true" tabindex="-1"></a>                                                 <span class="co">// reflections compare different</span></span>
+<span id="cb189-6"><a href="#cb189-6" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>value_of<span class="op">(^^</span>x<span class="op">)</span> <span class="op">==</span> value_of<span class="op">(^^</span>y<span class="op">))</span>;     <span class="co">// OK, both value_of(^^x) and value_of(^^y) represent</span></span>
+<span id="cb189-7"><a href="#cb189-7" aria-hidden="true" tabindex="-1"></a>                                                 <span class="co">// the value 0</span></span>
+<span id="cb189-8"><a href="#cb189-8" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>value_of<span class="op">(^^</span>x<span class="op">)</span> <span class="op">==</span> reflect_value<span class="op">(</span><span class="dv">0</span><span class="op">))</span>; <span class="co">// OK, likewise</span></span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
-<div class="sourceCode" id="cb184"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb184-1"><a href="#cb184-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info parent_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_318" id="pnum_318">39</a></span>
+<div class="sourceCode" id="cb190"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb190-1"><a href="#cb190-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info parent_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_363" id="pnum_363">39</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">r</code> represents
 a variable, structured binding, function, enumerator, class, class
 member, bit-field, template, namespace or
@@ -9063,54 +9770,54 @@ <h3 class="unnumbered" id="meta.reflection.queries-reflection-queries">[meta.ref
 <code class="sourceCode cpp"><span class="op">::</span></code>),
 <code class="sourceCode cpp"><em>typedef-name</em></code>, or base class
 specifier.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_319" id="pnum_319">40</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_364" id="pnum_364">40</a></span>
 <em>Returns</em>: If <code class="sourceCode cpp">r</code> represents a
 non-static data member that is a direct member of an anonymous union,
 then a reflection representing the innermost enclosing anonymous union.
 Otherwise, a reflection of the class, function, or namespace that is the
 target scope ([basic.scope.scope]) of the first declaration of what is
 represented by <code class="sourceCode cpp">r</code>.</p>
-<div class="sourceCode" id="cb185"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb185-1"><a href="#cb185-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info dealias<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_320" id="pnum_320">41</a></span>
+<div class="sourceCode" id="cb191"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb191-1"><a href="#cb191-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info dealias<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_365" id="pnum_365">41</a></span>
 <em>Returns</em>: If <code class="sourceCode cpp">r</code> represents a
 <code class="sourceCode cpp"><em>typedef-name</em></code> or
 <code class="sourceCode cpp"><em>namespace-alias</em></code>, then a
 reflection representing the entity named by what
 <code class="sourceCode cpp">r</code> represents. Otherwise,
 <code class="sourceCode cpp">r</code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_321" id="pnum_321">42</a></span></p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_366" id="pnum_366">42</a></span></p>
 <div class="example">
 <span>[ <em>Example 3:</em> </span>
-<div class="sourceCode" id="cb186"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb186-1"><a href="#cb186-1" aria-hidden="true" tabindex="-1"></a>using X = int;</span>
-<span id="cb186-2"><a href="#cb186-2" aria-hidden="true" tabindex="-1"></a>using Y = X;</span>
-<span id="cb186-3"><a href="#cb186-3" aria-hidden="true" tabindex="-1"></a>static_assert(dealias(^^int) == ^^int);</span>
-<span id="cb186-4"><a href="#cb186-4" aria-hidden="true" tabindex="-1"></a>static_assert(dealias(^^X) == ^^int);</span>
-<span id="cb186-5"><a href="#cb186-5" aria-hidden="true" tabindex="-1"></a>static_assert(dealias(^^Y) == ^^int);</span></code></pre></div>
+<div class="sourceCode" id="cb192"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb192-1"><a href="#cb192-1" aria-hidden="true" tabindex="-1"></a>using X = int;</span>
+<span id="cb192-2"><a href="#cb192-2" aria-hidden="true" tabindex="-1"></a>using Y = X;</span>
+<span id="cb192-3"><a href="#cb192-3" aria-hidden="true" tabindex="-1"></a>static_assert(dealias(^^int) == ^^int);</span>
+<span id="cb192-4"><a href="#cb192-4" aria-hidden="true" tabindex="-1"></a>static_assert(dealias(^^X) == ^^int);</span>
+<span id="cb192-5"><a href="#cb192-5" aria-hidden="true" tabindex="-1"></a>static_assert(dealias(^^Y) == ^^int);</span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
-<div class="sourceCode" id="cb187"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb187-1"><a href="#cb187-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info template_of<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb187-2"><a href="#cb187-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> template_arguments_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_322" id="pnum_322">43</a></span>
+<div class="sourceCode" id="cb193"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb193-1"><a href="#cb193-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info template_of<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb193-2"><a href="#cb193-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> template_arguments_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_367" id="pnum_367">43</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">has_template_arguments<span class="op">(</span>r<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_323" id="pnum_323">44</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_368" id="pnum_368">44</a></span>
 <em>Returns</em>: A reflection of the primary template of
 <code class="sourceCode cpp">r</code>, and the reflections of the
 template arguments of the specialization represented by
 <code class="sourceCode cpp">r</code>, respectively.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_324" id="pnum_324">45</a></span></p>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_369" id="pnum_369">45</a></span></p>
 <div class="example">
 <span>[ <em>Example 4:</em> </span>
-<div class="sourceCode" id="cb188"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb188-1"><a href="#cb188-1" aria-hidden="true" tabindex="-1"></a>template &lt;class T, class U=T&gt; struct Pair { };</span>
-<span id="cb188-2"><a href="#cb188-2" aria-hidden="true" tabindex="-1"></a>template &lt;class T&gt; struct Pair&lt;char, T&gt; { };</span>
-<span id="cb188-3"><a href="#cb188-3" aria-hidden="true" tabindex="-1"></a>template &lt;class T&gt; using PairPtr = Pair&lt;T*&gt;;</span>
-<span id="cb188-4"><a href="#cb188-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb188-5"><a href="#cb188-5" aria-hidden="true" tabindex="-1"></a>static_assert(template_of(^^Pair&lt;int&gt;) == ^^Pair);</span>
-<span id="cb188-6"><a href="#cb188-6" aria-hidden="true" tabindex="-1"></a>static_assert(template_of(^^Pair&lt;char, char&gt;) == ^^Pair);</span>
-<span id="cb188-7"><a href="#cb188-7" aria-hidden="true" tabindex="-1"></a>static_assert(template_arguments_of(^^Pair&lt;int&gt;).size() == 2);</span>
-<span id="cb188-8"><a href="#cb188-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb188-9"><a href="#cb188-9" aria-hidden="true" tabindex="-1"></a>static_assert(template_of(^^PairPtr&lt;int&gt;) == ^^PairPtr);</span>
-<span id="cb188-10"><a href="#cb188-10" aria-hidden="true" tabindex="-1"></a>static_assert(template_arguments_of(^^PairPtr&lt;int&gt;).size() == 1);</span></code></pre></div>
+<div class="sourceCode" id="cb194"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb194-1"><a href="#cb194-1" aria-hidden="true" tabindex="-1"></a>template &lt;class T, class U=T&gt; struct Pair { };</span>
+<span id="cb194-2"><a href="#cb194-2" aria-hidden="true" tabindex="-1"></a>template &lt;class T&gt; struct Pair&lt;char, T&gt; { };</span>
+<span id="cb194-3"><a href="#cb194-3" aria-hidden="true" tabindex="-1"></a>template &lt;class T&gt; using PairPtr = Pair&lt;T*&gt;;</span>
+<span id="cb194-4"><a href="#cb194-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb194-5"><a href="#cb194-5" aria-hidden="true" tabindex="-1"></a>static_assert(template_of(^^Pair&lt;int&gt;) == ^^Pair);</span>
+<span id="cb194-6"><a href="#cb194-6" aria-hidden="true" tabindex="-1"></a>static_assert(template_of(^^Pair&lt;char, char&gt;) == ^^Pair);</span>
+<span id="cb194-7"><a href="#cb194-7" aria-hidden="true" tabindex="-1"></a>static_assert(template_arguments_of(^^Pair&lt;int&gt;).size() == 2);</span>
+<span id="cb194-8"><a href="#cb194-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb194-9"><a href="#cb194-9" aria-hidden="true" tabindex="-1"></a>static_assert(template_of(^^PairPtr&lt;int&gt;) == ^^PairPtr);</span>
+<span id="cb194-10"><a href="#cb194-10" aria-hidden="true" tabindex="-1"></a>static_assert(template_arguments_of(^^PairPtr&lt;int&gt;).size() == 1);</span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
 </div>
@@ -9121,12 +9828,12 @@ <h3 class="unnumbered" id="meta.reflection.member.queries-reflection-member-quer
 <div class="std">
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb189"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb189-1"><a href="#cb189-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> members_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_325" id="pnum_325">1</a></span>
+<div class="sourceCode" id="cb195"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb195-1"><a href="#cb195-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> members_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_370" id="pnum_370">1</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">r</code> is a
 reflection representing either a class type that is complete from some
 point in the evaluation context or a namespace.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_326" id="pnum_326">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_371" id="pnum_371">2</a></span>
 A member of a class or namespace
 <code class="sourceCode cpp"><em>E</em></code> is
 <em>members-of-representable</em> if it is either</p>
@@ -9149,7 +9856,7 @@ <h3 class="unnumbered" id="meta.reflection.member.queries-reflection-member-quer
 members-of-representable members include: injected class names, partial
 template specializations, friend declarations, and static
 assertions.<span> — <em>end note</em> ]</span></span></p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_327" id="pnum_327">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_372" id="pnum_372">3</a></span>
 A member <code class="sourceCode cpp"><em>M</em></code> of a class or
 namespace is <em>members-of-reachable</em> from a point
 <code class="sourceCode cpp"><em>P</em></code> if there exists a
@@ -9160,7 +9867,7 @@ <h3 class="unnumbered" id="meta.reflection.member.queries-reflection-member-quer
 <code class="sourceCode cpp"><em>D</em></code> is declared in the
 translation unit containing
 <code class="sourceCode cpp"><em>P</em></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_328" id="pnum_328">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_373" id="pnum_373">4</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">vector</code>
 containing reflections of all members-of-representable members of the
 entity represented by <code class="sourceCode cpp">r</code> that are
@@ -9174,11 +9881,11 @@ <h3 class="unnumbered" id="meta.reflection.member.queries-reflection-member-quer
 but the order of namespace members is unspecified. <span class="note"><span>[ <em>Note 2:</em> </span>Base classes are not
 members. Implicitly-declared special members appear after any
 user-declared members.<span> — <em>end note</em> ]</span></span></p>
-<div class="sourceCode" id="cb190"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb190-1"><a href="#cb190-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> bases_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_329" id="pnum_329">5</a></span>
+<div class="sourceCode" id="cb196"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb196-1"><a href="#cb196-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> bases_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_374" id="pnum_374">5</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>type<span class="op">)</span></code>
 is a reflection representing a complete class type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_330" id="pnum_330">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_375" id="pnum_375">6</a></span>
 <em>Returns</em>: Let <code class="sourceCode cpp">C</code> be the type
 represented by <code class="sourceCode cpp">dealias<span class="op">(</span>type<span class="op">)</span></code>.
 A <code class="sourceCode cpp">vector</code> containing the reflections
@@ -9187,71 +9894,71 @@ <h3 class="unnumbered" id="meta.reflection.member.queries-reflection-member-quer
 indexed in the order in which they appear in the
 <em>base-specifier-list</em> of
 <code class="sourceCode cpp">C</code>.</p>
-<div class="sourceCode" id="cb191"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb191-1"><a href="#cb191-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> static_data_members_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_331" id="pnum_331">7</a></span>
+<div class="sourceCode" id="cb197"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb197-1"><a href="#cb197-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> static_data_members_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_376" id="pnum_376">7</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>type<span class="op">)</span></code>
 represents a complete class type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_332" id="pnum_332">8</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_377" id="pnum_377">8</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">vector</code>
 containing each element <code class="sourceCode cpp">e</code> of <code class="sourceCode cpp">members_of<span class="op">(</span>type<span class="op">)</span></code>
 such that <code class="sourceCode cpp">is_variable<span class="op">(</span>e<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>, in
 order.</p>
-<div class="sourceCode" id="cb192"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb192-1"><a href="#cb192-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> nonstatic_data_members_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_333" id="pnum_333">9</a></span>
+<div class="sourceCode" id="cb198"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb198-1"><a href="#cb198-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> nonstatic_data_members_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_378" id="pnum_378">9</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>type<span class="op">)</span></code>
 represents a complete class type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_334" id="pnum_334">10</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_379" id="pnum_379">10</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">vector</code>
 containing each element <code class="sourceCode cpp">e</code> of <code class="sourceCode cpp">members_of<span class="op">(</span>type<span class="op">)</span></code>
 such that <code class="sourceCode cpp">is_nonstatic_data_member<span class="op">(</span>e<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>, in
 order.</p>
-<div class="sourceCode" id="cb193"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb193-1"><a href="#cb193-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> enumerators_of<span class="op">(</span>info type_enum<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_335" id="pnum_335">11</a></span>
+<div class="sourceCode" id="cb199"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb199-1"><a href="#cb199-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> enumerators_of<span class="op">(</span>info type_enum<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_380" id="pnum_380">11</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>type_enum<span class="op">)</span></code>
 represents an enumeration type and <code class="sourceCode cpp">has_complete_definition<span class="op">(</span>dealias<span class="op">(</span>type_enum<span class="op">))</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_336" id="pnum_336">12</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_381" id="pnum_381">12</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">vector</code>
 containing the reflections of each enumerator of the enumeration
 represented by <code class="sourceCode cpp">dealias<span class="op">(</span>type_enum<span class="op">)</span></code>,
 in the order in which they are declared.</p>
-<div class="sourceCode" id="cb194"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb194-1"><a href="#cb194-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> get_public_members<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_337" id="pnum_337">13</a></span>
+<div class="sourceCode" id="cb200"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb200-1"><a href="#cb200-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> get_public_members<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_382" id="pnum_382">13</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>type<span class="op">)</span></code>
 represents a complete class type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_338" id="pnum_338">14</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_383" id="pnum_383">14</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">vector</code>
 containing each element <code class="sourceCode cpp">e</code> of <code class="sourceCode cpp">members_of<span class="op">(</span>type<span class="op">)</span></code>
 such that <code class="sourceCode cpp">is_public<span class="op">(</span>e<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>, in
 order.</p>
-<div class="sourceCode" id="cb195"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb195-1"><a href="#cb195-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> get_public_bases<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_339" id="pnum_339">15</a></span>
+<div class="sourceCode" id="cb201"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb201-1"><a href="#cb201-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> get_public_bases<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_384" id="pnum_384">15</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>type<span class="op">)</span></code>
 represents a complete class type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_340" id="pnum_340">16</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_385" id="pnum_385">16</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">vector</code>
 containing each element <code class="sourceCode cpp">e</code> of <code class="sourceCode cpp">bases_of<span class="op">(</span>type<span class="op">)</span></code>
 such that <code class="sourceCode cpp">is_public<span class="op">(</span>e<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>, in
 order.</p>
-<div class="sourceCode" id="cb196"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb196-1"><a href="#cb196-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> get_public_static_data_members<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_341" id="pnum_341">17</a></span>
+<div class="sourceCode" id="cb202"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb202-1"><a href="#cb202-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> get_public_static_data_members<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_386" id="pnum_386">17</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>type<span class="op">)</span></code>
 represents a complete class type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_342" id="pnum_342">18</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_387" id="pnum_387">18</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">vector</code>
 containing each element <code class="sourceCode cpp">e</code> of <code class="sourceCode cpp">static_data_members_of<span class="op">(</span>type<span class="op">)</span></code>
 such that <code class="sourceCode cpp">is_public<span class="op">(</span>e<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>, in
 order.</p>
-<div class="sourceCode" id="cb197"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb197-1"><a href="#cb197-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> get_public_nonstatic_data_members<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_343" id="pnum_343">19</a></span>
+<div class="sourceCode" id="cb203"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb203-1"><a href="#cb203-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> get_public_nonstatic_data_members<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_388" id="pnum_388">19</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>type<span class="op">)</span></code>
 represents a complete class type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_344" id="pnum_344">20</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_389" id="pnum_389">20</a></span>
 <em>Returns</em>: A <code class="sourceCode cpp">vector</code>
 containing each element <code class="sourceCode cpp">e</code> of <code class="sourceCode cpp">nonstatic_data_members_of<span class="op">(</span>type<span class="op">)</span></code>
 such that <code class="sourceCode cpp">is_public<span class="op">(</span>e<span class="op">)</span></code>
@@ -9265,23 +9972,23 @@ <h3 class="unnumbered" id="meta.reflection.layout-reflection-layout-queries">[me
 <div class="std">
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb198"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb198-1"><a href="#cb198-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">ptrdiff_t</span> member_offset<span class="op">::</span>total_bits<span class="op">()</span> <span class="kw">const</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_345" id="pnum_345">1</a></span>
+<div class="sourceCode" id="cb204"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb204-1"><a href="#cb204-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">ptrdiff_t</span> member_offset<span class="op">::</span>total_bits<span class="op">()</span> <span class="kw">const</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_390" id="pnum_390">1</a></span>
 <em>Returns</em>: <code class="sourceCode cpp">bytes <span class="op">*</span> CHAR_BIT <span class="op">+</span> bits</code>.</p>
-<div class="sourceCode" id="cb199"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb199-1"><a href="#cb199-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> member_offset offset_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_346" id="pnum_346">2</a></span>
+<div class="sourceCode" id="cb205"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb205-1"><a href="#cb205-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> member_offset offset_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_391" id="pnum_391">2</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">r</code> represents
 a non-static data member, unnamed bit-field, or base class specifier
 other than a virtual base class specifier of an abstract class.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_347" id="pnum_347">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_392" id="pnum_392">3</a></span>
 Let <code class="sourceCode cpp"><em>V</em></code> be the offset in bits
 from the beginning of a complete object of type <code class="sourceCode cpp">parent_of<span class="op">(</span>r<span class="op">)</span></code>
 to the subobject associated with the entity represented by
 <code class="sourceCode cpp">r</code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_348" id="pnum_348">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_393" id="pnum_393">4</a></span>
 <em>Returns</em>: <code class="sourceCode cpp"><span class="op">{</span><em>V</em> <span class="op">/</span> CHAR_BIT, <em>V</em> <span class="op">%</span> CHAR_BIT<span class="op">}</span></code>.</p>
-<div class="sourceCode" id="cb200"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb200-1"><a href="#cb200-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> size_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_349" id="pnum_349">5</a></span>
+<div class="sourceCode" id="cb206"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb206-1"><a href="#cb206-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> size_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_394" id="pnum_394">5</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>r<span class="op">)</span></code>
 is a reflection of a type, object, value, variable of non-reference
 type, non-static data member, base class specifier, or description of a
@@ -9289,7 +9996,7 @@ <h3 class="unnumbered" id="meta.reflection.layout-reflection-layout-queries">[me
 represents a type <code class="sourceCode cpp"><em>T</em></code>, there
 is a point within the evaluation context from which
 <code class="sourceCode cpp"><em>T</em></code> is not incomplete.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_350" id="pnum_350">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_395" id="pnum_395">6</a></span>
 <em>Returns</em>: If <code class="sourceCode cpp">r</code> represents a
 non-static data member whose corresponding subobject has type
 <code class="sourceCode cpp"><em>T</em></code>, or a description of a
@@ -9301,8 +10008,8 @@ <h3 class="unnumbered" id="meta.reflection.layout-reflection-layout-queries">[me
 corresponding to a non-static data member of reference type has the same
 size and alignment as the corresponding pointer type.<span> — <em>end
 note</em> ]</span></span></p>
-<div class="sourceCode" id="cb201"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb201-1"><a href="#cb201-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> alignment_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_351" id="pnum_351">7</a></span>
+<div class="sourceCode" id="cb207"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb207-1"><a href="#cb207-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> alignment_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_396" id="pnum_396">7</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>r<span class="op">)</span></code>
 is a reflection representing a type, object, variable, non-static data
 member that is not a bit-field, base class specifier, or description of
@@ -9310,29 +10017,29 @@ <h3 class="unnumbered" id="meta.reflection.layout-reflection-layout-queries">[me
 represents a type <code class="sourceCode cpp"><em>T</em></code>, there
 is a point within the evaluation context from which
 <code class="sourceCode cpp"><em>T</em></code> is not incomplete.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_352" id="pnum_352">8</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_397" id="pnum_397">8</a></span>
 <em>Returns</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_353" id="pnum_353">(8.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_398" id="pnum_398">(8.1)</a></span>
 If <code class="sourceCode cpp">dealias<span class="op">(</span>r<span class="op">)</span></code>
 represents a type, variable, or object, then the alignment requirement
 of the entity or object.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_354" id="pnum_354">(8.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_399" id="pnum_399">(8.2)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a base
 class specifier, then <code class="sourceCode cpp">alignment_of<span class="op">(</span>type_of<span class="op">(</span>r<span class="op">))</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_355" id="pnum_355">(8.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_400" id="pnum_400">(8.3)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a
 non-static data member, then the alignment requirement of the subobject
 associated with the represented entity within any object of type <code class="sourceCode cpp">parent_of<span class="op">(</span>r<span class="op">)</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_356" id="pnum_356">(8.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_401" id="pnum_401">(8.4)</a></span>
 Otherwise (when <code class="sourceCode cpp">r</code> represents a
 description of a declaration of a non-static data member), then the
 <code class="sourceCode cpp"><em>alignment-specifier</em></code> of any
 data member declared having the properties described by
 <code class="sourceCode cpp">r</code>.</li>
 </ul>
-<div class="sourceCode" id="cb202"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb202-1"><a href="#cb202-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> bit_size_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_357" id="pnum_357">9</a></span>
+<div class="sourceCode" id="cb208"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb208-1"><a href="#cb208-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> bit_size_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_402" id="pnum_402">9</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">dealias<span class="op">(</span>r<span class="op">)</span></code>
 is a reflection of a type, object, value, variable of non-reference
 type, non-static data member, unnamed bit-field, base class specifier,
@@ -9340,7 +10047,7 @@ <h3 class="unnumbered" id="meta.reflection.layout-reflection-layout-queries">[me
 represents a type <code class="sourceCode cpp"><em>T</em></code>, there
 is a point within the evaluation context from which
 <code class="sourceCode cpp"><em>T</em></code> is not incomplete.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_358" id="pnum_358">10</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_403" id="pnum_403">10</a></span>
 <em>Returns</em>: If <code class="sourceCode cpp">r</code> represents a
 non-static data member that is a bit-field, an unnamed bit-field, or a
 description of a declaration of such a bit-field data member, then the
@@ -9353,32 +10060,32 @@ <h3 class="unnumbered" id="meta.reflection.extract-value-extraction">[meta.refle
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_359" id="pnum_359">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_404" id="pnum_404">1</a></span>
 The <code class="sourceCode cpp">extract</code> function template may be
 used to extract a value out of a reflection when the type is known.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_360" id="pnum_360">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_405" id="pnum_405">2</a></span>
 The following are defined for exposition only to aid in the
 specification of <code class="sourceCode cpp">extract</code>:</p>
-<div class="sourceCode" id="cb203"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb203-1"><a href="#cb203-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
-<span id="cb203-2"><a href="#cb203-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> T <em>extract-ref</em><span class="op">(</span>info r<span class="op">)</span>; <span class="co">// exposition only</span></span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_361" id="pnum_361">3</a></span>
+<div class="sourceCode" id="cb209"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb209-1"><a href="#cb209-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
+<span id="cb209-2"><a href="#cb209-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> T <em>extract-ref</em><span class="op">(</span>info r<span class="op">)</span>; <span class="co">// exposition only</span></span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_406" id="pnum_406">3</a></span>
 <span class="note"><span>[ <em>Note 1:</em>
 </span><code class="sourceCode cpp">T</code> is a reference type.<span>
 — <em>end note</em> ]</span></span></p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_362" id="pnum_362">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_407" id="pnum_407">4</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">r</code> represents
 a variable or object of type <code class="sourceCode cpp">U</code> that
 is usable in constant expressions from some point in the evaluation
 context and <code class="sourceCode cpp">is_convertible_v<span class="op">&lt;</span>remove_reference_t<span class="op">&lt;</span>U<span class="op">&gt;(*)[]</span>, remove_reference_t<span class="op">&lt;</span>T<span class="op">&gt;(*)[]&gt;</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_363" id="pnum_363">5</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_408" id="pnum_408">5</a></span>
 <em>Returns</em>: the object represented by <code class="sourceCode cpp">object_of<span class="op">(</span>r<span class="op">)</span></code>.</p>
-<div class="sourceCode" id="cb204"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb204-1"><a href="#cb204-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
-<span id="cb204-2"><a href="#cb204-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> T <em>extract-member-or-function</em><span class="op">(</span>info r<span class="op">)</span>; <span class="co">// exposition only</span></span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_364" id="pnum_364">6</a></span>
+<div class="sourceCode" id="cb210"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb210-1"><a href="#cb210-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
+<span id="cb210-2"><a href="#cb210-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> T <em>extract-member-or-function</em><span class="op">(</span>info r<span class="op">)</span>; <span class="co">// exposition only</span></span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_409" id="pnum_409">6</a></span>
 <em>Constant When</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_365" id="pnum_365">(6.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_410" id="pnum_410">(6.1)</a></span>
 If <code class="sourceCode cpp">r</code> represents a non-static data
 member of a class <code class="sourceCode cpp">C</code> with type
 <code class="sourceCode cpp">X</code>, then when
@@ -9386,7 +10093,7 @@ <h3 class="unnumbered" id="meta.reflection.extract-value-extraction">[meta.refle
 <code class="sourceCode cpp">X C<span class="op">::*</span></code> and
 <code class="sourceCode cpp">r</code> does not represent a
 bit-field.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_366" id="pnum_366">(6.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_411" id="pnum_411">(6.2)</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents an
 implicit object member function of class
 <code class="sourceCode cpp">C</code> with type
@@ -9394,7 +10101,7 @@ <h3 class="unnumbered" id="meta.reflection.extract-value-extraction">[meta.refle
 <code class="sourceCode cpp">F <span class="kw">noexcept</span></code>,
 then when <code class="sourceCode cpp">T</code> is
 <code class="sourceCode cpp">F C<span class="op">::*</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_367" id="pnum_367">(6.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_412" id="pnum_412">(6.3)</a></span>
 Otherwise, <code class="sourceCode cpp">r</code> represents a function,
 static member function, or explicit object member function of function
 type <code class="sourceCode cpp">F</code> or
@@ -9402,58 +10109,58 @@ <h3 class="unnumbered" id="meta.reflection.extract-value-extraction">[meta.refle
 then when <code class="sourceCode cpp">T</code> is
 <code class="sourceCode cpp">F<span class="op">*</span></code>.</li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_368" id="pnum_368">7</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_413" id="pnum_413">7</a></span>
 <em>Returns</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_369" id="pnum_369">(7.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_414" id="pnum_414">(7.1)</a></span>
 If <code class="sourceCode cpp">T</code> is a pointer type, then a
 pointer value pointing to the entity represented by
 <code class="sourceCode cpp">r</code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_370" id="pnum_370">(7.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_415" id="pnum_415">(7.2)</a></span>
 Otherwise, a pointer-to-member value designating the entity represented
 by <code class="sourceCode cpp">r</code>.</li>
 </ul>
-<div class="sourceCode" id="cb205"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb205-1"><a href="#cb205-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
-<span id="cb205-2"><a href="#cb205-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> T <em>extract-val</em><span class="op">(</span>info r<span class="op">)</span>; <span class="co">// exposition only</span></span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_371" id="pnum_371">8</a></span>
+<div class="sourceCode" id="cb211"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb211-1"><a href="#cb211-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
+<span id="cb211-2"><a href="#cb211-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> T <em>extract-val</em><span class="op">(</span>info r<span class="op">)</span>; <span class="co">// exposition only</span></span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_416" id="pnum_416">8</a></span>
 Let <code class="sourceCode cpp">U</code> be the type of the value that
 <code class="sourceCode cpp">r</code> represents.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_372" id="pnum_372">9</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_417" id="pnum_417">9</a></span>
 <em>Constant When</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_373" id="pnum_373">(9.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_418" id="pnum_418">(9.1)</a></span>
 <code class="sourceCode cpp">U</code> is a pointer type,
 <code class="sourceCode cpp">T</code> and
 <code class="sourceCode cpp">U</code> are similar types ([conv.qual]),
 and <code class="sourceCode cpp">is_convertible_v<span class="op">&lt;</span>U, T<span class="op">&gt;</span></code>
 is
 <code class="sourceCode cpp"><span class="kw">true</span></code>,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_374" id="pnum_374">(9.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_419" id="pnum_419">(9.2)</a></span>
 <code class="sourceCode cpp">U</code> is not a pointer type and the
 cv-unqualified types of <code class="sourceCode cpp">T</code> and
 <code class="sourceCode cpp">U</code> are the same, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_375" id="pnum_375">(9.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_420" id="pnum_420">(9.3)</a></span>
 <code class="sourceCode cpp">U</code> is a closure type,
 <code class="sourceCode cpp">T</code> is a function pointer type, and
 the value that <code class="sourceCode cpp">r</code> represents is
 convertible to <code class="sourceCode cpp">T</code>.</li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_376" id="pnum_376">10</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_421" id="pnum_421">10</a></span>
 <em>Returns</em>: the value that <code class="sourceCode cpp">r</code>
 represents converted to <code class="sourceCode cpp">T</code>.</p>
-<div class="sourceCode" id="cb206"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb206-1"><a href="#cb206-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
-<span id="cb206-2"><a href="#cb206-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> T extract<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_377" id="pnum_377">11</a></span>
+<div class="sourceCode" id="cb212"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb212-1"><a href="#cb212-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
+<span id="cb212-2"><a href="#cb212-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> T extract<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_422" id="pnum_422">11</a></span>
 <em>Effects</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_378" id="pnum_378">12</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_423" id="pnum_423">12</a></span>
 If <code class="sourceCode cpp">T</code> is a reference type, then
 equivalent to <code class="sourceCode cpp"><span class="cf">return</span> <em>extract-ref</em><span class="op">&lt;</span>T<span class="op">&gt;(</span>r<span class="op">)</span>;</code></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_379" id="pnum_379">13</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_424" id="pnum_424">13</a></span>
 Otherwise, if <code class="sourceCode cpp">r</code> represents a
 function, non-static data member, or member function, equivalent to
 <code class="sourceCode cpp"><span class="cf">return</span> <em>extract-member-or-function</em><span class="op">&lt;</span>T<span class="op">&gt;(</span>r<span class="op">)</span>;</code></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_380" id="pnum_380">14</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_425" id="pnum_425">14</a></span>
 Otherwise, equivalent to <code class="sourceCode cpp"><span class="cf">return</span> <em>extract-value</em><span class="op">&lt;</span>T<span class="op">&gt;(</span>value_of<span class="op">(</span>r<span class="op">))</span></code></li>
 </ul>
 </div>
@@ -9464,49 +10171,49 @@ <h3 class="unnumbered" id="meta.reflection.substitute-reflection-substitution">[
 <div class="std">
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb207"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb207-1"><a href="#cb207-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> R<span class="op">&gt;</span></span>
-<span id="cb207-2"><a href="#cb207-2" aria-hidden="true" tabindex="-1"></a><span class="kw">concept</span> reflection_range <span class="op">=</span></span>
-<span id="cb207-3"><a href="#cb207-3" aria-hidden="true" tabindex="-1"></a>  ranges<span class="op">::</span>input_range<span class="op">&lt;</span>R<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
-<span id="cb207-4"><a href="#cb207-4" aria-hidden="true" tabindex="-1"></a>  same_as<span class="op">&lt;</span>ranges<span class="op">::</span>range_value_t<span class="op">&lt;</span>R<span class="op">&gt;</span>, info<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
-<span id="cb207-5"><a href="#cb207-5" aria-hidden="true" tabindex="-1"></a>  same_as<span class="op">&lt;</span>remove_cvref_t<span class="op">&lt;</span>ranges<span class="op">::</span>range_reference_t<span class="op">&lt;</span>R<span class="op">&gt;&gt;</span>, info<span class="op">&gt;</span>;</span></code></pre></div>
-<div class="sourceCode" id="cb208"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb208-1"><a href="#cb208-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb208-2"><a href="#cb208-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> can_substitute<span class="op">(</span>info templ, R<span class="op">&amp;&amp;</span> arguments<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_381" id="pnum_381">1</a></span>
+<div class="sourceCode" id="cb213"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb213-1"><a href="#cb213-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> R<span class="op">&gt;</span></span>
+<span id="cb213-2"><a href="#cb213-2" aria-hidden="true" tabindex="-1"></a><span class="kw">concept</span> reflection_range <span class="op">=</span></span>
+<span id="cb213-3"><a href="#cb213-3" aria-hidden="true" tabindex="-1"></a>  ranges<span class="op">::</span>input_range<span class="op">&lt;</span>R<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
+<span id="cb213-4"><a href="#cb213-4" aria-hidden="true" tabindex="-1"></a>  same_as<span class="op">&lt;</span>ranges<span class="op">::</span>range_value_t<span class="op">&lt;</span>R<span class="op">&gt;</span>, info<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
+<span id="cb213-5"><a href="#cb213-5" aria-hidden="true" tabindex="-1"></a>  same_as<span class="op">&lt;</span>remove_cvref_t<span class="op">&lt;</span>ranges<span class="op">::</span>range_reference_t<span class="op">&lt;</span>R<span class="op">&gt;&gt;</span>, info<span class="op">&gt;</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb214"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb214-1"><a href="#cb214-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb214-2"><a href="#cb214-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> can_substitute<span class="op">(</span>info templ, R<span class="op">&amp;&amp;</span> arguments<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_426" id="pnum_426">1</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">templ</code>
 represents a template and every reflection in
 <code class="sourceCode cpp">arguments</code> represents a construct
 usable as a template argument ([temp.arg]).</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_382" id="pnum_382">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_427" id="pnum_427">2</a></span>
 Let <code class="sourceCode cpp">Z</code> be the template represented by
 <code class="sourceCode cpp">templ</code> and let
 <code class="sourceCode cpp">Args<span class="op">...</span></code> be
 the sequence of entities, variables, or
 <code class="sourceCode cpp"><em>typedef-name</em></code>s represented
 by the elements of <code class="sourceCode cpp">arguments</code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_383" id="pnum_383">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_428" id="pnum_428">3</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">Z<span class="op">&lt;</span>Args<span class="op">...&gt;</span></code>
 is a valid <em>template-id</em> ([temp.names]). Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_384" id="pnum_384">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_429" id="pnum_429">4</a></span>
 <em>Remarks</em>: If attempting to substitute leads to a failure outside
 of the immediate context, the program is ill-formed.</p>
-<div class="sourceCode" id="cb209"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb209-1"><a href="#cb209-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb209-2"><a href="#cb209-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info substitute<span class="op">(</span>info templ, R<span class="op">&amp;&amp;</span> arguments<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_385" id="pnum_385">5</a></span>
+<div class="sourceCode" id="cb215"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb215-1"><a href="#cb215-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb215-2"><a href="#cb215-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info substitute<span class="op">(</span>info templ, R<span class="op">&amp;&amp;</span> arguments<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_430" id="pnum_430">5</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">can_substitute<span class="op">(</span>templ, arguments<span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_386" id="pnum_386">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_431" id="pnum_431">6</a></span>
 Let <code class="sourceCode cpp">Z</code> be the template represented by
 <code class="sourceCode cpp">templ</code> and let
 <code class="sourceCode cpp">Args<span class="op">...</span></code> be
 the sequence of entities, variables, or
 <code class="sourceCode cpp"><em>typedef-name</em></code>s represented
 by the elements of <code class="sourceCode cpp">arguments</code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_387" id="pnum_387">7</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_432" id="pnum_432">7</a></span>
 <em>Returns</em>: <code class="sourceCode cpp"><span class="op">^^</span>Z<span class="op">&lt;</span>Args<span class="op">...&gt;</span></code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_388" id="pnum_388">8</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_433" id="pnum_433">8</a></span>
 <span class="note"><span>[ <em>Note 1:</em> </span><code class="sourceCode cpp">Z<span class="op">&lt;</span>Args<span class="op">..&gt;</span></code>
 is not instantiated.<span> — <em>end note</em> ]</span></span></p>
 </div>
@@ -9517,72 +10224,72 @@ <h3 class="unnumbered" id="meta.reflection.result-expression-result-reflection">
 <div class="std">
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb210"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb210-1"><a href="#cb210-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
-<span id="cb210-2"><a href="#cb210-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> info reflect_value<span class="op">(</span><span class="kw">const</span> T<span class="op">&amp;</span> expr<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_389" id="pnum_389">1</a></span>
+<div class="sourceCode" id="cb216"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb216-1"><a href="#cb216-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb216-2"><a href="#cb216-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> info reflect_value<span class="op">(</span><span class="kw">const</span> T<span class="op">&amp;</span> expr<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_434" id="pnum_434">1</a></span>
 <em>Mandates</em>: <code class="sourceCode cpp">T</code> is a structural
 type that is neither a reference type nor an array type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_390" id="pnum_390">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_435" id="pnum_435">2</a></span>
 <em>Constant When</em>: Any value computed by
 <code class="sourceCode cpp">expr</code> having pointer type, or every
 subobject of the value computed by
 <code class="sourceCode cpp">expr</code> having pointer or reference
 type, is the address of or refers to an object or entity that</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_391" id="pnum_391">(2.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_436" id="pnum_436">(2.1)</a></span>
 is a permitted result of a constant expression ([expr.const]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_392" id="pnum_392">(2.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_437" id="pnum_437">(2.2)</a></span>
 is not a temporary object ([class.temporary]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_393" id="pnum_393">(2.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_438" id="pnum_438">(2.3)</a></span>
 is not a string literal object ([lex.string]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_394" id="pnum_394">(2.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_439" id="pnum_439">(2.4)</a></span>
 is not the result of a
 <code class="sourceCode cpp"><span class="kw">typeid</span></code>
 expression ([expr.typeid]), and</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_395" id="pnum_395">(2.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_440" id="pnum_440">(2.5)</a></span>
 is not an object associated with a predefined
 <code class="sourceCode cpp"><span class="ot">__func__</span></code>
 variable ([dcl.fct.def.general]).</li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_396" id="pnum_396">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_441" id="pnum_441">3</a></span>
 <em>Returns</em>: A reflection of the value computed by an
 lvalue-to-rvalue conversion applied to
 <code class="sourceCode cpp">expr</code>. The type of the represented
 value is the cv-unqualified version of
 <code class="sourceCode cpp">T</code>.</p>
-<div class="sourceCode" id="cb211"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb211-1"><a href="#cb211-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
-<span id="cb211-2"><a href="#cb211-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> info reflect_object<span class="op">(</span>T<span class="op">&amp;</span> expr<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_397" id="pnum_397">4</a></span>
+<div class="sourceCode" id="cb217"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb217-1"><a href="#cb217-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb217-2"><a href="#cb217-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> info reflect_object<span class="op">(</span>T<span class="op">&amp;</span> expr<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_442" id="pnum_442">4</a></span>
 <em>Mandates</em>: <code class="sourceCode cpp">T</code> is not a
 function type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_398" id="pnum_398">5</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_443" id="pnum_443">5</a></span>
 <em>Constant When</em>: <code class="sourceCode cpp">expr</code>
 designates an object or entity that</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_399" id="pnum_399">(5.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_444" id="pnum_444">(5.1)</a></span>
 is a permitted result of a constant expression ([expr.const]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_400" id="pnum_400">(5.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_445" id="pnum_445">(5.2)</a></span>
 is not a temporary object ([class.temporary]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_401" id="pnum_401">(5.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_446" id="pnum_446">(5.3)</a></span>
 is not a string literal object ([lex.string]),</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_402" id="pnum_402">(5.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_447" id="pnum_447">(5.4)</a></span>
 is not the result of a
 <code class="sourceCode cpp"><span class="kw">typeid</span></code>
 expression ([expr.typeid]), and</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_403" id="pnum_403">(5.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_448" id="pnum_448">(5.5)</a></span>
 is not an object associated with a predefined
 <code class="sourceCode cpp"><span class="ot">__func__</span></code>
 variable ([dcl.fct.def.general]).</li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_404" id="pnum_404">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_449" id="pnum_449">6</a></span>
 <em>Returns</em>: A reflection of the object designated by
 <code class="sourceCode cpp">expr</code>.</p>
-<div class="sourceCode" id="cb212"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb212-1"><a href="#cb212-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
-<span id="cb212-2"><a href="#cb212-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> info reflect_function<span class="op">(</span>T<span class="op">&amp;</span> expr<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_405" id="pnum_405">7</a></span>
+<div class="sourceCode" id="cb218"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb218-1"><a href="#cb218-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb218-2"><a href="#cb218-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> info reflect_function<span class="op">(</span>T<span class="op">&amp;</span> expr<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_450" id="pnum_450">7</a></span>
 <em>Mandates</em>: <code class="sourceCode cpp">T</code> is a function
 type.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_406" id="pnum_406">8</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_451" id="pnum_451">8</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="op">^^</span>fn</code>, where
 <code class="sourceCode cpp">fn</code> is the function designated by
@@ -9595,19 +10302,19 @@ <h3 class="unnumbered" id="meta.reflection.define.aggregate-reflection-class-def
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_407" id="pnum_407">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_452" id="pnum_452">1</a></span>
 The classes <code class="sourceCode cpp">data_member_options</code> and
 <code class="sourceCode cpp">name_type</code> are consteval-only types
 ([basic.types.general]), and are not a structural types
 ([temp.param]).</p>
-<div class="sourceCode" id="cb213"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb213-1"><a href="#cb213-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">requires</span> constructible_from<span class="op">&lt;</span>u8string, T<span class="op">&gt;</span></span>
-<span id="cb213-2"><a href="#cb213-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> data_member_options<span class="op">::</span>name_type<span class="op">(</span>T<span class="op">&amp;&amp;</span> value<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_408" id="pnum_408">2</a></span>
+<div class="sourceCode" id="cb219"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb219-1"><a href="#cb219-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">requires</span> constructible_from<span class="op">&lt;</span>u8string, T<span class="op">&gt;</span></span>
+<span id="cb219-2"><a href="#cb219-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> data_member_options<span class="op">::</span>name_type<span class="op">(</span>T<span class="op">&amp;&amp;</span> value<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_453" id="pnum_453">2</a></span>
 <em>Effects</em>: Initializes
 <code class="sourceCode cpp"><em>contents</em></code> with <code class="sourceCode cpp">u8string<span class="op">(</span>value<span class="op">)</span></code>.</p>
-<div class="sourceCode" id="cb214"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb214-1"><a href="#cb214-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">requires</span> constructible_from<span class="op">&lt;</span>string, T<span class="op">&gt;</span></span>
-<span id="cb214-2"><a href="#cb214-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> data_member_options<span class="op">::</span>name_type<span class="op">(</span>T<span class="op">&amp;&amp;</span> value<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_409" id="pnum_409">3</a></span>
+<div class="sourceCode" id="cb220"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb220-1"><a href="#cb220-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">requires</span> constructible_from<span class="op">&lt;</span>string, T<span class="op">&gt;</span></span>
+<span id="cb220-2"><a href="#cb220-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> data_member_options<span class="op">::</span>name_type<span class="op">(</span>T<span class="op">&amp;&amp;</span> value<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_454" id="pnum_454">3</a></span>
 <em>Effects</em>: Initializes
 <code class="sourceCode cpp"><em>contents</em></code> with <code class="sourceCode cpp">string<span class="op">(</span>value<span class="op">)</span></code>.</p>
 <div class="note">
@@ -9622,77 +10329,77 @@ <h3 class="unnumbered" id="meta.reflection.define.aggregate-reflection-class-def
 <code class="sourceCode cpp">string</code>, etc) or a UTF-8 string
 literal (or <code class="sourceCode cpp">u8string_view</code>,
 <code class="sourceCode cpp">u8string</code>, etc) equally well.</p>
-<div class="sourceCode" id="cb215"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb215-1"><a href="#cb215-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> mem1 <span class="op">=</span> data_member_spec<span class="op">(^^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">&quot;ordinary_literal_encoding&quot;</span><span class="op">})</span>;</span>
-<span id="cb215-2"><a href="#cb215-2" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> mem2 <span class="op">=</span> data_member_spec<span class="op">(^^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">u8&quot;utf8_encoding&quot;</span><span class="op">})</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb221"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb221-1"><a href="#cb221-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> mem1 <span class="op">=</span> data_member_spec<span class="op">(^^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">&quot;ordinary_literal_encoding&quot;</span><span class="op">})</span>;</span>
+<span id="cb221-2"><a href="#cb221-2" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> mem2 <span class="op">=</span> data_member_spec<span class="op">(^^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">u8&quot;utf8_encoding&quot;</span><span class="op">})</span>;</span></code></pre></div>
 <span> — <em>end note</em> ]</span>
 </div>
-<div class="sourceCode" id="cb216"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb216-1"><a href="#cb216-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info data_member_spec<span class="op">(</span>info type,</span>
-<span id="cb216-2"><a href="#cb216-2" aria-hidden="true" tabindex="-1"></a>                                data_member_options options <span class="op">=</span> <span class="op">{})</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_410" id="pnum_410">1</a></span>
+<div class="sourceCode" id="cb222"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb222-1"><a href="#cb222-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info data_member_spec<span class="op">(</span>info type,</span>
+<span id="cb222-2"><a href="#cb222-2" aria-hidden="true" tabindex="-1"></a>                                data_member_options options <span class="op">=</span> <span class="op">{})</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_455" id="pnum_455">1</a></span>
 <em>Constant When</em>:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_411" id="pnum_411">(1.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_456" id="pnum_456">(1.1)</a></span>
 <code class="sourceCode cpp">type</code> represents either a type
 <code class="sourceCode cpp">cv <em>T</em></code>, or a
 <code class="sourceCode cpp"><em>typedef-name</em></code> designating a
 type <code class="sourceCode cpp">cv <em>T</em></code>, where
 <code class="sourceCode cpp"><em>T</em></code> is either an object type
 or a reference type;</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_412" id="pnum_412">(1.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_457" id="pnum_457">(1.2)</a></span>
 if
 <code class="sourceCode cpp">options<span class="op">.</span>name</code>
 contains a value, then:
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_413" id="pnum_413">(1.2.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_458" id="pnum_458">(1.2.1)</a></span>
 <code class="sourceCode cpp">holds_alternative<span class="op">&lt;</span>u8string<span class="op">&gt;(</span>options<span class="op">.</span>name<span class="op">-&gt;</span><em>contents</em><span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code> and
 <code class="sourceCode cpp">get<span class="op">&lt;</span>u8string<span class="op">&gt;(</span>options<span class="op">.</span>name<span class="op">-&gt;</span><em>contents</em><span class="op">)</span></code>
 contains a valid identifier when interpreted with UTF-8, or</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_414" id="pnum_414">(1.2.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_459" id="pnum_459">(1.2.2)</a></span>
 <code class="sourceCode cpp">holds_alternative<span class="op">&lt;</span>string<span class="op">&gt;(</span>options<span class="op">.</span>name<span class="op">-&gt;</span><em>contents</em><span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code> and
 <code class="sourceCode cpp">get<span class="op">&lt;</span>string<span class="op">&gt;(</span>options<span class="op">.</span>name<span class="op">-&gt;</span><em>contents</em><span class="op">)</span></code>
 contains a valid identifier when interpreted with the ordinary literal
 encoding;</li>
 </ul></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_415" id="pnum_415">(1.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_460" id="pnum_460">(1.3)</a></span>
 if
 <code class="sourceCode cpp">options<span class="op">.</span>name</code>
 does not contain a value, then <code class="sourceCode cpp">options<span class="op">.</span>bit_field</code>
 contains a value;</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_416" id="pnum_416">(1.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_461" id="pnum_461">(1.4)</a></span>
 if <code class="sourceCode cpp">options<span class="op">.</span>alignment</code>
 contains a value, it is an alignment value ([basic.align]) not less than
 the alignment requirement of
 <code class="sourceCode cpp"><em>T</em></code>; and</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_417" id="pnum_417">(1.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_462" id="pnum_462">(1.5)</a></span>
 if <code class="sourceCode cpp">options<span class="op">.</span>bit_width</code>
 contains a value <code class="sourceCode cpp"><em>V</em></code>, then
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_418" id="pnum_418">(1.5.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_463" id="pnum_463">(1.5.1)</a></span>
 <code class="sourceCode cpp"><em>T</em></code> represents an integral or
 enumeration type,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_419" id="pnum_419">(1.5.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_464" id="pnum_464">(1.5.2)</a></span>
 <code class="sourceCode cpp">options<span class="op">.</span>alignment</code>
 does not contain a value,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_420" id="pnum_420">(1.5.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_465" id="pnum_465">(1.5.3)</a></span>
 <code class="sourceCode cpp">options<span class="op">.</span>no_unique_address</code>
 is <code class="sourceCode cpp"><span class="kw">false</span></code>,
 and</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_421" id="pnum_421">(1.5.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_466" id="pnum_466">(1.5.4)</a></span>
 if <code class="sourceCode cpp"><em>V</em> <span class="op">==</span> <span class="dv">0</span></code>
 then
 <code class="sourceCode cpp">options<span class="op">.</span>name</code>
 does not contain a value.</li>
 </ul></li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_422" id="pnum_422">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_467" id="pnum_467">2</a></span>
 <em>Returns</em>: A reflection of a description of a declaration of a
 non-static data member declared with the type or <code class="sourceCode cpp"><span class="kw">typedef</span><span class="op">-</span>name</code>
 represented by <code class="sourceCode cpp">type</code>, and having the
 optional characteristics designated by
 <code class="sourceCode cpp">options</code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_423" id="pnum_423">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_468" id="pnum_468">3</a></span>
 <em>Remarks</em>: The returned reflection value is primarily useful in
 conjunction with <code class="sourceCode cpp">define_aggregate</code>.
 Certain other functions in
@@ -9701,16 +10408,16 @@ <h3 class="unnumbered" id="meta.reflection.define.aggregate-reflection-class-def
 <code class="sourceCode cpp">identifier_of</code>) can also be used to
 query the characteristics indicated by the arguments provided to
 <code class="sourceCode cpp">data_member_spec</code>.</p>
-<div class="sourceCode" id="cb217"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb217-1"><a href="#cb217-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_data_member_spec<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_424" id="pnum_424">4</a></span>
+<div class="sourceCode" id="cb223"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb223-1"><a href="#cb223-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_data_member_spec<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_469" id="pnum_469">4</a></span>
 <em>Returns</em>:
 <code class="sourceCode cpp"><span class="kw">true</span></code> if
 <code class="sourceCode cpp">r</code> represents a description of a
 declaration of a non-static data member. Otherwise,
 <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb218"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb218-1"><a href="#cb218-1" aria-hidden="true" tabindex="-1"></a>  <span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb218-2"><a href="#cb218-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> info define_aggregate<span class="op">(</span>info class_type, R<span class="op">&amp;&amp;</span> mdescrs<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_425" id="pnum_425">5</a></span>
+<div class="sourceCode" id="cb224"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb224-1"><a href="#cb224-1" aria-hidden="true" tabindex="-1"></a>  <span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb224-2"><a href="#cb224-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">consteval</span> info define_aggregate<span class="op">(</span>info class_type, R<span class="op">&amp;&amp;</span> mdescrs<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_470" id="pnum_470">5</a></span>
 <em>Constant When</em>: Letting
 <code class="sourceCode cpp"><em>C</em></code> be the class represented
 by <code class="sourceCode cpp">class_type</code> and
@@ -9718,7 +10425,7 @@ <h3 class="unnumbered" id="meta.reflection.define.aggregate-reflection-class-def
 <code class="sourceCode cpp"><em>K</em></code><sup>th</sup> reflection
 value in <code class="sourceCode cpp">mdescrs</code>,</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_426" id="pnum_426">(5.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_471" id="pnum_471">(5.1)</a></span>
 If <code class="sourceCode cpp"><em>C</em></code> is a complete type
 from some point in the evaluation context, then
 <ul>
@@ -9735,18 +10442,18 @@ <h3 class="unnumbered" id="meta.reflection.define.aggregate-reflection-class-def
 <code class="sourceCode cpp"><em>K</em></code><sup>th</sup> data member
 of <code class="sourceCode cpp"><em>C</em></code>.</li>
 </ul></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_427" id="pnum_427">(5.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_472" id="pnum_472">(5.2)</a></span>
 <code class="sourceCode cpp">is_data_member_spec<span class="op">(</span><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub><span class="op">)</span></code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code> for
 every
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub></code> in
 <code class="sourceCode cpp">mdescrs</code>,</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_428" id="pnum_428">(5.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_473" id="pnum_473">(5.3)</a></span>
 the type represented by <code class="sourceCode cpp">type_of<span class="op">(</span><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub><span class="op">)</span></code>
 is a complete type for every
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub></code> in
 <code class="sourceCode cpp">mdescrs</code>, and</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_429" id="pnum_429">(5.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_474" id="pnum_474">(5.4)</a></span>
 for every pair 0 ≤ <code class="sourceCode cpp"><em>K</em></code> &lt;
 <code class="sourceCode cpp"><em>L</em></code> &lt; <code class="sourceCode cpp">mdescrs<span class="op">.</span>size<span class="op">()</span></code>,
 if <code class="sourceCode cpp">has_identifier<span class="op">(</span><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub><span class="op">)</span> <span class="op">&amp;&amp;</span> has_identifier<span class="op">(</span><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>L</em></span></sub><span class="op">)</span></code>,
@@ -9760,37 +10467,37 @@ <h3 class="unnumbered" id="meta.reflection.define.aggregate-reflection-class-def
 </span><code class="sourceCode cpp"><em>C</em></code> could be a class
 template specialization for which there is no reachable
 definition.<span> — <em>end note</em> ]</span></span></p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_430" id="pnum_430">6</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_475" id="pnum_475">6</a></span>
 Let
 {<code class="sourceCode cpp"><span class="math inline"><em>t</em></span><sub>k</sub></code>}
 be a sequence of reflections and
 {<code class="sourceCode cpp"><span class="math inline"><em>o</em></span><sub>k</sub></code>}
 be a sequence of <code class="sourceCode cpp">data_member_options</code>
 values such that</p>
-<div class="sourceCode" id="cb219"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb219-1"><a href="#cb219-1" aria-hidden="true" tabindex="-1"></a>data_member_spec(<span class="math inline"><em>t</em></span><sub><span class="math inline"><em>k</em></span></sub>, <span class="math inline"><em>o</em></span><sub><span class="math inline"><em>k</em></span></sub>) == <span class="math inline"><em>r</em></span><sub><span class="math inline"><em>k</em></span></sub></span></code></pre></div>
+<div class="sourceCode" id="cb225"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb225-1"><a href="#cb225-1" aria-hidden="true" tabindex="-1"></a>data_member_spec(<span class="math inline"><em>t</em></span><sub><span class="math inline"><em>k</em></span></sub>, <span class="math inline"><em>o</em></span><sub><span class="math inline"><em>k</em></span></sub>) == <span class="math inline"><em>r</em></span><sub><span class="math inline"><em>k</em></span></sub></span></code></pre></div>
 <p>for every
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>k</em></span></sub></code> in
 <code class="sourceCode cpp">mdescrs</code>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_431" id="pnum_431">7</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_476" id="pnum_476">7</a></span>
 <em>Effects</em>: Produces an injected declaration
 <code class="sourceCode cpp"><em>D</em></code> ([expr.const]) that
 provides a definition for <code class="sourceCode cpp"><em>C</em></code>
 with properties as follows:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_432" id="pnum_432">(7.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_477" id="pnum_477">(7.1)</a></span>
 The target scope of <code class="sourceCode cpp"><em>D</em></code> is
 the scope to which <code class="sourceCode cpp"><em>C</em></code>
 belongs ([basic.scope.scope]).</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_433" id="pnum_433">(7.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_478" id="pnum_478">(7.2)</a></span>
 The locus of <code class="sourceCode cpp"><em>D</em></code> follows
 immediately after the manifestly constant-evaluated expression currently
 under evaluation.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_434" id="pnum_434">(7.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_479" id="pnum_479">(7.3)</a></span>
 If <code class="sourceCode cpp"><em>C</em></code> is a specialization of
 a class template <code class="sourceCode cpp"><em>T</em></code>, then
 <code class="sourceCode cpp"><em>D</em></code> is is an explicit
 specialization of <code class="sourceCode cpp"><em>T</em></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_435" id="pnum_435">(7.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_480" id="pnum_480">(7.4)</a></span>
 <code class="sourceCode cpp"><em>D</em></code> contains a public
 non-static data member or unnamed bit-field corresponding to each
 reflection value
@@ -9803,29 +10510,29 @@ <h3 class="unnumbered" id="meta.reflection.define.aggregate-reflection-class-def
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub></code> precedes the
 declaration of
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>L</em></span></sub></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_436" id="pnum_436">(7.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_481" id="pnum_481">(7.5)</a></span>
 A non-static data member or unnamed bit-field corresponding to each
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub></code> is declared with the
 type or <code class="sourceCode cpp"><em>typedef-name</em></code>
 represented by
 <code class="sourceCode cpp"><span class="math inline"><em>t</em></span><sub><span class="math inline"><em>K</em></span></sub></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_437" id="pnum_437">(7.6)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_482" id="pnum_482">(7.6)</a></span>
 A non-static data member corresponding to a reflection
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub></code> for which <code class="sourceCode cpp"><span class="math inline"><em>o</em></span><sub><span class="math inline"><em>K</em></span></sub><span class="op">.</span>no_unique_address</code>
 is <code class="sourceCode cpp"><span class="kw">true</span></code> is
 declared with the attribute <code class="sourceCode cpp"><span class="op">[[</span><span class="at">no_unique_address</span><span class="op">]]</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_438" id="pnum_438">(7.7)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_483" id="pnum_483">(7.7)</a></span>
 A non-static data member or unnamed bit-field corresponding to a
 reflection
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub></code> for which <code class="sourceCode cpp"><span class="math inline"><em>o</em></span><sub><span class="math inline"><em>K</em></span></sub><span class="op">.</span>bit_width</code>
 contains a value is declared as a bit-field whose width is that
 value.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_439" id="pnum_439">(7.8)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_484" id="pnum_484">(7.8)</a></span>
 A non-static data member corresponding to a reflection
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub></code> for which <code class="sourceCode cpp"><span class="math inline"><em>o</em></span><sub><span class="math inline"><em>K</em></span></sub><span class="op">.</span>alignment</code>
 contains a value is declared with the
 <code class="sourceCode cpp"><em>alignment-specifier</em></code> <code class="sourceCode cpp"><span class="kw">alignas</span><span class="op">(</span><span class="math inline"><em>o</em></span><sub><span class="math inline"><em>K</em></span></sub><span class="op">.</span>alignment<span class="op">)</span></code>.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_440" id="pnum_440">(7.9)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_485" id="pnum_485">(7.9)</a></span>
 A non-static data member or unnamed bit-field corresponding to a
 reflection
 <code class="sourceCode cpp"><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub></code> is declared with a
@@ -9837,18 +10544,18 @@ <h3 class="unnumbered" id="meta.reflection.define.aggregate-reflection-class-def
 determined by the character sequence encoded by <code class="sourceCode cpp">u8identifier_of<span class="op">(</span><span class="math inline"><em>r</em></span><sub><span class="math inline"><em>K</em></span></sub><span class="op">)</span></code>
 in UTF-8.</li>
 </ul></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_441" id="pnum_441">(7.10)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_486" id="pnum_486">(7.10)</a></span>
 If <code class="sourceCode cpp"><em>C</em></code> is a union type for
 which any of its members are not trivially default constructible, then
 <code class="sourceCode cpp"><em>D</em></code> has a user-provided
 default constructor which has no effect.</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_442" id="pnum_442">(7.11)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_487" id="pnum_487">(7.11)</a></span>
 If <code class="sourceCode cpp"><em>C</em></code> is a union type for
 which any of its members are not trivially destructible, then
 <code class="sourceCode cpp"><em>D</em></code> has a user-provided
 destructor which has no effect.</li>
 </ul>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_443" id="pnum_443">8</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_488" id="pnum_488">8</a></span>
 <em>Returns</em>: <code class="sourceCode cpp">class_type</code>.</p>
 </div>
 </blockquote>
@@ -9858,10 +10565,10 @@ <h3 class="unnumbered" id="meta.reflection.unary-unary-type-traits">[meta.reflec
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_444" id="pnum_444">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_489" id="pnum_489">1</a></span>
 Subclause [meta.reflection.unary] contains consteval functions that may
 be used to query the properties of a type at compile time.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_445" id="pnum_445">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_490" id="pnum_490">2</a></span>
 For each function taking an argument of type
 <code class="sourceCode cpp">meta<span class="op">::</span>info</code>
 whose name contains <code class="sourceCode cpp">type</code>, a call to
@@ -9882,44 +10589,44 @@ <h4 class="unnumbered" id="meta.reflection.unary.cat-primary-type-categories">[m
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_446" id="pnum_446">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_491" id="pnum_491">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>TRAIT</em>_type</code>
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>TRAIT</em>_type<span class="op">(^^</span>T<span class="op">)</span></code>
 equals the value of the corresponding unary type trait <code class="sourceCode cpp">std<span class="op">::</span><em>TRAIT</em>_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.5.2 <a href="https://wg21.link/meta.unary.cat">[meta.unary.cat]</a></span>.</p>
-<div class="sourceCode" id="cb220"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb220-1"><a href="#cb220-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_void_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-2"><a href="#cb220-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_null_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-3"><a href="#cb220-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_integral_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-4"><a href="#cb220-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_floating_point_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-5"><a href="#cb220-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_array_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-6"><a href="#cb220-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-7"><a href="#cb220-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_lvalue_reference_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-8"><a href="#cb220-8" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_rvalue_reference_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-9"><a href="#cb220-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_object_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-10"><a href="#cb220-10" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_function_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-11"><a href="#cb220-11" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_enum_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-12"><a href="#cb220-12" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_union_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-13"><a href="#cb220-13" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-14"><a href="#cb220-14" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb220-15"><a href="#cb220-15" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_reflection_type<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_447" id="pnum_447">2</a></span></p>
+<div class="sourceCode" id="cb226"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb226-1"><a href="#cb226-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_void_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-2"><a href="#cb226-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_null_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-3"><a href="#cb226-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_integral_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-4"><a href="#cb226-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_floating_point_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-5"><a href="#cb226-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_array_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-6"><a href="#cb226-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-7"><a href="#cb226-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_lvalue_reference_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-8"><a href="#cb226-8" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_rvalue_reference_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-9"><a href="#cb226-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_object_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-10"><a href="#cb226-10" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_function_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-11"><a href="#cb226-11" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_enum_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-12"><a href="#cb226-12" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_union_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-13"><a href="#cb226-13" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-14"><a href="#cb226-14" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb226-15"><a href="#cb226-15" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_reflection_type<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_492" id="pnum_492">2</a></span></p>
 <div class="example">
 <span>[ <em>Example 1:</em> </span>
-<div class="sourceCode" id="cb221"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb221-1"><a href="#cb221-1" aria-hidden="true" tabindex="-1"></a>namespace std::meta {</span>
-<span id="cb221-2"><a href="#cb221-2" aria-hidden="true" tabindex="-1"></a>  consteval bool is_void_type(info type) {</span>
-<span id="cb221-3"><a href="#cb221-3" aria-hidden="true" tabindex="-1"></a>    // one example implementation</span>
-<span id="cb221-4"><a href="#cb221-4" aria-hidden="true" tabindex="-1"></a>    return extract&lt;bool&gt;(substitute(^^is_void_v, {type}));</span>
-<span id="cb221-5"><a href="#cb221-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-6"><a href="#cb221-6" aria-hidden="true" tabindex="-1"></a>    // another example implementation</span>
-<span id="cb221-7"><a href="#cb221-7" aria-hidden="true" tabindex="-1"></a>    type = dealias(type);</span>
-<span id="cb221-8"><a href="#cb221-8" aria-hidden="true" tabindex="-1"></a>    return type == ^^void</span>
-<span id="cb221-9"><a href="#cb221-9" aria-hidden="true" tabindex="-1"></a>        || type == ^^const void</span>
-<span id="cb221-10"><a href="#cb221-10" aria-hidden="true" tabindex="-1"></a>        || type == ^^volatile void</span>
-<span id="cb221-11"><a href="#cb221-11" aria-hidden="true" tabindex="-1"></a>        || type == ^^const volatile void;</span>
-<span id="cb221-12"><a href="#cb221-12" aria-hidden="true" tabindex="-1"></a>  }</span>
-<span id="cb221-13"><a href="#cb221-13" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
+<div class="sourceCode" id="cb227"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb227-1"><a href="#cb227-1" aria-hidden="true" tabindex="-1"></a>namespace std::meta {</span>
+<span id="cb227-2"><a href="#cb227-2" aria-hidden="true" tabindex="-1"></a>  consteval bool is_void_type(info type) {</span>
+<span id="cb227-3"><a href="#cb227-3" aria-hidden="true" tabindex="-1"></a>    // one example implementation</span>
+<span id="cb227-4"><a href="#cb227-4" aria-hidden="true" tabindex="-1"></a>    return extract&lt;bool&gt;(substitute(^^is_void_v, {type}));</span>
+<span id="cb227-5"><a href="#cb227-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-6"><a href="#cb227-6" aria-hidden="true" tabindex="-1"></a>    // another example implementation</span>
+<span id="cb227-7"><a href="#cb227-7" aria-hidden="true" tabindex="-1"></a>    type = dealias(type);</span>
+<span id="cb227-8"><a href="#cb227-8" aria-hidden="true" tabindex="-1"></a>    return type == ^^void</span>
+<span id="cb227-9"><a href="#cb227-9" aria-hidden="true" tabindex="-1"></a>        || type == ^^const void</span>
+<span id="cb227-10"><a href="#cb227-10" aria-hidden="true" tabindex="-1"></a>        || type == ^^volatile void</span>
+<span id="cb227-11"><a href="#cb227-11" aria-hidden="true" tabindex="-1"></a>        || type == ^^const volatile void;</span>
+<span id="cb227-12"><a href="#cb227-12" aria-hidden="true" tabindex="-1"></a>  }</span>
+<span id="cb227-13"><a href="#cb227-13" aria-hidden="true" tabindex="-1"></a>}</span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
 </div>
@@ -9930,20 +10637,20 @@ <h4 class="unnumbered" id="meta.reflection.unary.comp-composite-type-categories"
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_448" id="pnum_448">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_493" id="pnum_493">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>TRAIT</em>_type</code>
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>TRAIT</em>_type<span class="op">(^^</span>T<span class="op">)</span></code>
 equals the value of the corresponding unary type trait <code class="sourceCode cpp">std<span class="op">::</span><em>TRAIT</em>_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.5.3 <a href="https://wg21.link/meta.unary.comp">[meta.unary.comp]</a></span>.</p>
-<div class="sourceCode" id="cb222"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb222-1"><a href="#cb222-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_reference_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb222-2"><a href="#cb222-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_arithmetic_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb222-3"><a href="#cb222-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_fundamental_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb222-4"><a href="#cb222-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_object_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb222-5"><a href="#cb222-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_scalar_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb222-6"><a href="#cb222-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_compound_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb222-7"><a href="#cb222-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb228"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb228-1"><a href="#cb228-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_reference_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb228-2"><a href="#cb228-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_arithmetic_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb228-3"><a href="#cb228-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_fundamental_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb228-4"><a href="#cb228-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_object_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb228-5"><a href="#cb228-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_scalar_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb228-6"><a href="#cb228-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_compound_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb228-7"><a href="#cb228-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_pointer_type<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -9952,7 +10659,7 @@ <h4 class="unnumbered" id="meta.reflection.unary.prop-type-properties">[meta.ref
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_449" id="pnum_449">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_494" id="pnum_494">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>UNARY-TRAIT</em>_type</code>
@@ -9962,7 +10669,7 @@ <h4 class="unnumbered" id="meta.reflection.unary.prop-type-properties">[meta.ref
 or <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>UNARY-TRAIT</em><span class="op">(^^</span>T<span class="op">)</span></code>
 equals the value of the corresponding type property <code class="sourceCode cpp">std<span class="op">::</span><em>UNARY-TRAIT</em>_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.5.4 <a href="https://wg21.link/meta.unary.prop">[meta.unary.prop]</a></span>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_450" id="pnum_450">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_495" id="pnum_495">2</a></span>
 For any types or
 <code class="sourceCode cpp"><em>typedef-names</em></code>
 <code class="sourceCode cpp">T</code> and
@@ -9973,7 +10680,7 @@ <h4 class="unnumbered" id="meta.reflection.unary.prop-type-properties">[meta.ref
 or <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>BINARY-TRAIT</em><span class="op">(^^</span>T, <span class="op">^^</span>U<span class="op">)</span></code>
 equals the value of the corresponding type property <code class="sourceCode cpp">std<span class="op">::</span><em>BINARY-TRAIT</em>_v<span class="op">&lt;</span>T, U<span class="op">&gt;</span></code>
 as specified in <span>21.3.5.4 <a href="https://wg21.link/meta.unary.prop">[meta.unary.prop]</a></span>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_451" id="pnum_451">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_496" id="pnum_496">3</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, pack of types or
@@ -9985,71 +10692,71 @@ <h4 class="unnumbered" id="meta.reflection.unary.prop-type-properties">[meta.ref
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-TRAIT</em>_type<span class="op">(^^</span>T, r<span class="op">)</span></code>
 equals the value of the corresponding type property <code class="sourceCode cpp">std<span class="op">::</span><em>VARIADIC-TRAIT</em>_v<span class="op">&lt;</span>T, U<span class="op">...&gt;</span></code>
 as specified in <span>21.3.5.4 <a href="https://wg21.link/meta.unary.prop">[meta.unary.prop]</a></span>.</p>
-<div class="sourceCode" id="cb223"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb223-1"><a href="#cb223-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_const_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-2"><a href="#cb223-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_volatile_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-3"><a href="#cb223-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivial_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-4"><a href="#cb223-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copyable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-5"><a href="#cb223-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_standard_layout_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-6"><a href="#cb223-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_empty_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-7"><a href="#cb223-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_polymorphic_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-8"><a href="#cb223-8" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_abstract_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-9"><a href="#cb223-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_final_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-10"><a href="#cb223-10" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_aggregate_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-11"><a href="#cb223-11" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_signed_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-12"><a href="#cb223-12" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_unsigned_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-13"><a href="#cb223-13" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_bounded_array_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-14"><a href="#cb223-14" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_unbounded_array_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-15"><a href="#cb223-15" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_scoped_enum_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-16"><a href="#cb223-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-17"><a href="#cb223-17" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb223-18"><a href="#cb223-18" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructible_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb223-19"><a href="#cb223-19" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_default_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-20"><a href="#cb223-20" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-21"><a href="#cb223-21" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-22"><a href="#cb223-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-23"><a href="#cb223-23" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_assignable_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
-<span id="cb223-24"><a href="#cb223-24" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-25"><a href="#cb223-25" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-26"><a href="#cb223-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-27"><a href="#cb223-27" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_swappable_with_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
-<span id="cb223-28"><a href="#cb223-28" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_swappable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-29"><a href="#cb223-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-30"><a href="#cb223-30" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_destructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-31"><a href="#cb223-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-32"><a href="#cb223-32" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb223-33"><a href="#cb223-33" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_constructible_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb223-34"><a href="#cb223-34" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_default_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-35"><a href="#cb223-35" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copy_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-36"><a href="#cb223-36" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_move_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-37"><a href="#cb223-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-38"><a href="#cb223-38" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_assignable_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
-<span id="cb223-39"><a href="#cb223-39" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copy_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-40"><a href="#cb223-40" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_move_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-41"><a href="#cb223-41" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_destructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-42"><a href="#cb223-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-43"><a href="#cb223-43" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb223-44"><a href="#cb223-44" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_constructible_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb223-45"><a href="#cb223-45" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_default_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-46"><a href="#cb223-46" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_copy_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-47"><a href="#cb223-47" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_move_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-48"><a href="#cb223-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-49"><a href="#cb223-49" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_assignable_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
-<span id="cb223-50"><a href="#cb223-50" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_copy_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-51"><a href="#cb223-51" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_move_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-52"><a href="#cb223-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-53"><a href="#cb223-53" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_swappable_with_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
-<span id="cb223-54"><a href="#cb223-54" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_swappable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-55"><a href="#cb223-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-56"><a href="#cb223-56" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_destructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-57"><a href="#cb223-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-58"><a href="#cb223-58" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_implicit_lifetime_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-59"><a href="#cb223-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-60"><a href="#cb223-60" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_virtual_destructor<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-61"><a href="#cb223-61" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-62"><a href="#cb223-62" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_unique_object_representations<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb223-63"><a href="#cb223-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-64"><a href="#cb223-64" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> reference_constructs_from_temporary<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
-<span id="cb223-65"><a href="#cb223-65" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> reference_converts_from_temporary<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb229"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb229-1"><a href="#cb229-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_const_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-2"><a href="#cb229-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_volatile_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-3"><a href="#cb229-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivial_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-4"><a href="#cb229-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copyable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-5"><a href="#cb229-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_standard_layout_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-6"><a href="#cb229-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_empty_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-7"><a href="#cb229-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_polymorphic_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-8"><a href="#cb229-8" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_abstract_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-9"><a href="#cb229-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_final_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-10"><a href="#cb229-10" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_aggregate_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-11"><a href="#cb229-11" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_signed_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-12"><a href="#cb229-12" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_unsigned_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-13"><a href="#cb229-13" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_bounded_array_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-14"><a href="#cb229-14" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_unbounded_array_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-15"><a href="#cb229-15" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_scoped_enum_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-16"><a href="#cb229-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-17"><a href="#cb229-17" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb229-18"><a href="#cb229-18" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructible_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb229-19"><a href="#cb229-19" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_default_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-20"><a href="#cb229-20" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-21"><a href="#cb229-21" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-22"><a href="#cb229-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-23"><a href="#cb229-23" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_assignable_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
+<span id="cb229-24"><a href="#cb229-24" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-25"><a href="#cb229-25" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-26"><a href="#cb229-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-27"><a href="#cb229-27" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_swappable_with_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
+<span id="cb229-28"><a href="#cb229-28" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_swappable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-29"><a href="#cb229-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-30"><a href="#cb229-30" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_destructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-31"><a href="#cb229-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-32"><a href="#cb229-32" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb229-33"><a href="#cb229-33" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_constructible_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb229-34"><a href="#cb229-34" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_default_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-35"><a href="#cb229-35" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copy_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-36"><a href="#cb229-36" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_move_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-37"><a href="#cb229-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-38"><a href="#cb229-38" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_assignable_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
+<span id="cb229-39"><a href="#cb229-39" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copy_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-40"><a href="#cb229-40" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_move_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-41"><a href="#cb229-41" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_destructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-42"><a href="#cb229-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-43"><a href="#cb229-43" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb229-44"><a href="#cb229-44" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_constructible_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb229-45"><a href="#cb229-45" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_default_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-46"><a href="#cb229-46" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_copy_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-47"><a href="#cb229-47" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_move_constructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-48"><a href="#cb229-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-49"><a href="#cb229-49" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_assignable_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
+<span id="cb229-50"><a href="#cb229-50" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_copy_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-51"><a href="#cb229-51" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_move_assignable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-52"><a href="#cb229-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-53"><a href="#cb229-53" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_swappable_with_type<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
+<span id="cb229-54"><a href="#cb229-54" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_swappable_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-55"><a href="#cb229-55" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-56"><a href="#cb229-56" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_destructible_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-57"><a href="#cb229-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-58"><a href="#cb229-58" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_implicit_lifetime_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-59"><a href="#cb229-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-60"><a href="#cb229-60" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_virtual_destructor<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-61"><a href="#cb229-61" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-62"><a href="#cb229-62" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_unique_object_representations<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb229-63"><a href="#cb229-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb229-64"><a href="#cb229-64" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> reference_constructs_from_temporary<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span>
+<span id="cb229-65"><a href="#cb229-65" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> reference_converts_from_temporary<span class="op">(</span>info type_dst, info type_src<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -10058,13 +10765,13 @@ <h4 class="unnumbered" id="meta.reflection.unary.prop.query-type-property-querie
 <div class="std">
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb224"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb224-1"><a href="#cb224-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> rank<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_452" id="pnum_452">1</a></span>
+<div class="sourceCode" id="cb230"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb230-1"><a href="#cb230-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> rank<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_497" id="pnum_497">1</a></span>
 <em>Effects</em>: Equivalent to <code class="sourceCode cpp"><span class="cf">return</span> std<span class="op">::</span>rank_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>,
 where <code class="sourceCode cpp">T</code> is the type represented by
 <code class="sourceCode cpp">type</code>.</p>
-<div class="sourceCode" id="cb225"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb225-1"><a href="#cb225-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> extent<span class="op">(</span>info type, <span class="dt">unsigned</span> i <span class="op">=</span> <span class="dv">0</span><span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_453" id="pnum_453">2</a></span>
+<div class="sourceCode" id="cb231"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb231-1"><a href="#cb231-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> extent<span class="op">(</span>info type, <span class="dt">unsigned</span> i <span class="op">=</span> <span class="dv">0</span><span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_498" id="pnum_498">2</a></span>
 <em>Effects</em>: Equivalent to <code class="sourceCode cpp"><span class="cf">return</span> std<span class="op">::</span>extent_v<span class="op">&lt;</span>T, i<span class="op">&gt;</span></code>,
 where <code class="sourceCode cpp">T</code> is the type represented by
 <code class="sourceCode cpp">type</code>.</p>
@@ -10076,10 +10783,10 @@ <h3 class="unnumbered" id="meta.reflection.rel-type-relations">[meta.reflection.
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_454" id="pnum_454">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_499" id="pnum_499">1</a></span>
 The consteval functions specified in this clause may be used to query
 relationships between types at compile time.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_455" id="pnum_455">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_500" id="pnum_500">2</a></span>
 For any types or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code> and
@@ -10088,7 +10795,7 @@ <h3 class="unnumbered" id="meta.reflection.rel-type-relations">[meta.reflection.
 <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>REL</em>_type<span class="op">(^^</span>T, <span class="op">^^</span>U<span class="op">)</span></code>
 equals the value of the corresponding type relation <code class="sourceCode cpp">std<span class="op">::</span><em>REL</em>_v<span class="op">&lt;</span>T, U<span class="op">&gt;</span></code>
 as specified in <span>21.3.7 <a href="https://wg21.link/meta.rel">[meta.rel]</a></span>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_456" id="pnum_456">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_501" id="pnum_501">3</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, pack of types or
@@ -10100,7 +10807,7 @@ <h3 class="unnumbered" id="meta.reflection.rel-type-relations">[meta.reflection.
 <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-REL</em>_type<span class="op">(^^</span>T, r<span class="op">)</span></code>
 equals the value of the corresponding type relation <code class="sourceCode cpp">std<span class="op">::</span><em>VARIADIC-REL</em>_v<span class="op">&lt;</span>T, U<span class="op">...&gt;</span></code>
 as specified in <span>21.3.7 <a href="https://wg21.link/meta.rel">[meta.rel]</a></span>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_457" id="pnum_457">4</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_502" id="pnum_502">4</a></span>
 For any types or
 <code class="sourceCode cpp"><em>typedef-names</em></code>
 <code class="sourceCode cpp">T</code> and
@@ -10113,24 +10820,24 @@ <h3 class="unnumbered" id="meta.reflection.rel-type-relations">[meta.reflection.
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-REL-R</em><span class="op">(^^</span>R, <span class="op">^^</span>T, r<span class="op">)</span>_type</code>
 equals the value of the corresponding type relation <code class="sourceCode cpp">std<span class="op">::</span><em>VARIADIC-REL-R</em>_v<span class="op">&lt;</span>R, T, U<span class="op">...&gt;</span></code>
 as specified in <span>21.3.7 <a href="https://wg21.link/meta.rel">[meta.rel]</a></span>.</p>
-<div class="sourceCode" id="cb226"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb226-1"><a href="#cb226-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_same_type<span class="op">(</span>info type1, info type2<span class="op">)</span>;</span>
-<span id="cb226-2"><a href="#cb226-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_base_of_type<span class="op">(</span>info type_base, info type_derived<span class="op">)</span>;</span>
-<span id="cb226-3"><a href="#cb226-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_virtual_base_of_type<span class="op">(</span>info type_base, info type_derived<span class="op">)</span>;</span>
-<span id="cb226-4"><a href="#cb226-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_convertible_type<span class="op">(</span>info type_src, info type_dst<span class="op">)</span>;</span>
-<span id="cb226-5"><a href="#cb226-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_convertible_type<span class="op">(</span>info type_src, info type_dst<span class="op">)</span>;</span>
-<span id="cb226-6"><a href="#cb226-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_layout_compatible_type<span class="op">(</span>info type1, info type2<span class="op">)</span>;</span>
-<span id="cb226-7"><a href="#cb226-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pointer_interconvertible_base_of_type<span class="op">(</span>info type_base, info type_derived<span class="op">)</span>;</span>
-<span id="cb226-8"><a href="#cb226-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb226-9"><a href="#cb226-9" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb226-10"><a href="#cb226-10" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_invocable_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb226-11"><a href="#cb226-11" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb226-12"><a href="#cb226-12" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_invocable_r_type<span class="op">(</span>info type_result, info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb226-13"><a href="#cb226-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb226-14"><a href="#cb226-14" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb226-15"><a href="#cb226-15" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_invocable_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb226-16"><a href="#cb226-16" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb226-17"><a href="#cb226-17" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_invocable_r_type<span class="op">(</span>info type_result, info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_458" id="pnum_458">5</a></span>
+<div class="sourceCode" id="cb232"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb232-1"><a href="#cb232-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_same_type<span class="op">(</span>info type1, info type2<span class="op">)</span>;</span>
+<span id="cb232-2"><a href="#cb232-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_base_of_type<span class="op">(</span>info type_base, info type_derived<span class="op">)</span>;</span>
+<span id="cb232-3"><a href="#cb232-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_virtual_base_of_type<span class="op">(</span>info type_base, info type_derived<span class="op">)</span>;</span>
+<span id="cb232-4"><a href="#cb232-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_convertible_type<span class="op">(</span>info type_src, info type_dst<span class="op">)</span>;</span>
+<span id="cb232-5"><a href="#cb232-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_convertible_type<span class="op">(</span>info type_src, info type_dst<span class="op">)</span>;</span>
+<span id="cb232-6"><a href="#cb232-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_layout_compatible_type<span class="op">(</span>info type1, info type2<span class="op">)</span>;</span>
+<span id="cb232-7"><a href="#cb232-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pointer_interconvertible_base_of_type<span class="op">(</span>info type_base, info type_derived<span class="op">)</span>;</span>
+<span id="cb232-8"><a href="#cb232-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb232-9"><a href="#cb232-9" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb232-10"><a href="#cb232-10" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_invocable_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb232-11"><a href="#cb232-11" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb232-12"><a href="#cb232-12" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_invocable_r_type<span class="op">(</span>info type_result, info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb232-13"><a href="#cb232-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb232-14"><a href="#cb232-14" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb232-15"><a href="#cb232-15" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_invocable_type<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb232-16"><a href="#cb232-16" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb232-17"><a href="#cb232-17" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_invocable_r_type<span class="op">(</span>info type_result, info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_503" id="pnum_503">5</a></span>
 <span class="note"><span>[ <em>Note 1:</em> </span>If
 <code class="sourceCode cpp">t</code> is a reflection of the type
 <code class="sourceCode cpp"><span class="dt">int</span></code> and
@@ -10152,7 +10859,7 @@ <h3 class="unnumbered" id="meta.reflection.trans-transformations-between-types">
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_459" id="pnum_459">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_504" id="pnum_504">1</a></span>
 Subclause [meta.reflection.trans] contains consteval functions that may
 be used to transform one type to another following some predefined
 rule.</p>
@@ -10164,19 +10871,19 @@ <h4 class="unnumbered" id="meta.reflection.trans.cv-const-volatile-modifications
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_460" id="pnum_460">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_505" id="pnum_505">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code>
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^^</span>T<span class="op">)</span></code>
 returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.8.2 <a href="https://wg21.link/meta.trans.cv">[meta.trans.cv]</a></span>.</p>
-<div class="sourceCode" id="cb227"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb227-1"><a href="#cb227-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_const<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb227-2"><a href="#cb227-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb227-3"><a href="#cb227-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_cv<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb227-4"><a href="#cb227-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_const<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb227-5"><a href="#cb227-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb227-6"><a href="#cb227-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_cv<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb233"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb233-1"><a href="#cb233-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_const<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb233-2"><a href="#cb233-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb233-3"><a href="#cb233-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_cv<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb233-4"><a href="#cb233-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_const<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb233-5"><a href="#cb233-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb233-6"><a href="#cb233-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_cv<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -10185,16 +10892,16 @@ <h4 class="unnumbered" id="meta.reflection.trans.ref-reference-modifications">[m
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_461" id="pnum_461">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_506" id="pnum_506">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code>
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^^</span>T<span class="op">)</span></code>
 returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.8.3 <a href="https://wg21.link/meta.trans.ref">[meta.trans.ref]</a></span>.</p>
-<div class="sourceCode" id="cb228"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb228-1"><a href="#cb228-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb228-2"><a href="#cb228-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_lvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb228-3"><a href="#cb228-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_rvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb234"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb234-1"><a href="#cb234-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb234-2"><a href="#cb234-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_lvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb234-3"><a href="#cb234-3" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_rvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -10203,15 +10910,15 @@ <h4 class="unnumbered" id="meta.reflection.trans.sign-sign-modifications">[meta.
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_462" id="pnum_462">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_507" id="pnum_507">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code>
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^^</span>T<span class="op">)</span></code>
 returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.8.4 <a href="https://wg21.link/meta.trans.sign">[meta.trans.sign]</a></span>.</p>
-<div class="sourceCode" id="cb229"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb229-1"><a href="#cb229-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info make_signed<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb229-2"><a href="#cb229-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info make_unsigned<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb235"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb235-1"><a href="#cb235-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info make_signed<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb235-2"><a href="#cb235-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info make_unsigned<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -10220,15 +10927,15 @@ <h4 class="unnumbered" id="meta.reflection.trans.arr-array-modifications">[meta.
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_463" id="pnum_463">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_508" id="pnum_508">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code>
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^^</span>T<span class="op">)</span></code>
 returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.8.5 <a href="https://wg21.link/meta.trans.arr">[meta.trans.arr]</a></span>.</p>
-<div class="sourceCode" id="cb230"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb230-1"><a href="#cb230-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_extent<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb230-2"><a href="#cb230-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_all_extents<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb236"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb236-1"><a href="#cb236-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_extent<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb236-2"><a href="#cb236-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_all_extents<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -10237,15 +10944,15 @@ <h4 class="unnumbered" id="meta.reflection.trans.ptr-pointer-modifications">[met
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_464" id="pnum_464">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_509" id="pnum_509">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code>
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^^</span>T<span class="op">)</span></code>
 returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.8.6 <a href="https://wg21.link/meta.trans.ptr">[meta.trans.ptr]</a></span>.</p>
-<div class="sourceCode" id="cb231"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb231-1"><a href="#cb231-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb231-2"><a href="#cb231-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_pointer<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb237"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb237-1"><a href="#cb237-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb237-2"><a href="#cb237-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info add_pointer<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -10264,7 +10971,7 @@ <h4 class="unnumbered" id="meta.reflection.trans.other-other-transformations">[m
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_465" id="pnum_465">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_510" id="pnum_510">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>type_<em>MOD</em></code>
@@ -10272,7 +10979,7 @@ <h4 class="unnumbered" id="meta.reflection.trans.other-other-transformations">[m
 <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>type_<em>MOD</em><span class="op">(^^</span>T<span class="op">)</span></code>
 returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as specified in <span>21.3.8.7 <a href="https://wg21.link/meta.trans.other">[meta.trans.other]</a></span>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_466" id="pnum_466">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_511" id="pnum_511">2</a></span>
 For any pack of types or
 <code class="sourceCode cpp"><em>typedef-names</em></code>
 <code class="sourceCode cpp">T<span class="op">...</span></code> and
@@ -10282,7 +10989,7 @@ <h4 class="unnumbered" id="meta.reflection.trans.other-other-transformations">[m
 defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-MOD</em><span class="op">(</span>r<span class="op">)</span></code>
 returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>VARIADIC-MOD</em>_t<span class="op">&lt;</span>T<span class="op">...&gt;</span></code>
 as specified in <span>21.3.8.7 <a href="https://wg21.link/meta.trans.other">[meta.trans.other]</a></span>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_467" id="pnum_467">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_512" id="pnum_512">3</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, pack of types or
@@ -10293,29 +11000,29 @@ <h4 class="unnumbered" id="meta.reflection.trans.other-other-transformations">[m
 <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>invoke_result<span class="op">(^^</span>T, r<span class="op">)</span></code>
 returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span>invoke_result_t<span class="op">&lt;</span>T, U<span class="op">...&gt;</span></code>
 (<span>21.3.8.7 <a href="https://wg21.link/meta.trans.other">[meta.trans.other]</a></span>).</p>
-<div class="sourceCode" id="cb232"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb232-1"><a href="#cb232-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_cvref<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb232-2"><a href="#cb232-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info decay<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb232-3"><a href="#cb232-3" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb232-4"><a href="#cb232-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info common_type<span class="op">(</span>R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb232-5"><a href="#cb232-5" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb232-6"><a href="#cb232-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info common_reference<span class="op">(</span>R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb232-7"><a href="#cb232-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info underlying_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb232-8"><a href="#cb232-8" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
-<span id="cb232-9"><a href="#cb232-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info invoke_result<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
-<span id="cb232-10"><a href="#cb232-10" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info unwrap_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb232-11"><a href="#cb232-11" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info unwrap_ref_decay<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_468" id="pnum_468">4</a></span></p>
+<div class="sourceCode" id="cb238"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb238-1"><a href="#cb238-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info remove_cvref<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb238-2"><a href="#cb238-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info decay<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb238-3"><a href="#cb238-3" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb238-4"><a href="#cb238-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info common_type<span class="op">(</span>R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb238-5"><a href="#cb238-5" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb238-6"><a href="#cb238-6" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info common_reference<span class="op">(</span>R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb238-7"><a href="#cb238-7" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info underlying_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb238-8"><a href="#cb238-8" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>reflection_range R <span class="op">=</span> initializer_list<span class="op">&lt;</span>info<span class="op">&gt;&gt;</span></span>
+<span id="cb238-9"><a href="#cb238-9" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info invoke_result<span class="op">(</span>info type, R<span class="op">&amp;&amp;</span> type_args<span class="op">)</span>;</span>
+<span id="cb238-10"><a href="#cb238-10" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info unwrap_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb238-11"><a href="#cb238-11" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info unwrap_ref_decay<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_513" id="pnum_513">4</a></span></p>
 <div class="example">
 <span>[ <em>Example 1:</em> </span>
-<div class="sourceCode" id="cb233"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb233-1"><a href="#cb233-1" aria-hidden="true" tabindex="-1"></a><span class="co">// example implementation</span></span>
-<span id="cb233-2"><a href="#cb233-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info unwrap_reference<span class="op">(</span>info type<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb233-3"><a href="#cb233-3" aria-hidden="true" tabindex="-1"></a>  type <span class="op">=</span> dealias<span class="op">(</span>type<span class="op">)</span>;</span>
-<span id="cb233-4"><a href="#cb233-4" aria-hidden="true" tabindex="-1"></a>  <span class="cf">if</span> <span class="op">(</span>has_template_arguments<span class="op">(</span>type<span class="op">)</span> <span class="op">&amp;&amp;</span> template_of<span class="op">(</span>type<span class="op">)</span> <span class="op">==</span> <span class="op">^^</span>reference_wrapper<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb233-5"><a href="#cb233-5" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> add_lvalue_reference<span class="op">(</span>template_arguments_of<span class="op">(</span>type<span class="op">)[</span><span class="dv">0</span><span class="op">])</span>;</span>
-<span id="cb233-6"><a href="#cb233-6" aria-hidden="true" tabindex="-1"></a>  <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
-<span id="cb233-7"><a href="#cb233-7" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> type;</span>
-<span id="cb233-8"><a href="#cb233-8" aria-hidden="true" tabindex="-1"></a>  <span class="op">}</span></span>
-<span id="cb233-9"><a href="#cb233-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb239"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb239-1"><a href="#cb239-1" aria-hidden="true" tabindex="-1"></a><span class="co">// example implementation</span></span>
+<span id="cb239-2"><a href="#cb239-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info unwrap_reference<span class="op">(</span>info type<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb239-3"><a href="#cb239-3" aria-hidden="true" tabindex="-1"></a>  type <span class="op">=</span> dealias<span class="op">(</span>type<span class="op">)</span>;</span>
+<span id="cb239-4"><a href="#cb239-4" aria-hidden="true" tabindex="-1"></a>  <span class="cf">if</span> <span class="op">(</span>has_template_arguments<span class="op">(</span>type<span class="op">)</span> <span class="op">&amp;&amp;</span> template_of<span class="op">(</span>type<span class="op">)</span> <span class="op">==</span> <span class="op">^^</span>reference_wrapper<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb239-5"><a href="#cb239-5" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> add_lvalue_reference<span class="op">(</span>template_arguments_of<span class="op">(</span>type<span class="op">)[</span><span class="dv">0</span><span class="op">])</span>;</span>
+<span id="cb239-6"><a href="#cb239-6" aria-hidden="true" tabindex="-1"></a>  <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb239-7"><a href="#cb239-7" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> type;</span>
+<span id="cb239-8"><a href="#cb239-8" aria-hidden="true" tabindex="-1"></a>  <span class="op">}</span></span>
+<span id="cb239-9"><a href="#cb239-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
 <span> — <em>end example</em> ]</span>
 </div>
 </div>
@@ -10326,7 +11033,7 @@ <h4 class="unnumbered" id="meta.reflection.tuple.variant-tuple-and-variant-queri
 <div class="std">
 <blockquote>
 <div class="addu">
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_469" id="pnum_469">1</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_514" id="pnum_514">1</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>UNARY-TRAIT</em></code>
@@ -10334,7 +11041,7 @@ <h4 class="unnumbered" id="meta.reflection.tuple.variant-tuple-and-variant-queri
 <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>UNARY-TRAIT</em><span class="op">(^^</span>T<span class="op">)</span></code>
 equals the value of the corresponding property <code class="sourceCode cpp">std<span class="op">::</span><em>UNARY-TRAIT</em>_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 as defined in <span>22.4 <a href="https://wg21.link/tuple">[tuple]</a></span> or <span>22.6 <a href="https://wg21.link/variant">[variant]</a></span>.</p>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_470" id="pnum_470">2</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_515" id="pnum_515">2</a></span>
 For any type or
 <code class="sourceCode cpp"><em>typedef-name</em></code>
 <code class="sourceCode cpp">T</code> and value
@@ -10343,11 +11050,11 @@ <h4 class="unnumbered" id="meta.reflection.tuple.variant-tuple-and-variant-queri
 <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>BINARY-TRAIT</em><span class="op">(</span>I, <span class="op">^^</span>T<span class="op">)</span></code>
 returns a reflection representing the type <code class="sourceCode cpp">std<span class="op">::</span><em>BINARY-TRAIT</em>_t<span class="op">&lt;</span>I, T<span class="op">&gt;</span></code>
 as defined in <span>22.4 <a href="https://wg21.link/tuple">[tuple]</a></span> or <span>22.6 <a href="https://wg21.link/variant">[variant]</a></span>.</p>
-<div class="sourceCode" id="cb234"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb234-1"><a href="#cb234-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> tuple_size<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb234-2"><a href="#cb234-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info tuple_element<span class="op">(</span><span class="dt">size_t</span> index, info type<span class="op">)</span>;</span>
-<span id="cb234-3"><a href="#cb234-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb234-4"><a href="#cb234-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> variant_size<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb234-5"><a href="#cb234-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info variant_alternative<span class="op">(</span><span class="dt">size_t</span> index, info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb240"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb240-1"><a href="#cb240-1" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> tuple_size<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb240-2"><a href="#cb240-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info tuple_element<span class="op">(</span><span class="dt">size_t</span> index, info type<span class="op">)</span>;</span>
+<span id="cb240-3"><a href="#cb240-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb240-4"><a href="#cb240-4" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> variant_size<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb240-5"><a href="#cb240-5" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> info variant_alternative<span class="op">(</span><span class="dt">size_t</span> index, info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -10358,7 +11065,7 @@ <h3 class="unnumbered" id="bit.cast-function-template-bit_cast"><span>22.15.3 <a
 as a constant, in <span>22.15.3 <a href="https://wg21.link/bit.cast">[bit.cast]</a></span>/3:</p>
 <div class="std">
 <blockquote>
-<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_471" id="pnum_471">3</a></span>
+<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_516" id="pnum_516">3</a></span>
 <em>Remarks</em>: This function is constexpr if and only if
 <code class="sourceCode cpp">To</code>,
 <code class="sourceCode cpp">From</code>, and the types of all
@@ -10366,27 +11073,27 @@ <h3 class="unnumbered" id="bit.cast-function-template-bit_cast"><span>22.15.3 <a
 <code class="sourceCode cpp">From</code> are types
 <code class="sourceCode cpp">T</code> such that:</p>
 <ul>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_472" id="pnum_472">(3.1)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_517" id="pnum_517">(3.1)</a></span>
 <code class="sourceCode cpp">is_union_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 is
 <code class="sourceCode cpp"><span class="kw">false</span></code>;</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_473" id="pnum_473">(3.2)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_518" id="pnum_518">(3.2)</a></span>
 <code class="sourceCode cpp">is_pointer_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 is
 <code class="sourceCode cpp"><span class="kw">false</span></code>;</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_474" id="pnum_474">(3.3)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_519" id="pnum_519">(3.3)</a></span>
 <code class="sourceCode cpp">is_member_pointer_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 is
 <code class="sourceCode cpp"><span class="kw">false</span></code>;</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_475" id="pnum_475">(3.π)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_520" id="pnum_520">(3.π)</a></span>
 <span class="addu"><code class="sourceCode cpp">is_reflection_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 is
 <code class="sourceCode cpp"><span class="kw">false</span></code>;</span></li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_476" id="pnum_476">(3.4)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_521" id="pnum_521">(3.4)</a></span>
 <code class="sourceCode cpp">is_volatile_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 is <code class="sourceCode cpp"><span class="kw">false</span></code>;
 and</li>
-<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_477" id="pnum_477">(3.5)</a></span>
+<li><span class="marginalizedparent"><a class="marginalized" href="#pnum_522" id="pnum_522">(3.5)</a></span>
 <code class="sourceCode cpp">T</code> has no non-static data members of
 reference type.</li>
 </ul>
@@ -10404,10 +11111,10 @@ <h2 data-number="5.3" id="feature-test-macro"><span class="header-section-number
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb235"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb235-1"><a href="#cb235-1" aria-hidden="true" tabindex="-1"></a>  __cpp_impl_coroutine 201902L</span>
-<span id="cb235-2"><a href="#cb235-2" aria-hidden="true" tabindex="-1"></a>  __cpp_impl_destroying_delete 201806L</span>
-<span id="cb235-3"><a href="#cb235-3" aria-hidden="true" tabindex="-1"></a>  __cpp_impl_three_way_comparison 201907L</span>
-<span id="cb235-4"><a href="#cb235-4" aria-hidden="true" tabindex="-1"></a><span class="va">+ __cpp_impl_reflection 2024XXL</span></span></code></pre></div>
+<div class="sourceCode" id="cb241"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb241-1"><a href="#cb241-1" aria-hidden="true" tabindex="-1"></a>  __cpp_impl_coroutine 201902L</span>
+<span id="cb241-2"><a href="#cb241-2" aria-hidden="true" tabindex="-1"></a>  __cpp_impl_destroying_delete 201806L</span>
+<span id="cb241-3"><a href="#cb241-3" aria-hidden="true" tabindex="-1"></a>  __cpp_impl_three_way_comparison 201907L</span>
+<span id="cb241-4"><a href="#cb241-4" aria-hidden="true" tabindex="-1"></a><span class="va">+ __cpp_impl_reflection 2024XXL</span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
@@ -10415,7 +11122,7 @@ <h2 data-number="5.3" id="feature-test-macro"><span class="header-section-number
 <div class="std">
 <blockquote>
 <div>
-<div class="sourceCode" id="cb236"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb236-1"><a href="#cb236-1" aria-hidden="true" tabindex="-1"></a><span class="va">+ #define __cpp_lib_reflection 2024XXL // also in &lt;meta&gt;</span></span></code></pre></div>
+<div class="sourceCode" id="cb242"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb242-1"><a href="#cb242-1" aria-hidden="true" tabindex="-1"></a><span class="va">+ #define __cpp_lib_reflection 2024XXL // also in &lt;meta&gt;</span></span></code></pre></div>
 </div>
 </blockquote>
 </div>
diff --git a/2996_reflection/reflection.md b/2996_reflection/reflection.md
index 6b87a328..ee07035d 100644
--- a/2996_reflection/reflection.md
+++ b/2996_reflection/reflection.md
@@ -2,7 +2,7 @@
 title: "Reflection for C++26"
 document: P2996R8
 date: today
-audience: CWG, LEWG
+audience: CWG, LEWG, LWG
 author:
     - name: Wyatt Childers
       email: <wcc@edg.com>
@@ -1846,7 +1846,7 @@ First, we identify a subset of manifestly constant-evaluated expressions and con
 We require that a programmer can count on those evaluations occurring exactly once and completing at translation time.
 
 Second, we sequence plainly constant-evaluated expressions and conversions within the lexical order.
-Specifically, we require that the evaluation of a plainly constant-evaluated expression or conversion occurs before the implementation checks the validity of source constructs lexically following that expression or conversion.
+Specifically, we require that the evaluation of a non-dependent plainly constant-evaluated expression or conversion occurs before the implementation checks the validity of source constructs lexically following that expression or conversion.
 
 Those constraints are mostly intuitive, but they are a significant change to the underlying principles of the current standard in this respect.
 
@@ -2923,13 +2923,13 @@ Education and training are important to help C++ users avoid such sharp edges, b
 
 ### [lex.phases]{.sref} Phases of translation {-}
 
-[In addition to changes necessary for this proposal, we are applying the "drive-by fix" of merging phases 7/8, in order to clarify that template instantiation is interleaved with translation.]{.ednote}
+[In addition to changes necessary for this proposal, we are applying the "drive-by fix" of merging phases 7/8, in order to clarify that template instantiation is interleaved with translation. In so doing, we replace the notion of "instantiation units" with a partial ordering among all program constructs in a translation unit.]{.ednote}
 
 Modify the wording for phases 7-8 of [lex.phases]{.sref} as follows:
 
 ::: std
 
-[7-8]{.pnum} Whitespace characters separating tokens are no longer significant. Each preprocessing token is converted into a token ([lex.token]{.sref}). The resulting tokens constitute a translation unit and are syntactically and semantically analyzed and translated [alongside any instantiation units (see below) that are produced]{.addu}. [During this process, non-dependent plainly constant-evaluated expressions ([expr.const]) are evaluated in lexical order. Diagnosable rules ([intro.compliance.general]{.sref}) that apply to constructs whose syntactic end point occurs lexically after the syntactic end point of a non-dependent plainly constant-evaluated expression `$X$` are considered in a context where `$X$` has been evaluated exactly once.]{.addu}
+[7-8]{.pnum} Whitespace characters separating tokens are no longer significant. Each preprocessing token is converted into a token ([lex.token]{.sref}). The resulting tokens constitute a translation unit and are syntactically and semantically analyzed and translated.
 
   [The process of analyzing and translating the tokens can occasionally result in one token being replaced by a sequence of other tokens ([temp.names])]{.note3}
 
@@ -2937,31 +2937,38 @@ Modify the wording for phases 7-8 of [lex.phases]{.sref} as follows:
 
   [Source files, translation units and translated translation units need not necessarily be stored as files, nor need there be any one-to-one correspondence between these entities and any external representation. The description is conceptual only, and does not specify any particular implementation.]{.note}
 
-  [While the tokens constituting translation units are being analyzed and translated, a collection of required instantiations is produced.]{.addu}
-
   [Translated translation units and instantiation units are combined as follows:]{.rm}
 
   [[Some or all of these can be supplied from a library.]{.note5}]{.rm}
 
   [Each translated translation unit is examined to produce a list of required instantiations.]{.rm}
 
+  [While the tokens constituting translation units are being analyzed and translated, a collection of required instantiations is produced.]{.addu}
+
   [This can include instantiations which have been explicitly requested ([temp.explicit]).]{.note5}
 
+  [The contexts from which instantiations may be performed are determined by their respective points of instantiation ([temp.point]{.sref}).]{.addu}
+
+  [[Other requirements in this document can further constrain the  context from which an instantiation can be performed. For example, a constexpr function template specialization might have a point of instantation at the end of a translation unit, but its use in certain constant expressions could require that it be instantiated from an earlier point ([temp.inst]).]{.note}]{.addu}
+
   The definitions of the required templates are located. It is implementation-defined whether the source of the translation units containing these definitions is required to be available.
 
   [[An implementation can choose to encode sufficient information into the translated translation unit so as to ensure the source is not required here.]{.note}]{.rm}
 
-  All required instantiations are perfomed to produce _instantiation units_.
+  [All required instantiations are perfomed to produce _instantiation units_.]{.rm}
 
-  [These are similar to translated translation units, but contain no references to uninstantiated templates and no template definitions.]{.note}
+  [[These are similar to translated translation units, but contain no references to uninstantiated templates and no template definitions.]{.note}]{.rm}
 
-  [The contexts from which instantiations may be performed are determined by their respective points of instantiation ([temp.point]), and may be further constrained by other requirements in this document.]{.addu}
+  [Each instantiation results in new program constructs.]{.addu} The program is ill-formed if any instantiation fails.
 
-  [[For example, a constexpr function template specialization might have a point of instantation at the end of a translation unit, but its use in certain constant expressions could require that it be instantiated from an earlier point ([temp.inst]).]{.note}]{.addu}
+  [Instantiation confers a partition over the program constructs, and the tokens comprising the translation unit furthermore endow the partitioned constructs with a partial order. Two constructs are _instantiation-sequenced_ if the tokens by which they are described belong to the same translation unit and if either both constructs result from the same instantiation or if neither results from any instantiation. Given two instantiation-sequenced program constructs, whether one _semantically follows_ the other is determined as follows:]{.addu}
 
-  [During this process, plainly constant-evaluated expressions appearing in the same instantiation unit are evaluated in lexical order as part of the instantiation process. Diagnosable rules ([intro.compliance.general]{.sref}) that apply to constructs whose syntactic end point occurs lexically after the syntactic end point of a plainly constant-evaluated expression `$X$` in the same instantiation unit are considered in a context where `$X$` has been evaluated exactly once.]{.addu}
+  * [[7.8-1]{.pnum} If both constructs are within the `$member-specification$` of a class `C` ([class.mem.general]{.sref}) and one such construct (call it `$X$`) is in a complete-class context of `C` but the other (call it `$Y$`) is not, then `$X$` semantically follows `$Y$`.]{.addu}
+  * [[7-8.#]{.pnum} Otherwise, if the syntactic endpoint of the tokens that describe one such construct (call it `$X$`) occurs lexically after the syntactic endpoint of the tokens that describe the other (call it `$Y$`), then `$X$` semantically follows `$Y$`.]{.addu}
 
-  The program is ill-formed if any instantiation fails.
+  [During the analysis and translation of tokens and instantiations, certain expressions are evaluated. Diagnosable rules ([intro.compliance.general]{.sref}) that apply to constructs that semantically follow a plainly constant-evaluated expression `$P$` ([expr.const]{.sref}) are considered in a context where `$P$` has been evaluated exactly once.]{.addu}
+
+  [[Other requirements in this document can further constrain the contexts from which expressions are evaluated. For example, a declaration that lexically follows all points from which a given instantiation can be perfomed will be considered in a context where all plainly constant-evaluated expressions resulting from that instantiation have been evaluated exactly once.]{.note}]{.addu}
 
   [8]{.pnum} All external entity references are resolved. [...]
 
@@ -2969,22 +2976,22 @@ Modify the wording for phases 7-8 of [lex.phases]{.sref} as follows:
 
 ### [lex.pptoken]{.sref} Preprocessing tokens {-}
 
-Add a bullet after [lex.pptoken]{.sref} bullet (3.2):
+Add a bullet after bullet (4.2):
 
 ::: std
-  ...
+* [4]{.pnum} If the input stream has been parsed into preprocessing tokens up to a given character:
 
-  --- Otherwise, if the next three characters are `<::` and the subsequent character is neither `:` nor `>`, the `<` is treated as a preprocessing token by itself and not as the first character of the alternative token `<:`.
+  * [#.#]{.pnum} ...
+  * [#.#]{.pnum} Otherwise, if the next three characters are `<::` and the subsequent character is neither `:` nor `>`, the `<` is treated as a preprocessing token by itself and not as the first character of the alternative token `<:`.
+  * [[#.#]{.pnum} Otherwise, if the next three characters are `[::` and the subsequent character is not `:`, or if the next three characters are `[:>`, the `[` is treated as a preprocessing token by itself and not as the first character of the preprocessing token `[:`.]{.addu}
 
-::: addu
-  --- Otherwise, if the next three characters are `[::` and the subsequent character is not `:` or if the next three characters are `[:>`, the `[` is treated as a preprocessing token by itself and not as the first character of the preprocessing token `[:`.
-:::
-  ...
+      [[The tokens `[:` and `:]` cannot be composed from digraphs.]{.note}]{.addu}
+  * [#.#]{.pnum} ...
 :::
 
 ### [lex.operators]{.sref} Operators and punctuators {-}
 
-Change the grammar for `$operator-or-punctuator$` in paragraph 1 of [lex.operators]{.sref} to include splicer delimiters:
+Change the grammar for `$operator-or-punctuator$` in paragraph 1 of [lex.operators]{.sref} to include the reflection operator and the `$splice-specifier$` delimiters:
 
 ::: std
 ```
@@ -3003,12 +3010,6 @@ Change the grammar for `$operator-or-punctuator$` in paragraph 1 of [lex.operato
 
 ### [basic.def.odr]{.sref} One-definition rule {-}
 
-Modify paragraph 4.1 to cover splicing of functions:
-
-::: std
-- [4.1]{.pnum} A function is named by an expression or conversion if it is the selected member of an overload set ([basic.lookup], [over.match], [over.over]) in an overload resolution performed as part of forming that expression or conversion, [or if it is designated by a `$splice-expression$` ([expr.prim.splice]),]{.addu} unless it is a pure virtual function and either the expression is not an `$id-expression$` naming the function with an explicitly qualified name or the expression forms a pointer to member ([expr.unary.op]).
-:::
-
 Modify the first sentence of paragraph 5 to cover splicing of variables:
 
 ::: std
@@ -3018,7 +3019,8 @@ Modify the first sentence of paragraph 5 to cover splicing of variables:
 Modify paragraph 6 to cover splicing of structured bindings:
 
 ::: std
-- [6]{.pnum} A structured binding is odr-used if it appears as a potentially-evaluated expression[, or if a reflection representing it is the operand of a potentially-evaluated `$splice-expression$` ([expr.prim.splice])]{.addu}.
+- [6]{.pnum} A structured binding is [odr-used if it appears as a potentially-evaluated]{.rm} [named by an]{.addu} expression [if that expression is either an]{.addu} `$id-expression$` [or a `$splice-expression$` that designates that structured binding. A structured binding is odr-used if it is named by a potentially-evaluated expression.]{.addu}
+
 :::
 
 Prepend before paragraph 15 of [basic.def.odr]{.sref}:
@@ -3026,13 +3028,41 @@ Prepend before paragraph 15 of [basic.def.odr]{.sref}:
 ::: std
 
 ::: addu
+[15pre]{.pnum} If a class `C` is defined in a translation unit as a result of a call to a specialization of `std::meta::define_aggregate` and another translation unit contains a definition of `C` that is not a result of calling the same specialization with the same function arguments, the program is ill-formed; a diagnostic is required only if `C` is attached to a named module and a prior definition is reachable at the point where a later definition occurs.
+
+:::
+
+
+[15]{.pnum} For any [other]{.addu} definable item `D` with definitions in multiple translation units,
+
+* if `D` is a non-inline non-templated function or variable, or
+* if the definitions in different translation units do not satisfy the following requirements,
+
+the program is ill-formed; a diagnostic is required only if the definable item is attached to a named module and a prior definition is reachable at the point where a later definition occurs. [...]
+:::
+
+Clarify in bullet 15.11 that default template-arguments in `$splice-specialization-specifier$`s also factor into ODR.
+
+::: std
+- [15.10]{.pnum} In each such definition, the overloaded operators referred to, the implicit calls to conversion functions, constructors, operator new functions and operator delete functions, shall refer to the same function.
+- [15.11]{.pnum} In each such definition, a default argument used by an (implicit or explicit) function call or a default template argument used by an (implicit or explicit) `$template-id$`[,]{.addu} [or]{.rm} `$simple-template-id$`[, or `$splice-specialization-specifier$`]{.addu} is treated as if its token sequence were present in the definition of `$D$`; that is, the default argument or default template argument is subject to the requirements described in this paragraph (recursively).
+
+:::
+
+
+### [basic.lookup.general]{.sref} General {-}
+
+Modify paragraph 1 to cross-reference to the new definition of "overload set" given in [over.pre], rather than define it here.
 
-[15pre]{.pnum} If a class `C` is defined in a translation unit with a call to a specialization of `std::meta::define_aggregate`, every definition of that class shall be the result of a call to the same specialization; and for every reflection in the range of reflections describing its class members and unnamed bit-fields, every other such call shall have a corresponding value, occupying the same position in its respective range, to which the reflection compares equal.
+::: std
+[1]{.pnum} [...] If the declarations found by name lookup all denote functions or function templates, the declarations [are said to]{.rm} form an [_overload set_]{.rm} [overload set ([over.pre]{.sref})]{.addu}. Otherwise, [...]
 
 :::
 
+Adjust the definition in p2 of when a program point follows a declaration to account for the removal of instantiation units.
 
-[15]{.pnum} [Otherwise, for]{.addu} [For]{.rm} any definable item D with definitions ...
+::: std
+[2]{.pnum} A program point `$P$` is said to follow any declaration [with which it is instantiation-sequenced ([lex.phases]{.sref})]{.addu} [in the same translation unit]{.rm} whose locus ([basic.scope.pdecl]{.sref}) is before `$P$`.
 :::
 
 ### [basic.lookup.argdep]{.sref} Argument-dependent name lookup {-}
@@ -3043,7 +3073,11 @@ Modify the first bullet of paragraph 3 of [basic.lookup.argdep]{.sref} as follow
 
 [3]{.pnum} ... Any `$typedef-name$`s and `$using-declaration$`s used to specify the types do not contribute to this set. The set of entities is determined in the following way:
 
-* [[#.#]{.pnum} If `T` is `std::meta::info`, its associated set of entities is the singleton containing the function `std::meta::is_type`.]{.addu} If `T` is [a]{.rm} [any other]{.addu} fundamental type, its associated set of entities is empty.
+* [[#.#]{.pnum} If `T` is `std::meta::info` ([meta.reflection.synop]), its associated set of entities is the singleton containing the enumeration type `std::meta::operators` ([meta.reflection.operators]).]{.addu}
+
+  [[The `std::meta::info` type is a type alias, so an explicit rule is needed to associate calls whose arguments are reflections with the namespace `std::meta`.]{.note}]{.addu}
+
+* [#.#]{.pnum} If `T` is [a]{.rm} [any other]{.addu} fundamental type, its associated set of entities is empty.
 * [#.#]{.pnum} If `T` is a class type ...
 
 :::
@@ -3053,10 +3087,52 @@ Modify the first bullet of paragraph 3 of [basic.lookup.argdep]{.sref} as follow
 Extend paragraph 1 to cover `$splice-specifier$`s:
 
 ::: std
-[1]{.pnum} Lookup of an *identifier* followed by a `::` scope resolution operator considers only namespaces, types, and templates whose specializations are types. If a name, `$template-id$`, [`$splice-specifier$`,]{.addu} or `$computed-type-specifier$` is followed by a `::`, it shall designate a namespace, class, enumeration, [dependent `$splice-specifier$`,]{.addu} or dependent type, and the `::` is never interpreted as a complete nested-name-specifier.
+[1]{.pnum} Lookup of an *identifier* followed by a `::` scope resolution operator considers only namespaces, types, and templates whose specializations are types. If a name, `$template-id$`, [`$splice-scope-specifier$`,]{.addu} or `$computed-type-specifier$` is followed by a `::`, it shall [either be a dependent `$splice-scope-specifier$` ([temp.dep.splice]) or it shall]{.addu} designate a namespace, class, enumeration, or dependent type, and the `::` is never interpreted as a complete nested-name-specifier.
 
 :::
 
+### 6.5+ [basic.splice] Splice specifiers {-}
+
+Add a new subsection after [basic.lookup]{.sref}, and renumber accordingly:
+
+::: std
+::: addu
+**Splice specifiers   [basic.splice]**
+
+```
+$splice-specifier$:
+  [: $constant-expression$ :]
+
+$splice-specialization-specifier$:
+  $splice-specifier$ < $template-argument-list$@~_opt_~@ >
+```
+
+[1]{.pnum} The `$constant-expression$` of a `$splice-specifier$` shall be a converted constant expression ([expr.const]) contextually convertible to `std::meta::info`. A `$splice-specifier$` _designates_ the construct represented by the converted `$constant-expression$`.
+
+  [A `$splice-specifier$` is dependent if the converted `$constant-expression$` is value-dependent ([temp.dep.splice]).]{.note}
+
+[#]{.pnum} The `$splice-specifier$` of a non-dependent `$splice-specialization-specifier$` shall designate a template.
+
+[#]{.pnum} [A `<` following a `$splice-specifier$` is interpreted as the delimiter of a `$template-argument-list$` when the `$splice-specifier$` is preceded by `typename` or `template`, or when it appears in a type-only context ([temp.names]{.sref}).]{.note}
+
+::: example
+```cpp
+constexpr int v = 1;
+template <int V> struct TCls {
+  static constexpr int s = V + 1;
+};
+
+using alias = [:^^TCls:]<[:^^v:]>;
+  // OK, a splice-specialization-specifier with a splice-specifier
+  // as a template argument
+
+static_assert(alias::s == 2);
+```
+:::
+
+:::
+:::
+
 ### [basic.link]{.sref} Program and Linkage {-}
 
 Add a bullet to paragraph 13:
@@ -3066,27 +3142,27 @@ Add a bullet to paragraph 13:
 [13]{.pnum} A declaration `$D$` _names_ an entity `$E$` if
 
 * [13.1]{.pnum} `$D$` contains a `$lambda-expression$` whose closure type is `$E$`,
-* [13.1+]{.pnum} [`$D$` contains a reflection that represents either `$E$` or a `$typedef-name$` or `$namespace-alias$` that denotes `$E$`,]{.addu}
-* [13.2]{.pnum} `$E$` is not a function or function template and `$D$` contains an *id-expression*, *type-specifier*, *nested-name-specifier*, *template-name*, or *concept-name denoting* `$E$`, or
-* [13.#]{.pnum} `$E$` is a function or function template and `$D$` contains an expression that names `$E$` ([basic.def.odr]) or an *id-expression* that refers to a set of overloads that contains `$E$`.
+* [13.1+]{.pnum} [`$D$` contains an expression of type `std::meta::info` that represents either `$E$` or a type alias or namespace alias that denotes `$E$`,]{.addu}
+* [13.2]{.pnum} `$E$` is not a function or function template and `$D$` contains an `$id-expression$`, `$type-specifier$`, `$nested-name-specifier$`, `$template-name$`, or `$concept-name$` denoting `$E$`, or
+* [13.#]{.pnum} `$E$` is a function or function template and `$D$` contains an expression that names `$E$` ([basic.def.odr]) or an `$id-expression$` that refers to a set of overloads that contains `$E$`.
 
 :::
 
 [The below addition of "value or object of a TU-local type" is in part a drive-by fix to make sure that enumerators in a TU-local enumeration are also TU-local]{.ednote}
 
-Extend the definition of _TU-local_ values and objects to include reflections:
+Extend the definition of _TU-local_ values and objects in p16 to include reflections:
 
 ::: std
 
-[16]{.pnum} A value or object is _TU-local_ if either
+[16]{.pnum} A value or object is _TU-local_ if
 
+* [[16.0]{.pnum} it is of TU-local type,]{.addu}
 * [16.1]{.pnum} it is, or is a pointer to, a TU-local function or the object associated with a TU-local variable, [or]{.rm}
 
 :::addu
-* [16.1a]{.pnum} it is a value or object of a TU-local type,
-* [16.1b]{.pnum} it is a reflection representing
-  * [16.1b.#]{.pnum} a TU-local value or object, or
-  * [16.1b.#]{.pnum} a `$typedef-name$`, `$namespace-alias$`, or `$base-specifier$` introduced by an exposure, or
+* [16.1+]{.pnum} it is a reflection representing either
+  * [16.1+.#]{.pnum} a TU-local value or object, or
+  * [16.1+.#]{.pnum} a `$typedef-name$`, `$namespace-alias$`, or `$base-specifier$` introduced by an exposure, or
 :::
 * [16.2]{.pnum} it is an object of class or array type and any of its subobjects or any of the objects or functions to which its non-static data members of reference type refer is TU-local and is usable in constant expressions.
 
@@ -3097,7 +3173,7 @@ Extend the definition of _TU-local_ values and objects to include reflections:
 Change the first sentence in paragraph 9 of [basic.types.general]{.sref} as follows:
 
 ::: std
-[9]{.pnum} Arithmetic types (6.8.2), enumeration types, pointer types, pointer-to-member types (6.8.4), [`std::meta::info`,]{.addu} `std::nullptr_t`, and cv-qualified (6.8.5) versions of these types are collectively called scalar types.
+[9]{.pnum} Arithmetic types ([basic.fundamental]{.sref}), enumeration types, pointer types, pointer-to-member types ([basic.compound]{.sref}), [`std::meta::info`,]{.addu} `std::nullptr_t`, and cv-qualified versions of these types are collectively called scalar types. ...
 :::
 
 Add a new paragraph at the end of [basic.types.general]{.sref} as follows:
@@ -3105,16 +3181,7 @@ Add a new paragraph at the end of [basic.types.general]{.sref} as follows:
 ::: std
 ::: addu
 
-[12]{.pnum} A *consteval-only type* is one of the following:
-
-  - [#.#]{.pnum} `std::meta::info`, or
-  - [#.#]{.pnum} a pointer or reference to a consteval-only type,
-  - [#.#]{.pnum} a (possibly multi-dimensional) array of a consteval-only type,
-  - [#.#]{.pnum} a class type with a base class or non-static data member of consteval-only type,
-  - [#.#]{.pnum} a function type with a return type or parameter type of consteval-only type, or
-  - [#.#]{.pnum} a pointer-to-member type to a class `C` of type `M` where either `C` or `M` is a consteval-only type.
-
-[13]{.pnum} Every object of consteval-only type shall be
+[12]{.pnum} A type is _consteval-only_ if it is either `std::meta::info` or a type compounded from a consteval-only type ([basic.compound]). Every object of consteval-only type shall be
 
   - [#.#]{.pnum} the object associated with a constexpr variable or a subobject thereof,
   - [#.#]{.pnum} a template parameter object ([temp.param]{.sref}) or a subobject thereof, or
@@ -3132,137 +3199,138 @@ Add a new paragraph before the last paragraph of [basic.fundamental]{.sref} as f
 
 [17 - 1]{.pnum} A value of type `std::meta::info` is called a _reflection_. There exists a unique _null reflection_; every other reflection is a representation of
 
-* a value with structural type ([temp.param]),
+* a value of structural type ([temp.param]{.sref}),
 * an object with static storage duration,
 * a variable,
 * a structured binding,
 * a function,
 * an enumerator,
-* a type or `$typedef-name$`,
+* a `$typedef-name$`,
+* a type,
 * a class member,
-* a bit-field,
-* a primary class template, function template, primary variable template, alias template, or concept,
-* a namespace or `$namespace-alias$`,
-* a `$base-specifier$`,
-* a description of a declaration of a non-static data member, or
-* an implementation-defined construct not otherwise specified by this document.
+* an unnamed bit-field,
+* a primary class template,
+* a function template,
+* a primary variable template,
+* an alias template,
+* a concept,
+* a `$namespace-alias$`,
+* a namespace,
+* a `$base-specifier$`, or
+* a description of a declaration of a non-static data member ([meta.reflection.define.aggregate]).
 
 An expression convertible to a reflection is said to _represent_ the corresponding construct. `sizeof(std::meta::info)` shall be equal to `sizeof(void*)`.
 
-[17 - 2]{.pnum} _Recommended practice_: Implementations are discouraged from representing any constructs described by this document that are not explicitly enumerated in the list above (e.g., partial template specializations, attributes, placeholder types, statements).
+::: example
+```cpp
+int arr[] = {1, 2, 3};
+auto [a1, a2, a3] = arr;
+void fn();
+enum Enum { A };
+using Alias = int;
+struct B {};
+struct S : B {
+  int mem;
+  int : 0;
+};
+template <auto> struct TCls {};
+template <auto> void TFn();
+template <auto> int TVar;
+template <auto> concept Concept = requires { true; };
+namespace NS {};
+namespace NSAlias = NS;
 
-:::
-:::
+constexpr auto r1 = std::meta::reflect_value(42);  // represents int value of 42
 
-### [expr.prim]{.sref} Primary expressions {-}
+constexpr auto r2 = std::meta::reflect_object(arr[1]);  // represents int object
 
-Change the grammar for `$primary-expression$` in [expr.prim]{.sref} as follows:
+constexpr auto r3 = ^^arr;      // represents a variable
+constexpr auto r4 = ^^a3;       // represents a structured binding
+constexpr auto r5 = ^^fn;       // represents a function
+constexpr auto r6 = ^^Enum::A;  // represents an enumerator
+constexpr auto r7 = ^^Alias;    // represents a typedef-name
+constexpr auto r8 = ^^S;        // represents a type
+constexpr auto r9 = ^^S::mem;   // represents a class member
 
-::: std
-```diff
-  $primary-expression$:
-     $literal$
-     this
-     ( $expression$ )
-     $id-expression$
-     $lambda-expression$
-     $fold-expression$
-     $requires-expression$
-+    $splice-expression$
-```
-:::
+constexpr auto r10 = std::meta::members_of(^^S)[1];
+    // represents an unnamed bit-field
 
-### 7.5.4.0* [expr.prim.id.splice] Splice specifiers {-}
+constexpr auto r11 = ^^TCls;     // represents a class template
+constexpr auto r12 = ^^TFn;      // represents a function template
+constexpr auto r13 = ^^TVar;     // represents a variable template
+constexpr auto r14 = ^^Concept;  // represents a concept
+constexpr auto r15 = ^^NSAlias;  // represents a namespace-alias
+constexpr auto r16 = ^^NS;       // represents a namespace
 
-Add a new vocabulary of nonterminals for various forms of splicers:
+constexpr auto r17 = std::meta::bases_of(^^S)[0];
+    // represents a base-specifier
 
-::: std
-::: addu
+constexpr auto r18 = std::meta::data_member_spec(^^int, {.name="member"});
+    // represents a description of a declaration of a non-static data member.
 ```
-$splice-specifier$:
-  [: $constant-expression$ :]
-
-$splice-expr-template-specifier$:
-	template $splice-specifier$
 
-$splice-type-specifier$:
-	typename@~_opt_~@ template@~_opt_~@ $splice-specifier$
-```
-
-The term _splicer_ generically refers to a `$splice-specifier$`, a `$splice-expr-template-specifier$`, or a `$splice-type-specifier$`.
-
-[1]{.pnum} The `$constant-expression$` of a `$splice-specifier$` shall be a converted constant expression ([expr.const]) contextually convertible to `std::meta::info`. A `$splice-specifier$` designates the construct represented by the converted `$constant-expression$`, and is dependent if the converted `$constant-expression$` is value-dependent.
+:::
 
-[#]{.pnum} A `$splice-expr-template-specifier$` or `$splice-type-specifier$` designates the construct designated by the `$splice-specifier$`. A `$splice-expr-template-specifier$` designates either a function template a primary variable template, or a concept. A `$splice-type-specifier$` designates either a type, `$typedef-name$`, primary class template, alias template, or concept.
+[17 - 2]{.pnum} [Implementations are discouraged from representing any constructs described by this document that are not explicitly enumerated in the list above (e.g., partial template specializations, attributes, placeholder types, statements). Constructs not described by this document can also be represented.]{.note}
 
-[#]{.pnum} The form `template $splice-specifier$` is interpreted as a `$splice-type-specifier$` when
+:::
+:::
 
-* [#.#]{.pnum} it is preceded by `typename`,
-* [#.#]{.pnum} it is within a type-only context,
-* [#.#]{.pnum} it is followed by `auto` or `decltype(auto)`, or
-* [#.#]{.pnum} the `$splice-specifier$` is not dependent and designates a primary class template or alias template.
+### [basic.lval]{.sref} Value category {-}
 
-In all other cases, it is interpreted as a `$splice-expr-template-specifier$`.
+Apply a drive-by fix to bullet 1.1 clarifying that a glvalue can also determine the identity of a non-static data member.
 
-[#]{.pnum} The `typename` in a `$splice-type-specifier$` may only be omitted in a type-only context, or when the `$splice-specifier$` is preceded by `template`.
+::: std
+* [1.1]{.pnum} A _glvalue_ is an expression whose evaluation determines the identity of an object[,]{.addu} [or]{.rm} function[, or non-static data member]{.addu}.
 
-::: example
-```cpp
-int var;
-struct cls {};
-template<int> int t_var = 0;
-template<int> struct t_cls { };
-template <typename> concept always_true = requires { true; };
+:::
 
-template <auto Var, auto Cls, auto TVar, auto TCls, auto Concept>
-void dependent() {
-  [:Var:] *var;                      // OK, multiplication of 'var * var'
+### [expr.context]{.sref} Context dependence {-}
 
-  typename [:Cls:] *a;               // OK, declaration of 'cls *a'
-  template [:TVar:]<0> *var;         // OK, multiplication of 't_var<0> * var'
-  template [:TCls:]<0> *var;         // error: cannot splice type as expression
-  typename [:TCls:]<0> *b;           // OK, declaration of 't_cls<0> *b'
-  typename template [:TCls:]<0> *c;  // OK
+Add `$reflect-expression$`s to the list of unevaluated operands in paragraph 1.
 
-  template [:Concept:] auto d = 0;   // OK, deduced placeholder type
+::: std
+[1]{.pnum} In some contexts, _unevaluated operands_ appear ([expr.prim.req], [expr.typeid], [expr.sizeof], [expr.unary.noexcept], [[expr.reflect],]{.addu} [temp.pre], [temp.concept]). An unevaluated operand is not evaluated.
 
-  [:Cls:]::k = 1;                    // OK
-  typename [:TCls:]<1>::type var;    // OK, 'typename' binds to 'type'.
-};
+:::
 
-void non_dependent() {
-  dependent<^^var, ^^cls, ^^t_var, ^^t_cls, ^^always_true>();
+### [expr.prim]{.sref} Primary expressions {-}
 
-  template [:^^t_cls:]<0> *var1;  // OK, non-dependent context
-  [:^^t_cls:]<0> *var2;           // error: interpreted as multiplication.
-};
+Change the grammar for `$primary-expression$` in [expr.prim]{.sref} as follows:
 
+::: std
+```diff
+  $primary-expression$:
+     $literal$
+     this
+     ( $expression$ )
+     $id-expression$
+     $lambda-expression$
+     $fold-expression$
+     $requires-expression$
++    $splice-expression$
 ```
 :::
 
-:::
-:::
-
 ### [expr.prim.id.general]{.sref} General {-}
 
-Add a carve-out for reflection in [expr.prim.id.general]{.sref}/4. Adjust the wording to reflect the fact that a `$reflect-expression$` operand is not formally an `$id-expression$`:
+Modify paragraph 2 to avoid transforming non-static members into implicit member accesses when named as operands to `$reflect-expression$`s.
 
 ::: std
-[4]{.pnum} [An `$id-expression$` that denotes a]{.rm} [A]{.addu} non-static data member or implicit object member function of a class can only be [used]{.rm} [denoted]{.addu}:
+[2]{.pnum} If an `$id-expression$` `$E$` denotes a non-static non-type member of some class `C` at a point where the current class ([expr.prim.this]{.sref}) is `X` and
 
-* [4.#]{.pnum} as part of a class member access (after any implicit transformation (see above)) in which the object expression refers to the member's class or a class derived from that class, or
+* [#.#]{.pnum} `$E$` is potentially evaluated or `C` is `X` or a base class of `X`, and
+* [#.#]{.pnum} `$E$` is not the `$id-expression$` of a class member access expression ([expr.ref]{.sref}), and
+* [[#.#]{.pnum} `$E$` is not the `$id-expression$` of a `$reflect-expression$` ([expr.reflect]), and]{.addu}
+* [#.#]{.pnum} if `$E$` is a `$qualified-id$`, `$E$` is not the un-parenthesized operand of the unary `&` operator ([expr.unary.op]{.sref}),
 
-::: addu
-* [4.#]{.pnum} by the operand of a `$reflect-expression$` ([expr.reflect]), or
-:::
+the `$id-expression$` is transformed into a class member access expression using `(*this)` as the object expression.
 
-* [4.#]{.pnum} to form a pointer to member ([expr.unary.op]), or
-* [4.#]{.pnum} [if that]{.rm} [by an]{.addu} `$id-expression$` [denotes]{.rm} [denoting]{.addu} a non-static data member [and it appears]{.rm} in an unevaluated operand.
 :::
 
 ### [expr.prim.id.qual]{.sref} Qualified names {-}
 
-Add a production to the grammar for `$nested-name-specifier$` as follows:
+Extend the grammar for `$nested-name-specifier$` as follows:
 
 ::: std
 ```diff
@@ -3270,24 +3338,44 @@ Add a production to the grammar for `$nested-name-specifier$` as follows:
       ::
       $type-name$ ::
       $namespace-name$ ::
-+     $splice-specifier$ ::
       $computed-type-specifier$ ::
++     $splice-scope-specifier$ ::
       $nested-name-specifier$ $identifier$ ::
       $nested-name-specifier$ template@~_opt_~@ $simple-template-id$ ::
++
++  $splice-scope-specifier$:
++     $splice-specifier$
++     template@~_opt_~@ $splice-specialization-specifier$
 ```
 :::
 
-Add a new paragraph restricting `$splice-specifier$`, and renumber accordingly:
+Add a paragraph after paragraph 1 specifying the rules for parsing a `$splice-scope-specifier$`, as well as an example:
 
 ::: std
 ::: addu
-[0]{.pnum} The `$splice-specifier$` of a `$nested-name-specifier$`, if any, shall either be dependent or designate a class, a `$typedef-name$` denoting a class, a namespace, or a `$namespace-alias$`.
-:::
+[1+]{.pnum} A `$splice-specifier$` or `$splice-specialization-specifier$` that is not followed by `::` is never interpreted as part of a `$splice-scope-specifier$`. The `template` may only be omitted from the form `template@~_opt_~@ $splice-specialization-specifier$ ::` when the `$splice-specialization-specifier$` is preceded by `typename`.
+
+::: example
+```cpp
+template <int V>
+struct TCls {
+  static constexpr int s = V;
+  using type = int;
+};
+
+constexpr int v1 = [:^^TCls<1>:]::s;
+constexpr int v2 = template [:^^TCls:]<2>::s;
+  // OK, template binds to splice-scope-specifier
+
+constexpr typename [:^^TCls:]<3>::type v3 = 3;
+  // OK, typename binds to the qualified name
+```
 
-[1]{.pnum} The component names of a `$qualified-id$` are [...]
+:::
+:::
 :::
 
-Clarify that a splice cannot appear in a declarative `$nested-name-specifier$`:
+Clarify in paragraph 2 that a splice cannot appear in a declarative `$nested-name-specifier$`:
 
 ::: std
 [2]{.pnum} A `$nested-name-specifier$` is _declarative_ if it is part of
@@ -3297,15 +3385,23 @@ Clarify that a splice cannot appear in a declarative `$nested-name-specifier$`:
 * a `$qualified-id$` that is the `$id-expression$` of a `$declarator-id$`, or
 * a declarative `$nested-name-specifier$`.
 
-A declarative `$nested-name-specifier$` shall not have a `$computed-type-specifier$` [or a `$splice-specifier$`]{.addu}. A declaration that uses a declarative `$nested-name-specifier$` shall be a friend declaration or inhabit a scope that contains the entity being redeclared or specialized.
+A declarative `$nested-name-specifier$` shall not have a `$computed-type-specifier$` [or a `$splice-scope-specifier$`]{.addu}. A declaration that uses a declarative `$nested-name-specifier$` shall be a friend declaration or inhabit a scope that contains the entity being redeclared or specialized.
 :::
 
-Extend the next paragraph to also cover splices, and prefer the verb "designate" over "nominate":
+Break the next paragraph into a bulleted list, extend it to also cover splices, and prefer the verb "designate" over "nominate":
 
 ::: std
-[3]{.pnum} The `$nested-name-specifier$` `::` [nominates]{.rm} [designates]{.addu} the global namespace. A `$nested-name-specifier$` with a `$computed-type-specifier$` [nominates]{.rm} [designates]{.addu} the type denoted by the `$computed-type-specifier$`, which shall be a class or enumeration type. [A `$nested-name-specifier$` with a `$splice-specifier$` that designates an entity itself designates the same entity. A `$nested-name-specifier$` with a `$splice-specifier$` that designates a name itself designates the entity nominated by that name.]{.addu} If a `$nested-name-specifier$` _N_ is declarative and has a `$simple-template-id$` with a template argument list _A_ that involves a template parameter, let _T_ be the template [nominated]{.rm} [designated]{.addu} by _N_ without _A_. _T_ shall be a class template.
+[3]{.pnum} [The entity designated by a `$nested-name-specifier$` is determined as follows:]{.addu}
 
-...
+  - [#.#]{.pnum} The `$nested-name-specifier$` `::` [nominates]{.rm} [designates]{.addu} the global namespace.[\ ]{.addu}
+  - [#.#]{.pnum} A `$nested-name-specifier$` with a `$computed-type-specifier$` [nominates]{.rm} [designates]{.addu} the [same]{.addu} type [denoted]{.rm} [designated]{.addu} by the `$computed-type-specifier$`, which shall be a class or enumeration type.[\ ]{.addu}
+  - [[#.#]{.pnum} For a `$nested-name-specifier$` of the form `$splice-specifier$ ::`, the `$splice-specifier$` shall designate a class or enumeration type, a type alias denoting such a type, a namespace, or a namespace alias. If the `$splice-specifier$` designates a type alias or a namespace alias, the `$nested-names-specifier$` designates the type or namespace denoted by that entity. Otherwise, the `$nested-name-specifier$` designates the same entity as the `$splice-specifier$`.]{.addu}
+  - [[#.#]{.pnum} For a `$nested-name-specifier$` of the form `template@~_opt_~@ $splice-specialization-specifier$ ::`, the `$splice-specifier$` of the `$splice-specialization-specifier$` shall designate a primary class template or an alias template `$T$`. Letting `$S$` be the specialization of `$T$` corresponding to the `$template-argument-list$` (if any) of the `$splice-specialization-specifier$`, `$S$` shall either be a class template specialization or an alias template specialization that denotes a class or enumeration type. The `$nested-name-specifier$` designates `$S$` if `$T$` is a class template or the type denoted by `$S$` if `$T$` is an alias template.]{.addu}
+  - [#.#]{.pnum} If a `$nested-name-specifier$` _N_ is declarative and has a `$simple-template-id$` with a template argument list _A_ that involves a template parameter, let _T_ be the template [nominated]{.rm} [designated]{.addu} by _N_ without _A_. _T_ shall be a class template.
+    - [#.#.#]{.pnum} If `$A$` is the template argument list ([temp.arg]{.sref}) of the corresponding `$template-head$` `$H$` ([temp.mem]{.sref}), `$N$` nominates the primary template of `$T$`; `$H$` shall be equivalent to the `$template-head$` of `$T$` ([temp.over.link]{.sref}).
+    - [#.#.#]{.pnum} Otherwise, `$N$` nominates the partial specialization ([temp.spec.partial]{.sref}) of `$T$` whose template argument list is equivalent to `$A$` ([temp.over.link]{.sref}); the program is ill-formed if no such partial specialization exists.
+  
+  - [#.#]{.pnum} Any other `$nested-name-specifier$` [nominates]{.rm} [designates]{.addu} the [same]{.addu} entity [denoted]{.rm} [designated]{.addu} by its `$type-name$`, `$namespace-name$`, `$identifier$`, or `$simple-template-id$`. If the `$nested-name-specifier$` is not declarative, the entity shall not be a template.
 
 :::
 
@@ -3320,28 +3416,59 @@ Add a new subsection of [expr.prim]{.sref} following [expr.prim.req]{.sref}
 ```
 $splice-expression$:
    $splice-specifier$
+   template $splice-specialization-specifier$
 ```
 
-[#]{.pnum} The `$splice-specifier$` shall designate either
+[#]{.pnum} A `$splice-specifier$` or `$splice-specialization-specifier$` immediately followed by `::` or preceded by `typename` is never interpreted as part of a `$splice-expression$`.
 
-* [#.#]{.pnum} a value or object,
-* [#.#]{.pnum} a variable,
-* [#.#]{.pnum} a structured binding,
-* [#.#]{.pnum} a function other than a constructor or destructor,
-* [#.#]{.pnum} an enumerator, or
-* [#.#]{.pnum} a non-static data member.
+::: example
+```cpp
+struct S { static constexpr int a = 1; };
+template <typename> struct TCls { static constexpr int b = 2; };
+
+constexpr int c = [:^^S:]::a;                   // [:^^S:] is not an expression
+
+constexpr int d = template [:^^TCls:]<int>::b;  // template [:^^TCls:]<int> is not
+                                                // an expression
+
+template <auto V> constexpr int e = [:V:];   // splice-expression
+constexpr int f = template [:^^e:]<^^S::a>;  // splice-expression
+```
+
+:::
+
+[#]{.pnum} For a `$splice-expression$` of the form `$splice-specifier$`, let `$S$` be the construct designated by `$splice-specifier$`.
+
+* [#.#]{.pnum} If `$S$` is an object, a function, or a non-static data member, the expression is an lvalue designating `$S$`. The expression has the same type as `$S$`, and is a bit-field if and only if `$S$` is a bit-field.
+
+* [#.#]{.pnum} Otherwise, if `$S$` is a variable or a structured binding, `$S$` shall either have static or thread storage duration or shall inhabit a scope enclosing the expression. The expression is an lvalue referring to the object or function `$X$` associated with or referenced by `$S$`, has the same type as `$S$`, and is a bit-field if and only if `$X$` is a bit-field.
+
+  [The type of a `$splice-expression$` designating a variable or structured binding of reference type will be adjusted to a non-reference type ([expr.type]{.sref}).]{.note}
+
+* [#.#]{.pnum} Otherwise, if `$S$` is a value or an enumerator, the expression is a prvalue that computes `$S$` and whose type is the same as `$S$`.
 
-[Unnamed bit-fields are not class members ([class.bit]), and cannot be spliced.]{.note}
+* [#.#]{.pnum} Otherwise, the expression is ill-formed.
 
-[#]{.pnum} Let `$E$` be the construct designated by `$splice-specifier$`.
+[#]{.pnum} For a `$splice-expression$` of the form `template $splice-specialization-specifier$`, the `$splice-specifier$` of the `$splice-specialization-specifier$` shall designate a template. Let `$T$` be that template and let `$S$` be the specialization of `$T$` corresponding to the `$template-argument-list$` (if any) of the `$splice-specialization-specifier$`.
 
-* [#.#]{.pnum} If `$E$` is an object, a function, or a non-static data member, the expression is an lvalue designating `$E$`. The expression has the same type as `$E$`, and is a bit-field if and only if `$E$` is a bit-field.
+* [#.#]{.pnum} If `$T$` is a primary variable template or function template, the expression is an lvalue referring to the same object or function associated with `$S$`. The expression has the same type as `$S$`.
 
-* [#.#]{.pnum} Otherwise, if `$E$` is a variable or a structured binding, the expression is an lvalue designating the object associated with `$E$`. The expression has the same type as `$E$`, and is a bit-field if and only if `$E$` is a bit-field.
+* [#.#]{.pnum} Otherwise, if `$T$` is a concept, the expression is a prvalue that computes the same boolean value as the `$concept-id$` formed by `$S$`.
 
-* [#.#]{.pnum} Otherwise, `$E$` shall be a value or an enumerator. The expression is a prvalue whose evaluation computes `$E$` and whose type is the same as `$E$`.
+* [#.#]{.pnum} Otherwise, the expression is ill-formed.
 
 [Access checking of class members occurs during lookup, and therefore does not pertain to splicing.]{.note}
+
+[#]{.pnum} A `$splice-expression$` that designates a non-static data member or implicit object member function of a class can only be used:
+
+* [#.#]{.pnum} as part of a class member access in which the object expression refers to the member's class or a class derived from that class,
+* [#.#]{.pnum} to form a pointer to member ([expr.unary.op]{.sref}), or
+* [#.#]{.pnum} if that `$splice-expression$` denotes a non-static data member and it appears in an unevaluated operand.
+
+[The implicit transformation ([expr.prim.id]{.sref}) whereby an `$id-expression$` denoting a non-static member becomes a class member access does not apply to a `$splice-expression$`.]{.note}
+
+[#]{.pnum} For a `$splice-expression$` that designates a function or function template, overload resolution is performed ([over.match]{.sref}, [temp.over]{.sref}) from an initial set of candidate functions containing only that entity designated by the `$splice-expression$`. The best viable function selected by overload resolution is considered to be designated in a manner exempt from access rules.
+
 :::
 :::
 
@@ -3356,19 +3483,17 @@ Add a production to `$postfix-expression$` for splices in member access expressi
     ...
     $postfix-expression$ . $template$@~_opt_~@ $id-expression$
 +   $postfix-expression$ . $splice-expression$
-+   $postfix-expression$ . $splice-expr-template-specifier$
     $postfix-expression$ -> $template$@~_opt_~@ $id-expression$
 +   $postfix-expression$ -> $splice-expression$
-+   $postfix-expression$ -> $splice-expr-template-specifier$
 ```
 :::
 
 ### [expr.ref]{.sref} Class member access {-}
 
-Modify paragraph 1 to account for splices in member access expressions. Prefer the word "possibly" to "optionally" since `template` cannot precede a `splice-expression`:
+Modify paragraph 1 to account for splices in member access expressions:
 
 ::: std
-[1]{.pnum} A postfix expression followed by a dot `.` or an arrow `->`, [optionally]{.rm} [possibly]{.addu} followed by the keyword `template`, and then followed by an `$id-expression$` [or a splicer designating a class member]{.addu}, is a postfix expression.
+[1]{.pnum} A postfix expression followed by a dot `.` or an arrow `->`, optionally followed by the keyword `template`, and then followed by an `$id-expression$` [or a `$splice-expression$`]{.addu}, is a postfix expression.
 
 [If the keyword `template` is used, the following unqualified name is considered to refer to a template ([temp.names]). If a `$simple-template-id$` results and is followed by a `::`, the `$id-expression$` is a `$qualified-id$`.]{.note}
 
@@ -3377,23 +3502,23 @@ Modify paragraph 1 to account for splices in member access expressions. Prefer t
 Modify paragraph 2 to account for splices in member access expressions:
 
 ::: std
-[2]{.pnum} [For the first option,]{.rm} [if]{.rm}[If]{.addu} the [dot is followed by an]{.addu} `$id-expression$` [names]{.rm} [ or splicer designating]{.addu} a static member or an enumerator, the first expression is a discarded-value expression ([expr.context]); if the `$id-expression$` [or splicer designates]{.addu} [names]{.rm} a non-static data member, the first expression shall be a glvalue. [For the second option (arrow), the first expression]{.rm} [A postfix expression followed by an arrow]{.addu} shall be a prvalue having pointer type. The expression `E1->E2` is converted to the equivalent form `(*(E1)).E2`; the remainder of [expr.ref] will address only [the first option (dot)]{.rm} [expressions containing a dot]{.addu}.
+[2]{.pnum} For [the first option, if the]{.rm} [a dot that is followed by an]{.addu} `$id-expression$` [names]{.rm} [ or `$splice-expression$` that designates]{.addu} a static member or an enumerator, the first expression is a discarded-value expression ([expr.context]{.sref}); if the `$id-expression$` [or `$splice-expression$` designates]{.addu} [names]{.rm} a non-static data member, the first expression shall be a glvalue. [For the second option (arrow), the first expression]{.rm} [A postfix expression that is followed by an arrow]{.addu} shall be a prvalue having pointer type. The expression `E1->E2` is converted to the equivalent form `(*(E1)).E2`; the remainder of [expr.ref] will address only [the first option (dot)]{.rm} [the form using a dot]{.addu}.
 :::
 
 Modify paragraph 3 to account for splices in member access expressions:
 
 ::: std
-[3]{.pnum} The postfix expression before the dot is evaluated; the result of that evaluation, together with the `$id-expression$` [or splicer]{.addu}, determines the result of the entire postfix expression.
+[3]{.pnum} The postfix expression before the dot is evaluated; the result of that evaluation, together with the `$id-expression$` [or `$splice-expression$`]{.addu}, determines the result of the entire postfix expression.
 :::
 
 Modify paragraph 4 to account for splices in member access expressions:
 
 ::: std
-[4]{.pnum} Abbreviating [`$postfix-expression$`.`$id-expression$`]{.rm} [`$postfix-expression$.EXPR`, where `EXPR` is the `$id-expression$` or splicer following the dot,]{.addu} as `E1.E2`, `E1` is called the `$object expression$`. [...]
+[4]{.pnum} Abbreviating `$postfix-expression$`.`$id-expression$` [or `$postfix-expression$.$splice-expression$`]{.addu} as `E1.E2`, `E1` is called the `$object expression$`. [...]
 
 :::
 
-Adjust the language in paragraphs 6-9 to account for splicers.
+Adjust the language in paragraphs 6-9 to account for `$splice-expression$`s. Explicitly add a fallback to paragraph 7 that makes other cases ill-formed.
 
 ::: std
 
@@ -3402,15 +3527,17 @@ Adjust the language in paragraphs 6-9 to account for splicers.
 [7]{.pnum} If [the entity designated by]{.addu} `E2` is declared to have type "reference to `T`", then `E1.E2` is an lvalue of type `T`. If `E2` [is]{.rm} [designates]{.addu} a static data member, `E1.E2` designates the object or function to which the reference is bound, otherwise `E1.E2` designates the object or function to which the corresponding reference member of `E1` is bound. Otherwise, one of the following rules applies.
 
 * [#.#]{.pnum} If `E2` [is]{.rm} [designates]{.addu} a static data member and the type of `E2` is `T`, then `E1.E2` is an lvalue; [...]
-* [#.#]{.pnum} If `E2` [is]{.rm} [designates]{.addu} a non-static data member and the type of `E1` is "_cq1_ _vq1_ `X`", and the type of `E2` is "_cq2 vq2_ `T`", [...]. If [the entity designated by]{.addu} `E2` is declared to be a `mutable` member, then the type of `E1.E2` is "_vq12_ `T`". If [the entity designated by]{.addu} `E2` is not declared to be a `mutable` member, then the type of `E1.E2` is "_cq12_ _vq12_ `T`".
+* [#.#]{.pnum} [Otherwise, if]{.addu} [If]{.rm} `E2` [is]{.rm} [designates]{.addu} a non-static data member and the type of `E1` is "_cq1_ _vq1_ `X`", and the type of `E2` is "_cq2 vq2_ `T`", [...]. If [the entity designated by]{.addu} `E2` is declared to be a `mutable` member, then the type of `E1.E2` is "_vq12_ `T`". If [the entity designated by]{.addu} `E2` is not declared to be a `mutable` member, then the type of `E1.E2` is "_cq12_ _vq12_ `T`".
 
-[...]
+* [#.#]{.pnum} [Otherwise, if]{.addu} [If]{.rm} `E2` is an overload set, [...]
 
-* [#.4]{.pnum} If `E` [is]{.rm} [designates]{.addu} a nested type, the expression `E1.E2` is ill-formed.
+* [#.#]{.pnum} [Otherwise, if]{.addu} [If]{.rm} `E2` [is]{.rm} [designates]{.addu} a nested type, the expression `E1.E2` is ill-formed.
 
-* [#.#]{.pnum} If `E2` [is]{.rm} [designates]{.addu} a member enumerator and the type of `E2` is `T`, the expression `E1.E2` is a prvalue of type `T` whose value is the value of the enumerator.
+* [#.#]{.pnum} [Otherwise, if]{.addu} [If]{.rm} `E2` [is]{.rm} [designates]{.addu} a member enumerator and the type of `E2` is `T`, the expression `E1.E2` is a prvalue of type `T` whose value is the value of the enumerator.
 
-[8]{.pnum} If `E2` [is]{.rm} [designates]{.addu} a non-static member [`$M$`]{.addu}, the program is ill-formed if the class of which [`E2`]{.rm} [`$M$`]{.addu} is directly a member is an ambiguous base ([class.member.lookup]) of the naming class ([class.access.base]) of [`E2`]{.rm} [`$M$`]{.addu}.
+* [[#.#]{.pnum} Otherwise, the program is ill-formed.]{.addu}
+
+[8]{.pnum} If `E2` is [an `$id-expression$` denoting]{.addu} a non-static member, the program is ill-formed if the class of which `E2` [is]{.rm} directly [denotes]{.addu} a member is an ambiguous base ([class.member.lookup]{.sref}) of the naming class ([class.access.base]{.sref}) of `E2`.
 
 [9]{.pnum} If [the entity designated by]{.addu} `E2` is a non-static member and the result of `E1` is an object whose type is not similar ([conv.qual]) to the type of `E1`, the behavior is undefined.
 
@@ -3418,7 +3545,7 @@ Adjust the language in paragraphs 6-9 to account for splicers.
 
 ### [expr.unary.general]{.sref} General {-}
 
-Change [expr.unary.general]{.sref} paragraph 1 to add productions for the new operator:
+Add `$reflect-expression$` to the grammar for `$unary-expression$` in paragraph 1:
 
 ::: std
 [1]{.pnum} Expressions with unary operators group right-to-left.
@@ -3453,26 +3580,25 @@ Add a new subsection of [expr.unary]{.sref} following [expr.delete]{.sref}
 ::: addu
 **The reflection operator   [expr.reflect]**
 
-[The following grammar avoids use of `$id-expression$`, even though any operand to an `$id-expression$` can be an operand to a `$reflect-expression$`. The reason is that the operand of a `$reflect-expression$` is not necessarily an expression, as it could name a namespace, class template, type, etc.]{.ednote}
-
 ```
 $reflect-expression$:
    ^^ ::
-   ^^ $unqualified-id$
-   ^^ $qualified-id$
+   ^^ $qualified-namespace-specifier$
+   ^^ $nested-name-specifier$@~_opt_~@ $template-name$
+   ^^ $nested-name-specifier$@~_opt_~@ $concept-name$
    ^^ $type-id$
-   ^^ $pack-index-expression$
+   ^^ $id-expression$
 ```
 
 [#]{.pnum} The unary `^^` operator, called the _reflection operator_, yields a prvalue of type `std::meta::info` ([basic.fundamental]{.sref}).
 
-[#]{.pnum} A `$reflect-expression$` is parsed as the longest possible sequence of tokens that could syntactically form a `$reflect-expression$`.
+[Constructs not described by this document can also be represented by reflections, and can appear as operands of `$reflect-expression$`s.]{.note}
 
-[#]{.pnum}
+[#]{.pnum} A `$reflect-expression$` is parsed as the longest possible sequence of tokens that could syntactically form a `$reflect-expression$`.
 
 ::: example
 ```
-static_assert(is_type(^^int()));    // ^^ applies to the type-id "int()"
+static_assert(std::meta::is_type(^^int()));  // ^^ applies to the type-id "int()"
 
 template<bool> struct X {};
 bool operator<(std::meta::info, X<false>);
@@ -3480,34 +3606,36 @@ consteval void g(std::meta::info r, X<false> xv) {
   r == ^^int && true;    // error: ^^ applies to the type-id "int&&"
   r == ^^int & true;     // error: ^^ applies to the type-id "int&"
   r == (^^int) && true;  // OK
-  r == ^^int &&&& true;  // OK
-  ^^X < xv;              // error: < starts template argument list
+  r == ^^int &&&& true;  // error: 'int &&&&' is not a valid type
+  ^^X < xv;              // OK
   (^^X) < xv;            // OK
 }
 
-
 ```
 :::
 
-[#]{.pnum} A `$reflect-expression$` having the form `^^ ::` computes a reflection of the global namespace.
+[#]{.pnum} A `$reflect-expression$` that could be validly interpreted as `^^ $template-name$` is never interpreted as `^^ $id-expression$`, and is interpreted as `^^ $type-id$` if and only if the operand refers to the current instantiation ([temp.dep.type]).
+
+[#]{.pnum} A `$reflect-expression$` of the form `^^ ::` represents the global namespace. A `$reflect-expression$` of the form `^^ $qualified-namespace-specifier$` represents the denoted namespace or namespace alias.
 
-[#]{.pnum} A `$reflect-expression$` having the form `^^ $unqualified-id$` or `^^ $qualified-id$` performs name lookup for the operand following `^^` and computes a result as follows:
+[#]{.pnum} A `$reflect-expression$` of the form `^^ $nested-name-specifier$@~_opt_~@ $template-name$` represents the primary class template, function template, primary variable template, or alias template denoted by `$template-name$`.
 
-* [#.#]{.pnum} If the lookup finds an overload set `$S$` such that the initialization of an invented variable of type `const auto` ([dcl.type.auto.deduct]{.sref}) with `&$S$` would select a unique candidate function `$F$` from `$S$`, then the result is a reflection of `$F$`. If the lookup finds any other overload set, the program is ill-formed.
+[#]{.pnum} A `$reflect-expression$` of the form `^^ $nested-name-specifier$@~_opt_~@ $concept-name$` represents the concept denoted by `$concept-name$`.
 
-* [#.#]{.pnum} Otherwise, if the lookup finds a `$typedef-name$` or a `$namespace-alias$`, then the result is a reflection of the indicated name.
+[#]{.pnum} A `$reflect-expression$` of the form `^^ $type-id$` is interpreted as follows:
 
-* [#.#]{.pnum} Otherwise, if the lookup finds a non-type template parameter, then the result is a reflection of the result computed by an `$id-expression$` naming the parameter.
+* [#.#]{.pnum} If `$type-id$` denotes a type alias that was introduced by the declaration of a type template parameter, the `$reflect-expression$` represents the type denoted by that type alias.
+* [#.#]{.pnum} Otherwise, the `$reflect-expression$` represents the type or type alias denoted by `$type-id$`.
 
-* [#.#]{.pnum} Otherwise, if the lookup finds a variable, structured binding, function, enumerator, type, non-static member, template, or namespace, then the result is a reflection of the denoted entity.
+[#]{.pnum} A `$reflect-expression$` of the form `^^ $id-expression$` is interpreted as follows:
 
-* [#.#]{.pnum} Otherwise, if the lookup finds an implementation-defined construct not otherwise specified by this document, then the implementation may compute a reflection of the denoted construct.
+  * [#.#]{.pnum} If `$id-expression$` denotes an overload set `$S$` and overload resolution for the expression `&$S$` determines a unique function `$F$` ([over.over]{.sref}), the `$reflect-expression$` represents `$F$`.
 
-* [#.#]{.pnum} Otherwise, the program is ill-formed.
+  * [#.#]{.pnum} Otherwise, if `$id-expression$` denotes a variable, structured binding, enumerator, or non-static data member or member function, the `$reflect-expression$` represents that entity.
 
-[#]{.pnum} A `$reflect-expression$` of the form `^^ $type-id$` computes a reflection of the denoted type. A `$reflect-expression$` that could be validly interpreted as either `^^ $unqualified-id$` or `^^ $type-id$` is interpreted as `^^ $unqualified-id$`, and a `$reflect-expression$` that could be validly interpreted as `^^ $qualified-id$` or `^^ $type-id$` is interpreted as `^^ $qualified-id$`.
+  * [#.#]{.pnum} Otherwise, the `$reflect-expression$` is ill-formed. [This includes `$pack-index-expression$`s and non-type template parameters.]{.note}
 
-[#]{.pnum} A `$reflect-expression$` having the form `^^ $pack-index-expression$` computes a reflection of the result computed by the `$pack-index-expression$`.
+  The `$id-expression$` of a `$reflect-expression$` is an unevaluated operand ([expr.context]{.sref}).
 
 ::: example
 ```cpp
@@ -3515,10 +3643,18 @@ template <typename T> void fn() requires (^^T != ^^int);
 template <typename T> void fn() requires (^^T == ^^int);
 template <typename T> void fn() requires (sizeof(T) == sizeof(int));
 
-constexpr auto R = ^^fn<char>;     // OK
-constexpr auto S = ^^fn<int>;      // error: cannot reflect an overload set
+constexpr auto x = ^^fn<char>;     // OK
+constexpr auto y = ^^fn<int>;      // error: ambiguous
+
+constexpr auto z = ^^std::vector;  // OK
 
-constexpr auto r = ^^std::vector;  // OK
+template <typename T>
+struct S {
+  static constexpr auto r = ^^T;
+  using type = T;
+}
+static_assert(S<int>::r == ^^int);
+static_assert(S<int>::type != ^^int);
 ```
 :::
 
@@ -3528,29 +3664,29 @@ constexpr auto r = ^^std::vector;  // OK
 
 ### [expr.eq]{.sref} Equality Operators {-}
 
-Extend [expr.eq]{.sref}/2 to also handle `std::meta::info`:
+Extend paragraph 2 to also handle `std::meta::info`:
 
 ::: std
 [2]{.pnum} The converted operands shall have arithmetic, enumeration, pointer, or pointer-to-member type, [type `std::meta::info`,]{.addu} or type `std::nullptr_t`. The operators `==` and `!=` both yield `true` or `false`, i.e., a result of type `bool`. In each case below, the operands shall have the same type after the specified conversions have been applied.
 
 :::
 
-Add a new paragraph between [expr.eq]{.sref}/5 and /6:
+Add a new paragraph between paragraphs 5 and 6:
 
 ::: std
 [5]{.pnum} Two operands of type `std::nullptr_t` or one operand of type `std::nullptr_t` and the other a null pointer constant compare equal.
 
 ::: addu
-[*]{.pnum} If both operands are of type `std::meta::info`, comparison is defined as follows:
+[5+]{.pnum} If both operands are of type `std::meta::info`, comparison is defined as follows:
 
-* [*.#]{.pnum} If one operand is a null reflection value, then they compare equal if and only if the other operand is also a null reflection value.
-* [*.#]{.pnum} Otherwise, if one operand represents a `$template-id$` referring to a specialization of an alias template, then they compare equal if and only if the other operand represents the same `$template-id$` ([temp.type]).
-* [*.#]{.pnum} Otherwise, if one operand represents a `$namespace-alias$` or a `$typedef-name$`, then they compare equal if and only if the construct represented by the other operand represents the same kind of construct, shares the same name, is declared within the same enclosing scope, and aliases the same underlying entity.
-* [*.#]{.pnum} Otherwise, if one operand represents a value, then they compare equal if and only if the other operand represents a template-argument-equivalent value ([temp.type]{.sref}).
-* [*.#]{.pnum} Otherwise, if one operand represents an object, then they compare equal if and only if the other operand represents the same object.
-* [*.#]{.pnum} Otherwise, if one operand represents an entity, then they compare equal if and only if the other operand represents the same entity.
-* [*.#]{.pnum} Otherwise, if one operand represents a `$base-specifier$`, then they compare equal if and only if the other operand represents the same `$base-specifier$`.
-* [*.#]{.pnum} Otherwise, both operands `O@~_1_~@` and `O@~_2_~@` represent descriptions of declarations of non-static data members: Let `C@~_1_~@` and `C@~_2_~@` be invented class types such that each `C@~_k_~@` has a single non-static data member having the properties described by `O@~_k_~@`. The operands compare equal if and only if the data members of `C@~_1_~@` and `C@~_2_~@` would be declared with the same type or `$typedef-name$`, name (if any), `$alignment-specifiers$` (if any), width, and attributes.
+* [5+.#]{.pnum} If one operand is a null reflection value, then they compare equal if and only if the other operand is also a null reflection value.
+* [5+.#]{.pnum} Otherwise, if one operand represents a `$typedef-name$` that is a `$simple-template-id$`, then they compare equal if and only if the other operand represents a `$typedef-name$` that is the same `$simple-template-id$` ([temp.type]{.sref}).
+* [5+.#]{.pnum} Otherwise, if one operand represents a `$namespace-alias$` or a `$typedef-name$`, then they compare equal if and only if the construct represented by the other operand represents the same kind of construct, shares the same name, is declared within the same enclosing scope, and aliases the same underlying entity.
+* [5+.#]{.pnum} Otherwise, if one operand represents a value, then they compare equal if and only if the other operand represents a value that is template-argument-equivalent ([temp.type]{.sref}).
+* [5+.#]{.pnum} Otherwise, if one operand represents an object, then they compare equal if and only if the other operand represents the same object.
+* [5+.#]{.pnum} Otherwise, if one operand represents an entity, then they compare equal if and only if the other operand represents the same entity.
+* [5+.#]{.pnum} Otherwise, if one operand represents a `$base-specifier$`, then they compare equal if and only if the other operand represents the same `$base-specifier$`.
+* [5+.#]{.pnum} Otherwise, both operands `O@~_1_~@` and `O@~_2_~@` represent descriptions of declarations of non-static data members: Let `C@~_1_~@` and `C@~_2_~@` be invented class types such that each `C@~_k_~@` has a single non-static data member having the properties described by `O@~_k_~@`. The operands compare equal if and only if the data members of `C@~_1_~@` and `C@~_2_~@` would be declared with the same type or `$typedef-name$`, name (if any), `$alignment-specifier$`s (if any), width, and attributes.
 :::
 
 [6]{.pnum} If two operands compare equal, the result is `true` for the `==` operator and `false` for the `!=` operator. If two operands compare unequal, the result is `false` for the `==` operator and `true` for the `!=` operator. Otherwise, the result of each of the operators is unspecified.
@@ -3562,81 +3698,63 @@ Add a new paragraph between [expr.eq]{.sref}/5 and /6:
 Modify paragraph 15 to disallow returning non-consteval-only pointers and references to consteval-only objects from constant expressions.
 
 ::: std
-[15]{.pnum} A _constant expression_ is either a glvalue core constant expression that [\ ]{.addu}
+[15]{.pnum} A _constant expression_ is either a glvalue core constant expression [`$E$`]{.addu} that [\ ]{.addu}
 
-* [#.#]{.pnum} refers to an entity that is a permitted result of a constant expression[, and]{.addu}
-* [[#.#]{.pnum} is of consteval-only type if the entity designated by the expression is of consteval-only type,]{.addu}
+* [#.#]{.pnum} refers to an [entity]{.rm} [object or function]{.addu} that is a permitted result of a constant expression[, and]{.addu}
+* [[#.#]{.pnum} if `$E$` designates a function of consteval-only type ([basic.types.general]{.sref}) or an object whose complete object is of consteval-only type, then `$E$` is also of consteval-only type,]{.addu}
 
   ::: addu
-  ::: note
-  For example, given the function
+  ::: example
   ```cpp
-  consteval Base& fn(const Derived& derived) {
-    return derived;
-  }
+  struct Base { };
+  struct Derived : Base { std::meta::info r; };
+
+  consteval const Base& fn(const Derived& derived) { return derived; }
+
+  constexpr auto obj = Derived{^^::}; // OK
+  constexpr auto const& d = obj; // OK
+  constexpr auto const& b = fn(obj); // error: not a constant expression
+    // because Derived is a consteval-only type but Base is not.
   ```
 
-  where `Derived` is a consteval-only type, if `Base` is not also a consteval-only type then `fn(derived)` is never a constant expression.
   :::
   :::
 
 or a prvalue core constant expression whose value satisfies the following constraints:
 
-* [#.#]{.pnum} if the value is an object of class type, each non-static data member of reference type refers to an entity that is a permitted result of a constant expression [and has consteval-only type if that entity has consteval-only type]{.addu},
-* [#.#]{.pnum} if the value is an object of scalar type, it does not have an indeterminate or erroneous value ([basic.indet]),
+* [#.#]{.pnum} if the value is an object of class type, each non-static data member of reference type refers to an [entity]{.rm} [object or function]{.addu} that is a permitted result of a constant expression, and if the [object or function is of consteval-only type, or is the subobject of such an object, then so is the value]{.addu},
+* [#.#]{.pnum} if the value is an object of scalar type, it does not have an indeterminate or erroneous value ([basic.indet]{.sref}),
 * [#.#]{.pnum} if the value is of pointer type, [then:\ ]{.addu}
-  * [#.#.#]{.pnum} it is a pointer to an object of static storage duration[,]{.rm} [or]{.addu} a pointer past the end of such an object ([expr.add]), [such that if the type of that object is a consteval-only type then that pointer type is also a consteval-only type, or]{.addu}
-  * [#.#.#]{.pnum} [it is]{.addu} a pointer to a non-immediate function, or
+  * [#.#.#]{.pnum} it is a pointer to an object of static storage duration[,]{.rm} [or]{.addu} a pointer past the end of such an object ([expr.add]{.sref}), [and if the complete object of that object is of consteval-only type then so is that pointer,]{.addu}
+  * [#.#.#]{.pnum} [it is]{.addu} a pointer to a non-immediate function, [and if that function is of consteval-only type then so is that pointer,]{.addu} or
   * [#.#.#]{.pnum} [it is]{.addu} a null pointer value,
-* [#.#]{.pnum} if the value is of pointer-to-member-function type, it does not designate an immediate function, and
+* [#.#]{.pnum} if the value is of pointer-to-member-function type, it does not designate an immediate function, [and if that function is of consteval-only type then so is that value,]{.addu} and
 * [#.#]{.pnum} if the value is an object of class or array type, each subobject satisfies these constraints for the value.
 
 :::
 
-Modify (and clean up) the definition of _immediate-escalating_ to also apply to expressions of consteval-only type.
+Modify (and clean up) the definition of _immediate-escalating_ in paragraph 18 to also apply to expressions of consteval-only type.
 
 ::: std
-[18]{.pnum} A[n]{.rm} [potentially-evaluated]{.addu} expression or conversion is _immediate-escalating_ if it is [not]{.rm} [neither]{.addu} initially in an immediate function context [nor a subexpression of an immediate invocation,]{.addu} and it [is]{.rm} either
+[18]{.pnum} A[n]{.rm} [potentially-evaluated]{.addu} expression or conversion is _immediate-escalating_ if it is [not]{.rm} [neither]{.addu} initially in an immediate function context [nor a subexpression of an immediate invocation,]{.addu} and it is [either]{.rm}
 
-* [#.#]{.pnum} [a potentially-evaluated]{.rm} [is an]{.addu} `$id-expression$` that denotes an immediate function[,]{.addu} [that is not a subexpression of an immediate invocation, or]{.rm}
-* [#.#]{.pnum} [is]{.addu} an immediate invocation that is not a constant expression[, or]{.addu} [and is not a subexpression of an immediate invocation.]{.rm}
-* [[#.#]{.pnum} has consteval-only type ([basic.types.general]).]{.addu}
+* [#.#]{.pnum} [a potentially-evaluated]{.rm} [an]{.addu} `$id-expression$` that denotes an immediate function[,]{.addu} [that is not a subexpression of an immediate invocation, or]{.rm}
+* [#.#]{.pnum} an immediate invocation that is not a constant expression[, or]{.addu} [and is not a subexpression of an immediate invocation.]{.rm}
+* [[#.#]{.pnum} of consteval-only type ([basic.types.general]{.sref}).]{.addu}
 
 :::
 
-Add new paragraphs prior to the definition of _manifestly constant evaluated_ ([expr.const]{.sref}/20), and renumber accordingly:
+Add a new paragraphs prior to the definition of _manifestly constant evaluated_ ([expr.const]{.sref}/21), and renumber accordingly:
 
 ::: std
 ::: addu
 
-[#]{.pnum} An expression or conversion is _plainly constant-evaluated_ if it is
-
-* [#.#]{.pnum} the `$constant-expression$` of a `$static_assert-declaration$` ([dcl.pre]{.sref}), or
-* [#.#]{.pnum} an initializer of a `constexpr` ([dcl.constexpr]{.sref}) or `constinit` ([dcl.constinit]{.sref}) variable.
-
-[A plainly constant-evaluated expression `$E$` is evaluated exactly once, may produce injected declarations (see below), and any such declarations are reachable at a point immediately following `$E$` ([lex.phases]{.sref}).]{.note}
-
-::: example
-```cpp
-template <auto> struct RV {};
-
-// instantiations of 'T::f(0)' are not plainly constant-evaluated
-template <class T> RV<T::f(0)> check(int);
+[21pre]{.pnum} A non-dependent expression or conversion is _plainly constant-evaluated_ if it is not in a complete-class context ([class.mem.general]{.sref}) and is either
 
-consteval int cfn(int) { return 1; }
+* [21pre.#]{.pnum} the `$constant-expression$` of a `$static_assert-declaration$` ([dcl.pre]{.sref}), or
+* [21pre.#]{.pnum} an initializer of a `constexpr` ([dcl.constexpr]{.sref}) or `constinit` ([dcl.constinit]{.sref}) variable.
 
-constexpr int b1 = cfn(1);            // 'cfn(1)' is plainly constant-evaluated
-constinit int b2 = cfn(2);            // 'cfn(2)' is plainly constant-evaluated
-const int b3 = cfn(3);                // 'cfn(3)' is not plainly constant-evaluated
-
-static_assert(b1 > 0);                // 'b1 > 0' is plainly constant-evaluated
-
-struct Cls {
-  static constexpr int var = cfn(4);  // 'cfn(4)' is plainly constant-evaluated
-  int arr[cfn(5)];                    // 'cfn(5)' is not plainly constant-evaluated
-};
-```
-:::
+[The evaluation of a plainly constant-evaluated expression `$E$` can produce injected declarations (see below) and happens exactly once ([lex.phases]{.sref}). Any such declarations are reachable from a point that follows immediately after `$E$`.]{.note}
 
 :::
 :::
@@ -3645,7 +3763,7 @@ Add a note following the definition of _manifestly constant-evaluated_ to clarif
 
 ::: std
 
-[#]{.pnum} An expression or conversion is _manifestly constant-evaluated_ if it is:
+[21]{.pnum} An expression or conversion is _manifestly constant-evaluated_ if it is:
 
 * [#.#]{.pnum} a `$constant-expression$`, or
 * [#.#]{.pnum} the condition of a constexpr if statement ([stmt.if]{.sref}), or
@@ -3654,76 +3772,60 @@ Add a note following the definition of _manifestly constant-evaluated_ to clarif
 * [#.#]{.pnum} the initializer for a variable that is usable in constant expressions or has constant initialization ([basic.start.static]{.sref}).
 
 ::: addu
-[All plainly constant-evaluated expressions are manifestly constant-evaluated, but some manifestly constant-evaluated expressions (e.g., initializers that can require trial evaluations) are not plainly constant-evaluated. Such expressions are still evaluated during translation, but (unlike plainly constant-evaluated expressions) may be evaluated multiple times, and there are no constraints on the relative order of their evaluation.]{.note}
+[All plainly constant-evaluated expressions are manifestly constant-evaluated, but some manifestly constant-evaluated expressions (e.g., template arguments) are not plainly constant-evaluated. Such expressions are still evaluated during translation, but (unlike plainly constant-evaluated expressions) can be evaluated multiple times, and there are no constraints on the relative order of their evaluation.]{.note}
 :::
 
 :::
 
-Add new paragraphs defining _evaluation context_, _injected declaration_, and _injected point_ after the example following the definition of _manifestly constant-evaluated_, and renumber accordingly:
+After the example following the definition of _manifestly constant-evaluated_, introduce new terminology and rules for injecting declarations and renumber accordingly:
 
 ::: std
 ::: addu
 
-[#]{.pnum} The evaluation of an expression `$E$` can introduce an _injected declaration_. For each such declaration `$D$`, the _injected point_ is a corresponding program point which follows the last non-injected point in the translation unit containing `$D$`. The evaluation of `$E$` is said to _produce_ the declaration `$D$`.
+[#]{.pnum} The evaluation of an expression can introduce one or more _injected declarations_. Each such declaration has an associated _injected point_ which follows the last non-injected program point in the translation unit containing that declaration. The evaluation is said to _produce_ the declaration.
 
-[Special rules concerning reachability apply to injected points ([module.reach]).]{.note13}
+[Special rules concerning reachability apply to injected points ([module.reach]{.sref}).]{.note13}
 
-[#]{.pnum} The program is ill-formed if an injected declaration is produced by the evaluation of an expression `$E$` that is
+[#]{.pnum} The program is ill-formed if the evaluation of a manifestly constant-evaluated expression `$M$` produces an injected declaration `$D$` and either
 
-* [#.#]{.pnum} a manifestly constant-evaluated expression that is not plainly constant-evaluated, or
-* within the body of an immediate-escalating function `$F$`, unless `$E$` is a plainly constant-evaluated expression or a subexpression thereof.
-
-[An immediate invocation within an immediate-escalating function is similar to a trial evaluation of a variable initializer: if it fails to be a constant expression, the implementation may be forced to evaluate it again. The above rule is intended to only permit evaluations to produce declarations when such evaluations can be guaranteed to only happen once.]{.note}
+* [#.#]{.pnum} `$M$` is not a plainly constant-evaluated expression, or
+* [#.#]{.pnum} the target scope of `$D$` is not instantiation-sequenced with `$M$` ([lex.phases]).
 
 ::: example
 ```cpp
-consteval bool make_decl(int);      // calling 'make_decl(n)' produces a declaration
-
-template <int R> requires (make_decl(R))
-  bool tfn();
+consteval bool make_decl(int);      // calling 'make_decl(n)' produces an injected
+                                    // declaration in the global namespace
 
 constexpr bool b1 = !make_decl(1);  // OK, constexpr variable so this is plainly
                                     // constant evaluated
 
-bool b2 = !make_decl(2);            // error: initializer !make_decl(42) produced
-                                    // a declaration but is not plainly constant
-                                    // evaluated
+bool b2 = !make_decl(2);
+  // error: initializer !make_decl(42) produced an injected declaration but is
+  // not plainly constant-evaluated
+
+template <int R> requires (make_decl(R))
+  bool tfn();
 
-constexpr bool b3 = tfn<3>();       // error: the invocation of make_decl(R) in the
-                                    // requires clause produced a declaration but is
-                                    // not plainly constant evaluated
+constexpr bool b3 = tfn<3>();
+  // error: the invocation of make_decl(R) in the requires clause produces an
+  // injected declaration but is not plainly constant-evaluated
 
-consteval int *not_constant() {
-  make_decl(4);
-  return new int {};
+template <typename> struct S {
+  static constexpr bool b4 = make_decl(4);
+    // error: target scope of the injected declaration is not
+    // instantatiation-sequenced with the expression
 }
-constexpr bool b4 = [] {
-  int *p = not_constant();          // error: not_constant() produces a declaration
-                                    // in an immediate-escalated function, but is
-                                    // not plainly constant-evaluated.
-  delete p;
-  return true;
-}();
 ```
 :::
 
-[24]{.pnum} The _evaluation context_ is a set of points within the program that determines which declarations are found by certain expressions used for reflection. During the evaluation of a manifestly constant-evaluated expression `$M$`, the evaluation context of an evaluation `$E$` comprises the union of
+[#]{.pnum} The _evaluation context_ is a set of points within the program that determines the behavior of certain functions used for reflection. During the evaluation of a manifestly constant-evaluated expression `$M$`, the evaluation context of an evaluation `$E$` comprises the union of
 
-* [#.#]{.pnum} the instantiation context of `$M$` ([module.context]), and
-* [#.#]{.pnum} the injected points corresponding to any injected declarations ([expr.const]) produced by evaluations sequenced before `$E$` ([intro.execution]).
+- [#.#]{.pnum} the instantiation context of `$M$` ([module.context]{.sref}), and
+- [#.#]{.pnum} the injected points corresponding to any injected declarations produced by evaluations sequenced before `$E$` ([intro.execution]{.sref}).
 
 :::
 :::
 
-### [dcl.typedef]{.sref} The `typedef` specifier {-}
-
-Account for `$splice-type-speciifer$`s in paragraph 3.
-
-::: std
-[3]{.pnum} A `$simple-template-id$` is only a `$typedef-name$` if its `$template-name$` [or `$splice-type-specifier$` designates]{.addu} [names]{.rm} an alias template or a template `$template-parameter$`.
-
-:::
-
 ### [dcl.type.simple]{.sref} Simple type specifiers {-}
 
 Extend the grammar for `$computed-type-specifier$` as follows:
@@ -3737,25 +3839,15 @@ Extend the grammar for `$computed-type-specifier$` as follows:
 ```
 :::
 
-Add a restriction to paragrpah 2 disallowing splicers from appearing after nested name specifiers.
+Extend the definition of "placeholder for a deduced class type" in p3 to accommodate `$splice-type-specifier$`s.
 
 ::: std
-[2]{.pnum} The component names of a `$simple-type-specifier$` are those of its `$nested-name-specifier$`, `$type-name$`, `$simple-template-id$`, `$template-name$`, and/or `$type-constraint$` (if it is a `$placeholder-type-specifier$`). The component name of a `$type-name$` is the first name in it. [The `$simple-template-id$` in a `$type-specifier$` of the form `$nested-name-specifier$ template $simple-template-id$` shall not contain a splicer.]{.addu}
-
-:::
+[3]{.pnum} A `$placeholder-type-specifier$` is a placeholder for a type to be deduced ([dcl.spec.auto]). A `$type-specifier$` [of the form `typename@~_opt_~@ $nested-name-specifier$@~_opt_~@ $template-name$`]{.rm} is a placeholder for a deduced class type ([dcl.type.class.deduct]) [if it either\ ]{.addu}
 
-Indicate that a `$splice-type-specifier$` can be a placeholder for a deduced class type.
+- [[#.#]{.pnum} is of the form `typename@~_opt_~@ $nested-name-specifier$@~_opt_~@ $template-name$`, or]{.addu}
+- [[#.#]{.pnum} is of the form `typename@~_opt_~@ $splice-specifier$` and the `$splice-specifier$` designates a class template or alias template.]{.addu}
 
-::: std
-[3]{.pnum} A `$placeholder-type-specifier$` is a placeholder for a type to be deduced ([dcl.spec.auto]). A `$type-specifier$` [of the form `typename@~_opt_~@ $nested-name-specifier$@~_opt_~@ $template-name$`]{.rm} is a placeholder for a deduced class type ([dcl.type.class.deduct]) [if it]{.addu}
-
-:::addu
-* is of the form `typename@~_opt_~@ $nested-name-specifier$@~_opt_~@ $template-name$`, or
-* consists of a `$splice-type-specifier$` that designates a class template or alias template.
-
-:::
-
-The `$nested-name-specifier$`, if any, shall be non-dependent and the `$template-name$` [or `$splice-type-specifier$`]{.addu} shall [name]{.rm} [designate]{.addu} a deducible template. A _deducible template_ is either a class template or is an alias template whose `$defining-type-id$` is of the form
+The `$nested-name-specifier$`, if any, shall be non-dependent and the `$template-name$` [or `$splice-specifier$`]{.addu} shall [name]{.rm} [designate]{.addu} a deducible template. A _deducible template_ is either a class template or is an alias template whose `$defining-type-id$` is of the form
 
 ```cpp
 typename@~_opt_~@ $nested-name-specifier$@~_opt_~@ template@~_opt_~@ $simple-template-id$
@@ -3777,10 +3869,53 @@ Add a row to [tab:dcl.type.simple] to cover the `$splice-type-specifier$` produc
 |`$pack-index-specifier$`|the type as defined in [dcl.type.pack.index]|
 |`$placeholder-type-specifier$`|the type as defined in [dcl.spec.auto]|
 |`$template-name$`|the type as defined in [dcl.type.class.deduct]|
-|[`$splice-type-specifier$`]{.addu}|[the type as defined in [dcl.type.class.deduct]]{.addu}|
+|[`$splice-type-specifier$`]{.addu}|[the type as defined in [dcl.type.splice]]{.addu}|
 |`...`|...|
 :::
 
+
+### [dcl.type.splice] Type splicing {-}
+
+Add a new subsection of ([dcl.type]{.sref}) following ([dcl.type.class.deduct]{.sref}).
+
+::: std
+::: addu
+**Type Splicing   [dcl.type.splice]**
+
+```
+$splice-type-specifier$:
+   typename@~_opt_~@ $splice-specifier$
+   typename@~_opt_~@ $splice-specialization-specifier$
+```
+
+[#]{.pnum} A `$splice-specifier$` or `$splice-specialization-specifier$` immediately followed by `::` is never interpreted as part of a `$splice-type-specifier$`. A `$splice-specifier$` or `$splice-specialization-specifier$` not preceded by `typename` is only interpreted as a `$splice-type-specifier$` within a type-only context ([temp.res.general]{.sref}).
+
+::: example
+```cpp
+struct S { using type = int; };
+template <auto R> struct TCls {
+  typename [:R:]::type member;  // typename applies to the qualified name
+};
+
+int fn() {
+  [:^^S::type:] *var;           // error: [:^^S::type:] is an expression
+  typename [:^^S::type:] *var;  // OK, declares variable with type int*
+}
+
+using alias = [:^^S::type:];    // OK, type-only context
+```
+:::
+
+[#]{.pnum} For a `$splice-type-specifier$` of the form `typename@~_opt_~@ $splice-specifier$`, the `$splice-specifier$` shall designate a type, a type alias, a primary class template, an alias template, or a concept. The `$splice-type-specifier$` designates the same entity as the `$splice-specifier$`.
+
+[#]{.pnum} For a `$splice-type-specifier$` of the form `typename@~_opt_~@ $splice-specialization-specifier$`, the `$splice-specifier$` of the `$splice-specialization-specifier$` shall designate a primary class template or an alias template. Let `$T$` be that template and let `$S$` be the specialization of `$T$` corresponding to the `$template-argument-list$` (if any) of the `$splice-specialization-specifier$`.
+
+  - [#.#]{.pnum} If `$T$` is a primary class template, the `$splice-type-specifier$` designates `$S$`.
+  - [#.#]{.pnum} Otherwise if `$T$` is an alias template, the `$splice-type-specifier$` designates the type denoted by `$S$`.
+
+:::
+:::
+
 ### [dcl.init.general]{.sref} Initializers (General) {-}
 
 Change paragraphs 6-8 of [dcl.init.general]{.sref} [No changes are necessary for value-initialization, which already forwards to zero-initialization for scalar types]{.ednote}:
@@ -3833,7 +3968,7 @@ Change paragraph 2 of [dcl.fct.def.delete]{.sref} to allow for reflections of de
 
 ::: std
 
-[2]{.pnum} A program that refers to a deleted function implicitly or explicitly, other than to declare it [or to use as the operand of the reflection operator ([expr.reflect])]{.addu}, is ill-formed.
+[2]{.pnum} A program that refers to a deleted function implicitly or explicitly, other than to declare it [or to use as the operand of a `$reflect-expression$` ([expr.reflect])]{.addu}, is ill-formed.
 :::
 
 ### [enum.udecl]{.sref} The `using enum` declaration {-}
@@ -3852,11 +3987,11 @@ Extend the grammar for `$using-enum-declarator$` as follows:
 ```
 :::
 
-Modify paragraph 1 to handle splicers:
+Modify paragraph 1 to handle `$splice-type-specifier$`s:
 
 ::: std
 
-[1]{.pnum} [A `$using-enum-declarator$` of the form `$splice-type-specifier$` is a type-only context, and designates the same construct designated by the splicer. Any other]{.addu} [A]{.rm} `$using-enum-declarator$` names the set of declarations found by type-only lookup ([basic.lookup.general]) for the `$using-enum-declarator$` ([basic.lookup.unqual], [basic.lookup.qual]). The `$using-enum-declarator$` shall designate a non-dependent type with a reachable `$enum-specifier$`.
+[1]{.pnum} [A `$using-enum-declarator$` of the form `$splice-type-specifier$` is a type-only context, and designates the same construct designated by the `$splice-type-specifier$`. Any other]{.addu} [A]{.rm} `$using-enum-declarator$` names the set of declarations found by type-only lookup ([basic.lookup.general]) for the `$using-enum-declarator$` ([basic.lookup.unqual]{.sref}, [basic.lookup.qual]{.sref}). The `$using-enum-declarator$` shall designate a non-dependent type with a reachable `$enum-specifier$`.
 :::
 
 ### [namespace.alias]{.sref} Namespace alias {-}
@@ -3875,7 +4010,7 @@ Add the following prior to paragraph 1, and renumber accordingly:
 
 ::: std
 :::addu
-[0]{.pnum} A `$splice-specifier$` appearing in a `$namespace-alias-definition$` shall designate a namespace or `$namespace-alias$`.
+[0]{.pnum} A `$splice-specifier$` appearing in a `$namespace-alias-definition$` shall designate a namespace or a `$namespace-alias$`.
 :::
 :::
 
@@ -3954,16 +4089,17 @@ Change a sentence in paragraph 4 of [dcl.attr.grammar]{.sref} as follows:
 [4]{.pnum} [...] An `$attribute-specifier$` that contains no `$attribute$`s [and no `$alignment-specifier$`]{.addu} has no effect. [[That includes an `$attribute-specifier$` of the form `[ [ using $attribute-namespace$ :] ]` which is thus equivalent to replacing the `:]` token by the two-token sequence `:` `]`.]{.note}]{.addu} ...
 :::
 
-### [module.global.frag] Global module fragment {-}
+### [module.global.frag]{.sref} Global module fragment {-}
 
-Extend the caveat in paragraph 3.7 to also apply to `$splice-type-specifier$`s.
+Specify in paragraph 3 that it is unspecified whether spliced types are replaced by their designated types, and renumber accordingly.
 
 ::: std
 In this determination, it is unspecified
 
-* [3.6]{.pnum} whether a reference to an `$alias-declaration$`, `typedef` declaration, `$using-declaration$`, or `$namespace-alias-definition$` is replaced by the declarations they name prior to this determination,
-* [#.#]{.pnum} whether a `$simple-template-id$` that does not denote a dependent type and whose `$template-name$` [or `$splice-type-specifier$`]{.addu} [names]{.rm} [designates]{.addu} an alias template is replaced by its denoted type prior to this determination,
-* [#.#]{.pnum} ...
+- [3.6]{.pnum} whether a reference to an `$alias-declaration$`, `typedef` declaration, `$using-declaration$`, or `$namespace-alias-definition$` is replaced by the declarations they name prior to this determination,
+- [#.#]{.pnum} whether a `$simple-template-id$` that does not denote a dependent type and whose `$template-name$` names an alias template is replaced by its denoted type prior to this determination,
+- [#.#]{.pnum} whether a `$decltype-specifier$` [or `$splice-type-specifier$`]{.addu} that does not [denote]{.rm} [designate]{.addu} a dependent type is replaced by its [denoted]{.rm} [designated]{.addu} type prior to this determination,
+- [#.#]{.pnum} whether a non-value-dependent constant expression is replaced by the result of constant evaluation prior to this determination.
 
 :::
 
@@ -3976,37 +4112,73 @@ Modify the definition of reachability to account for injected declarations:
 
 * [#.#]{.pnum} [`$P$` is not an injected point and]{.addu} `$D$` appears prior to `$P$` in the same translation unit, [or]{.rm}
 * [#.#]{.pnum} [`$D$` is an injected declaration for which `$P$` is the corresponding injected point, or]{.addu}
-* [#.#]{.pnum} `$D$` is not discarded ([module.global.frag]), appears in a translation unit that is reachable from `$P$`, and does not appear within a _private-module-framgent_.
+* [#.#]{.pnum} `$D$` is not discarded ([module.global.frag]{.sref}), appears in a translation unit that is reachable from `$P$`, and does not appear within a _private-module-fragment_.
 :::
 
-### [class.pre] Preamble {-}
+### [class.mem.general]{.sref} General {-}
 
-Disallow splicers from appearing in a declaration of a `$class-name$` in paragraph 1.
+Extend paragraph 5, and modify note 3, to clarify the existence of subobjects corresponding to non-static data members of reference types.
 
 ::: std
-...
+[5]{.pnum} A data member or member function may be declared `static` in its _member-declaration_, in which case it is a _static member_ (see [class.static]{.sref}) (a _static data member_ ([class.static.data]{.sref}) or _static member function_ ([class.static.mfct]{.sref}), respectively) of the class. Any other data member or member function is a _non-static member_ (a _non-static data member_ or _non-static member function_ ([class.mfct.non.static]{.sref}), respectively). [For each non-static data member of reference type, there is a unique member subobject whose size and alignment is the same as if the data member were declared with the corresponding pointer type.]{.addu}
 
-A class declaration where the `$class-name$` in the `$class-head-name$` is a `$simple-template-id$` shall be an explicit specialization ([temp.expl.spec]) or a partial specialization ([temp.spec.partial]). [The `$simple-template-id$` shall not contain a splicer.]{.addu} A `$class-specifier$` whose `$class-head$` omits the `$class-head-name$` defines an _unnamed class_.
+[[A non-static data member of non-reference type is a member subobject of a class object.]{.rm} [An object of class type has a member subobject corresponding to each non-static data member of its class.]{.addu}]{.note3}
 
 :::
 
-### [class.name] Class names {-}
+### [over.pre] Preamble {-}
 
-Cover `$splice-type-specifier$`s in paragraph 5.
+Move the definition "overload set" from [basic.lookup]{.sref} to paragraph 2, rewrite the preamble to better describe overload resolution, and add a note explaining the expressions that form overload sets.
 
 ::: std
-[5]{.pnum} A `$simple-template-id$` is only a `$class-name$` if its `$template-name$` [or `$splice-type-specifier$`]{.addu} [names]{.rm} [designates]{.addu} a class template.
+[2]{.pnum} [An _overload set_ is a set of declarations that each denote a function or function template.]{.addu} [When a function is named in a call, which function declaration is being referenced and the validity of the call are determined]{.rm} [The process of _overload resolution_ determines the identity of a function and its validity in a context]{.addu} by comparing the types of the arguments at [the]{.rm} [a]{.addu} point of use with the types of the parameters in [the]{.rm} [candidate functions derived from]{.addu} [declarations in]{.rm} the [initial]{.addu} overload set. [This function selection process is called _overload resolution_ and]{.rm} [Overload resolution]{.addu} is defined in [over.match].
+
+  [[Overload sets are formed by `$id-expression$`s naming functions and function templates and by `$splice-expression$`s that designate entities of the same kinds.]{.note}]{.addu}
 
 :::
 
-### [class.mem.general]{.sref} General {-}
+### [over.match.general]{.sref} General {-}
 
-Extend paragraph 5, and modify note 3, to clarify the existence of subobjects corresponding to non-static data members of reference types.
+Modify paragraphs 3 and 4 to clarify that access rules do not apply in all contexts.
 
 ::: std
-[5]{.pnum} A data member or member function may be declared `static` in its _member-declaration_, in which case it is a _static member_ (see [class.static]) (a _static data member_ ([class.static.data]) or _static member function_ ([class.static.mfct]), respectively) of the class. Any other data member or member function is a _non-static member_ (a _non-static data member_ or _non-static member function_ ([class.mfct.non.static]), respectively). [For each non-static data member of reference type, there is a unique member subobject whose size and alignment is the same as if the data member were declared with the corresponding pointer type.]{.addu}
+[3]{.pnum} If a best viable function exists and is unique, overload resolution succeeds and produces it as the result. Otherwise overload resolution fails and the invocation is ill-formed. When overload resolution succeeds, and the best viable function is [not]{.rm} [neither designated in a manner exempt from access rules nor]{.addu} accessible in the context in which it is used, the program is ill-formed.
 
-[[A non-static data member of non-reference type is a member subobject of a class object.]{.rm} [An object of class type has a member subobject corresponding to each non-static data member of its class]{.addu}]{.note3}
+[4]{.pnum} Overload resolution results in a _usable candidate_ if overload resolution succeeds and the selected candidate is either not a function ([over.built]{.sref}), or is a function that is not deleted and is [either designated in a manner exempt from access rules or is]{.addu} accessible from the context in which overload resolution was performed.
+
+:::
+
+### [over.call.func]{.sref} Call to named function {-}
+
+Modify paragraph 1 to clarify that this section will also apply to splices of function templates.
+
+::: std
+[1]{.pnum} Of interest in [over.call.func] are [only]{.rm} those function calls in which the `$posfix-expression$` ultimately contains an `$id-expression$` that denotes one or more functions [or a `$splice-expression$` that designates a function template]{.addu}. Such a `$postfix-expression$`, perhaps nested arbitrarily deep in parentheses, has one of the following forms:
+
+```diff
+  $postfix-expression$:
+     $postfix-expression$ . $id-expression$
++    $postfix-expression$ . $splice-expression$
+     $postfix-expression$ -> $id-expression$
++    $postfix-expression$ -> $splice-expression$
+     $primary-expression$
+```
+
+These represent two syntactic subcategories of function calls: qualified function calls and unqualified function calls.
+
+:::
+
+Modify paragraph 2 to account for overload resolution of `$splice-expression$`s designating member function templates.
+
+::: std
+[2]{.pnum} In qualified function calls, the function is [named]{.rm} [designated]{.addu} by an `$id-expression$` [or `$splice-expression$`]{.addu} preceded by an `->` or `.` operator. Since the construct `A->B` is generally equivalent to `(*A).B`, the rest of [over] assumes, without loss of generality, that all member function calls have been normalized to the form that uses an object and the `.` operator. Furthermore, [over] assumes that the `$postfix-expression$` that is the left operand of the `.` operator has type "_cv_ `T`" where `T` denotes a class.^102^ The [set of]{.addu} function declarations [constituting the candidate functions is]{.addu} found by name lookup ([class.member.lookup]{.sref}) [if the `.` is followed by an `$id-expression$` and is otherwise the singleton containing the function template designated by the `$splice-expression$`]{.addu} [constitute the set of candidate functions]{.rm}. The argument list is the `$expression-list$` in the call augmented by the addition of the left operand of the `.` operator in the normalized member function call as the implied object argument ([over.match.funcs]{.sref}).
+
+:::
+
+Modify paragraph 3 to account for overload resolution of `$splice-expression$`s designating non-member function templates.
+
+::: std
+[3]{.pnum} In unqualified function calls, the function is named by a `$primary-expression$`. [If that `$primary-expression$` is a `$splice-expression$`, then the set of function declarations constituting the candidate functions is the singleton containing the function template designated by that `$splice-expression$`. For all other cases, the]{.addu} [The]{.rm} function declarations found by name lookup ([basic.lookup]{.sref}) constitute the set of candidate functions. Because of the rules for name lookup, the set of candidate functions consists either entirely of non-member functions or entirely of member functions of some class `T`. In the former case or if the `$primary-expression$` is [a `$splice-expression$` or]{.addu} the address of an overload set, the argument list is the same as the `$expression-list$` in the call. Otherwise, the argument list is the `$expression-list$` in the call augmented by the addition of an implied function argument as in a qualified function call. If the current class is, or is derived from, `T`, and the keyword `this` ([expr.prim.this]{.sref}) refers to it, then the implied object argument is `(*this)`. Otherwise, a contrived object of type `T` becomes the implied object argument;^103^ if overload resolution selects a non-static member function, the call is ill-formed.
 
 :::
 
@@ -4015,7 +4187,7 @@ Extend paragraph 5, and modify note 3, to clarify the existence of subobjects co
 Extend paragraph 1 to work with `$splice-type-specifier$`s.
 
 ::: std
-[1]{.pnum} When resolving a placeholder for a deduced class type ([dcl.type.class.deduct]) where the `$template-name$` [or `$splice-type-specifier$`]{.addu} [names]{.rm} [designates]{.addu} a primary class template `C`, a set of functions and function templates, called the guides of `C`, is formed comprising:
+[1]{.pnum} When resolving a placeholder for a deduced class type ([dcl.type.class.deduct]{.sref}) where the `$template-name$` [or `$splice-type-specifier$`]{.addu} [names]{.rm} [designates]{.addu} a primary class template `C`, a set of functions and function templates, called the guides of `C`, is formed comprising:
 
 * [#.#]{.pnum} ...
 
@@ -4024,13 +4196,13 @@ Extend paragraph 1 to work with `$splice-type-specifier$`s.
 Extend paragraph 3 to also cover `$splice-type-specifier$`s.
 
 :::std
-[3]{.pnum} When resolving a placeholder for a deduced class type ([dcl.type.simple]) where the `$template-name$` [or `$splice-type-specifier$`]{.addu} [names]{.rm} [designates]{.addu} an alias template `A`, the `$defining-type-id$` of `A` must be of the form
+[3]{.pnum} When resolving a placeholder for a deduced class type ([dcl.type.simple]{.sref}) where the `$template-name$` [or `$splice-type-specifier$`]{.addu} [names]{.rm} [designates]{.addu} an alias template `A`, the `$defining-type-id$` of `A` must be of the form
 
 ```cpp
 typename@~_opt_~@ $nested-name-specifier$@~_opt_~@ template@~_opt_~@ $simple-template-id$
 ```
 
-as specified in [dcl.type.simple]. The guides of `A` are the set of functions or function templates formed as follows. ...
+as specified in [dcl.type.simple]{.sref}. The guides of `A` are the set of functions or function templates formed as follows. ...
 
 :::
 
@@ -4059,7 +4231,7 @@ Extend the grammar for `$type-constraint$` to include `$splice-type-specifier$`.
 ```
 :::
 
-Add a paragraph after paragraph 3 to restrict the type splicers that form `$type-constraint$`s.
+Add a paragraph after paragraph 3 to restrict which `$splice-type-specifier$`s form `$type-constraint$`s.
 
 ::: std
 ::: addu
@@ -4069,57 +4241,36 @@ Add a paragraph after paragraph 3 to restrict the type splicers that form `$type
 
 ### [temp.names]{.sref} Names of template specializations {-}
 
-Extend `$simple-template-id$` and `$template-argument$` to leverage splicers.
+Define the term `$splice-template-argument$`, and add it as a production for `$template-argument$`.
 
 ::: std
 ```diff
-  $simple-template-id$:
-      $template-name$ < $template-argument-list$@~_opt_~@ >
-+     $splice-expr-template-specifier$ < $template-argument-list$@~_opt_~@ >
-+     $splice-type-specifier$ < $template-argument-list$@~_opt_~@ >
-
-  $template-id$:
-      $simple-template-id$
-      $operator-function-id < $template-argument-list$@~_opt_~@ >
-      $literal-operator-id < $template-argument-list$@~_opt_~@ >
-
-  $template-name$:
-      identifier
-
-  $template-argument-list$:
-      $template-argument$ ...@~_opt_~@
-      $template-argument-list$ , $template-argument$ ...@~_opt_~@
-
   $template-argument$:
       $constant-expression$
       $type-id$
       $id-expression$
       $braced-init-list$
++     $splice-template-argument$
+
++ $splice-template-argument$:
 +     $splice-specifier$
 ```
 :::
 
-Extend paragraph 2 to cover `$simple-template-id$`s and `$template-id$`s that have no component name.
-
-::: std
-[2]{.pnum} The component name of a [`$simple-template-id$`, `$template-id$`, or]{.rm} `$template-name$` is its `$identifier$` [the first name in it]{.rm}. [The component names of a `$simple-template-id$` are those of its `$template-name$` (if any). The component names of a `$template-id$` are those of its `$simple-template-id$`, `$operator-function-id$`, or `$literal-operator-id$`.]{.addu}
-
-:::
-
 Extend and re-format paragraph 3 of [temp.names]{.sref}:
 
 ::: std
 
-[3]{.pnum} A `<` is interpreted as the delimiter of a `$template-argument-list$` if it follows [either]{.addu}
+[3]{.pnum} A `<` is interpreted as the delimiter of a `$template-argument-list$` if it follows
 
-* [[#.#]{.pnum} a `$splice-expr-template-specifier$` or `$splice-type-specifier$`, or]{.addu}
+* [[#.#]{.pnum} a `$splice-specifier$` that either appears in a type-only context or is preceded by `template` or `typename`, or]{.addu}
 * [#.#]{.pnum} a name that is not a `$conversion-function-id$` and
   * [#.#.#]{.pnum} that follows the keyword template or a ~ after a nested-name-specifier or in a class member access expression, or
   * [#.#.#]{.pnum}  for which name lookup finds the injected-class-name of a class template or finds any declaration of a template, or
   * [#.#.#]{.pnum} that is an unqualified name for which name lookup either finds one or more functions or finds nothing, or
   * [#.#.#]{.pnum} that is a terminal name in a using-declarator ([namespace.udecl]), in a declarator-id ([dcl.meaning]), or in a type-only context other than a nested-name-specifier ([temp.res]).
 
-[If the name is an identifier, it is then interpreted as a *template-name*. The keyword template is used to indicate that a dependent qualified name ([temp.dep.type]) denotes a template where an expression might appear.]{.note}
+[If the name is an identifier, it is then interpreted as a *template-name*. The keyword template is used to indicate that a dependent qualified name ([temp.dep.type]{.sref}) denotes a template where an expression might appear.]{.note}
 
 ::: example
 ```diff
@@ -4141,27 +4292,59 @@ template<class T> void f(T* p) {
 :::
 :::
 
-Extend paragraph 8 to also cover `$simple-template-id$`s containing `$splice-expr-template-specifier$`s.
+Clarify that the `>` disambiguation in paragraph 4 also applies to the parsing of `$splice-specialization-specifier$`s:
+
+::: std
+[4]{.pnum} When parsing a `$template-argument-list$`, the first non-nested `>`^111^ is taken as the ending delimiter rather than a greater-than operator. Similarly, the first non-nested `>>` is treated as two consecutive but distinct `>` tokens, the first of which is taken as the end of the `$template-argument-list$` and completes the `$template-id$` [or `$splice-specialization-specifier$`]{.addu}.
+
+[The second `>` token produced by this replacement rule can terminate an enclosing `$template-id$` [or `$splice-specialization-specifier$`]{.addu} construct or it can be part of a different construct (e.g., a cast).]{.note}
+
+:::
+
+Extend the definition of a _valid_ `$template-id$` to also cover `$splice-specialization-specifier$`s:
+
+::: std
+[7]{.pnum} A `$template-id$` [or `$splice-specialization-specifier$`]{.addu} is _valid_ if
+
+* [#.#]{.pnum} there are at most as many arguments as there are parameters or a parameter is a template parameter pack ([temp.variadic]{.sref}),
+* [#.#]{.pnum} there is an argument for each non-deducible non-pack parameter that does not have a default `$template-argument$`,
+* [#.#]{.pnum} each `$template-argument$` matches the corresponding `$template-parameter$` ([temp.arg]{.sref}),
+* [#.#]{.pnum} substitution of each template argument into the following template parameters (if any) succeeds, and
+* [#.#]{.pnum} if the `$template-id$` [or `$splice-specialization-specifier$`]{.addu} is non-dependent, the associated constraints are satisfied as specified in the next paragraph.
+
+A `$simple-template-id$` [or `$splice-specialization-specifier$`]{.addu} shall be valid unless it names a function template specialization ([temp.deduct]{.sref}).
+
+:::
+
+Extend paragraph 8 to require constraints to also be satisfied by `$splice-specialization-specifier$`s:
 
 ::: std
-[8]{.pnum} When the `$template-name$` [or splicer]{.addu} of a `$simple-template-id$` [names]{.rm} [designates]{.addu} a constrained non-function template or a constrained template `$template-parameter$`, and all `$template-arguments$` in the `$simple-template-id$` are non-dependent ([temp.dep.temp]), the associated contraints ([temp.constr.decl]) of the constrained template shall be satisfied ([temp.constr.constr]).
+[8]{.pnum} When the `$template-name$` of a `$simple-template-id$` [or the `$splice-specifier$` of a `$splice-specialization-specifier$` designates]{.addu} [names]{.rm} a constrained non-function template or a constrained template `$template-parameter$`, and all `$template-arguments$` in the `$simple-template-id$` [or `$splice-specialization-specifier$`]{.addu} are non-dependent ([temp.dep.temp]{.sref}), the associated constraints ([temp.constr.decl]{.sref}) of the constrained template shall be satisfied ([temp.constr.constr]{.sref}).
 
 :::
 
-Change paragraph 9 to allow splicing into a *concept-id*:
+Modify footnote 111 to account for `$splice-specialization-specifier$`s:
 
 ::: std
-[9]{.pnum} A _concept-id_ is a `$simple-template-id$` where [either]{.addu} the `$template-name$` is a `$concept-name$` [or the `$splice-expr-template-specifier$` designates a concept]{.addu}. A concept-id is a prvalue of type `bool`, and does not name a template specialization. A concept-id evaluates to `true` if the concept's normalized `$constraint-expression$` ([temp.constr.decl]) is satisfied ([temp.constr.constr]) by the specified template arguments and `false` otherwise.
+[111)]{.pnum} A `>` that encloses the `$type-id$` of a `dynamic_cast`, `static_cast`, `reinterpret_cast` or `const_cast`, or which encloses the `$template-argument$`s of a subsequent `$template-id$` [or `$splice-specialization-specifier$`]{.addu}, is considered nested for the purpose of this description.
+
 :::
 
 
 ### [temp.arg.general]{.sref} General {-}
 
-Adjust paragraph 3 of [temp.arg.general] to not apply to splice template arguments:
+Modify paragraph 1; there are now _four_ forms of `$template-argument$`.
 
 ::: std
+[1]{.pnum} There are [three]{.rm} [four]{.addu} forms of `$template-argument$`, [three of which]{.addu} correspond[ing]{.rm} to the three forms of `$template-parameter$`: type, non-type and template. [The fourth argument form, splice template argument, is considered to match the form of any template parameter.]{.addu} The type and form of each `$template-argument$` specified in a `$template-id$` [or in a `$splice-specialization-specifier$`]{.addu} shall match the type and form specified for the corresponding parameter declared by the template in its `$template-parameter-list$`.
 
-[3]{.pnum} In a `$template-argument$` [that is not a `$splice-specifier$`]{.addu}, an ambiguity between a `$type-id$` and an expression is resolved to a `$type-id$`, regardless of the form of the corresponding `$template-parameter$`.
+:::
+
+Clarify ambiguity between `$splice-expression$`s and `$splice-template-argument$`s in paragraph 3:
+
+::: std
+
+[3]{.pnum} [A `$template-argument$` of the form `$splice-specifier$` is interpreted as a `$splice-template-argument$`.]{.addu} [In a]{.rm} [For any other]{.addu} `$template-argument$`, an ambiguity between a `$type-id$` and an expression is resolved to a `$type-id$`, regardless of the form of the corresponding `$template-parameter$`.
 
 ::: example2
 ```diff
@@ -4172,20 +4355,27 @@ Adjust paragraph 3 of [temp.arg.general] to not apply to splice template argumen
     f<int()>();       // int() is a type-id: call@[s (#1)]{.addu}@ @[`the first f()`]{.rm}@
 
 +   constexpr int x = 42;
-+   f<[:^^int:]>();    // splice-specifier: calls (#1)
-+   f<[:^^x:]>();      // splice-specifier: calls (#2)
++   f<[:^^int:]>();    // splice-template-argument: calls (#1)
++   f<[:^^x:]>();      // splice-template-argument: calls (#2)
   }
 ```
 :::
 
 :::
 
+Clarify in paragraph 9 that default template arguments also apply to `$splice-specialization-specifier$`s:
+
+::: std
+[9]{.pnum} When a `$simple-template-id$` [or `$splice-specialization-specifier$`]{.addu} does not [name]{.rm} [designate]{.addu} a function, a default `$template-argument$` is implicitly instantiated when the value of that default argument is needed.
+
+:::
+
 ### [temp.arg.type]{.sref} Template type arguments {-}
 
 Extend [temp.arg.type]{.sref}/1 to cover splice template arguments:
 
 ::: std
-[1]{.pnum} A `$template-argument$` for a `$template-parameter$` which is a type shall [either]{.addu} be a `$type-id$` [or a `$splice-specifier$` that is either dependent or designates a type]{.addu}.
+[1]{.pnum} A `$template-argument$` for a `$template-parameter$` which is a type shall [either]{.addu} be a `$type-id$` [or a `$splice-template-argument$` whose `$splice-specifier$` designates a type]{.addu}.
 :::
 
 ### [temp.arg.nontype]{.sref} Template non-type arguments {-}
@@ -4214,27 +4404,26 @@ is introduced.
 Extend [temp.arg.template]{.sref}/1 to cover splice template arguments:
 
 ::: std
-[1]{.pnum} A `$template-argument$` for a template `$template-parameter$` shall be [the name of]{.rm} a class template or an alias template, expressed as [an]{.addu} `$id-expression$` [or a (possibly dependent) splicer]{.addu}. Only primary templates are considered when matching the template argument with the corresponding parameter; partial specializations are not considered even if their parameter lists match that of the template template parameter.
+[1]{.pnum} A `$template-argument$` for a template `$template-parameter$` shall be [the name of]{.rm} a class template or an alias template, expressed as [an]{.addu} `$id-expression$` [or a `$splice-template-argument$`]{.addu}. Only primary templates are considered when matching the template argument with the corresponding parameter; partial specializations are not considered even if their parameter lists match that of the template template parameter.
 :::
 
 ### [temp.type]{.sref} Type equivalence {-}
 
-Extend `$template-id$` equivalence as defined by paragraph 1 to cover splicers.
+Extend paragraph 1 to also define the "sameness" of `$splice-specialization-specifier$`s:
 
 ::: std
-[1]{.pnum} Two `$template-id$`s are the same if
+[1]{.pnum} Two `$template-id$`s [or `$splice-specialization-specifier$`s]{.addu} are the same if
 
-* their `$template-name$`s, [`$splice-expr-template-specifier$`s, `$splice-type-specifier$`s, ]{.addu} `$operator-function-id$`s, or `$literal-operator-id$`s refer to the same template, and
-* their corresponding type `$template-argument$`s are the same type, and
-* the template parameter values determined by their corresponding non-type template arguments ([temp.arg.nontype]) are template-argument-equivalent (see below), and
-* their corresponding template `$template-argument$`s refer to the same template.
+* [#.#]{.pnum} their `$template-name$`s, `$operator-function-id$`s, [or]{.rm} `$literal-operator-id$`s[, or `$splice-specifier$`s]{.addu} refer to the same template, and
+* [#.#]{.pnum} their corresponding type `$template-argument$`s are the same type, and
+* [#.#]{.pnum} the template parameter values determined by their corresponding non-type template arguments ([temp.arg.nontype]{.sref}) are template-argument-equivalent (see below), and
+* [#.#]{.pnum} their corresponding template `$template-argument$`s refer to the same template.
 
-Two `$template-id$`s that are the same refer to the same class, function, or variable.
+Two `$template-id$`s [or `$splice-specialization-specifier$`s]{.addu} that are the same refer to the same class, function, or variable.
 
 :::
 
-
-Extend *template-argument-equivalent* to handle `std::meta::info`:
+Extend *template-argument-equivalent* in paragraph 2 to handle `std::meta::info`:
 
 ::: std
 [2]{.pnum} Two values are *template-argument-equivalent* if they are of the same type and
@@ -4252,15 +4441,23 @@ Extend *template-argument-equivalent* to handle `std::meta::info`:
 Extend paragraph 1 to clarify that `$splice-type-specifier$`s can also leverage deduction guides.
 
 ::: std
-[1]{.pnum} Deduction guides are used when a `$template-name$` [or `$splice-type-specifier$`]{.addu} appears as a type specifier for a deduced class type ([dcl.type.class.deduct]). Deduction guides are not found by name lookup. Instead, when performing class template argument deduction ([over.match.class.deduct]), all reachable deduction guides declared for the class template are considered.
+[1]{.pnum} Deduction guides are used when a `$template-name$` [or `$splice-type-specifier$`]{.addu} appears as a type specifier for a deduced class type ([dcl.type.class.deduct]{.sref}). Deduction guides are not found by name lookup. Instead, when performing class template argument deduction ([over.match.class.deduct]{.sref}), all reachable deduction guides declared for the class template are considered.
 
 :::
 
-Notwithstanding the above, extend paragraph 3 to clarify that `$splice-type-specifier$`s cannot themselves appear in deduction guides.
+### [temp.mem]{.sref} Member templates {-}
+
+Clarify in Note 1 that a specialization of a conversion function template can be formed through a `$splice-expression$`.
 
 ::: std
-[3]{.pnum} The same restrictions apply to the `$parameter-declaration-clause$` of a deduction guide as in a function declaration ([dcl.fct]), except that a generic parameter type placeholder ([dcl.spec.auto]) shall not appear in the `$parameter-declaration-clause$` of a deduction guide. The `$simple-template-id$` shall name a class template specialization [and shall contain a `$template-name$`]{.addu}. The `$template-name$` shall be the same `$identifier$` as the `$template-name$` of the `$simple-template-id$`. A `$deduction-guide$` shall inhabit the scope to which the corresponding class template belongs and, for a member class template, have the same access. Two deduction guide declarations for the same class template shall not have equivalent `$parameter-declaration-clauses$` if either is reachable from the other.
+::: note
+A specialization of a conversion function template is referenced in the same way as a non-template conversion function that converts to the same type ([class.conv.fct]{.sref}).
 
+...
+
+[An expression designating a particular specialization of a conversion function template can only be formed with a `$splice-expression$`.]{.addu} There is no [analogous]{.addu} syntax to form a `$template-id$` ([temp.names]{.sref}) [for such a function]{.addu} by providing an explicit template argument list ([temp.arg.explicit]{.sref}).
+
+:::
 :::
 
 ### [temp.alias]{.sref} Alias templates {-}
@@ -4274,14 +4471,7 @@ Extend paragraph 2 to enable reflection of alias template specializations.
 
 ### [temp.res.general]{.sref} General {-}
 
-Disallow `$splice-type-specifier$`s from appearing in `$typename-specifier$`s, since splicers can't follow `$nested-name-specifier$`s.
-
-::: std
-[3]{.pnum} The component names of a `$typename-specifier$` are its `$identifier$` (if any) and those of its `$nested-name-specifier$` and `$simple-template-id$` (if any). [The `$simple-template-id$` shall not contain a splicer.]{.addu}
-
-:::
-
-Add a parargraph after the definition of _type-only context_ to define what it means for a  splicer to appear in a type-only context.
+Extend paragraph 4 to define what it means for a `$splice-specifier$` to appear in a type-only context.
 
 ::: std
 [4]{.pnum} A qualified or unqualified name is said to be in a `$type-only context$` if it is the terminal name of
@@ -4290,7 +4480,7 @@ Add a parargraph after the definition of _type-only context_ to define what it m
 * [#.#]{.pnum} [...]
   * [4.4.6]{.pnum} `$parameter-declaration$` of a (non-type) `$template-parameter$`.
 
-[A splicer ([expr.prim.id.splice]) is said to be in a _type-only context_ if a hypothetical qualified name appearing in the same position would be in a type-only context.]{.addu}
+[A `$splice-specifier$` or `$splice-specialization-specifier$` ([basic.splice]) is said to be in a _type-only context_ if a hypothetical qualified name appearing in the same position would be in a type-only context.]{.addu}
 
 ::: example5
 ```cpp
@@ -4317,29 +4507,43 @@ template<typename T> void f() {
 :::
 :::
 
-Add a new case to the list of IFNDR conditions related to template instantiation.
+### [temp.dep.type]{.sref} Dependent types {-}
+
+Account for dependent `$splice-specifier$`s in paragraph 7.
+
+::: std
+[7]{.pnum} An initializer is dependent if any constituent expression ([intro.execution]{.sref}) of the initializer is type-dependent. A placeholder type ([dcl.spec.auto.general]{.sref}) is dependent if it designates a type deduced from a dependent initializer [or if its `$type-constraint$` (if any) contains a dependent `$splice-specifier$` ([temp.dep.splice])]{.addu}.
+
+:::
+
+Apply a drive-by fix to paragraph 8 to account for placeholders for deduced class types whose template is dependent, while extending the definition to apply to `$splice-specifier$`s.
 
 ::: std
-[6]{.pnum} The validity of a templated entity may be checked prior to any instantiation.
+[8]{.pnum} A placeholder for a deduced class type ([dcl.type.class.deduct]{.sref}) is dependent if
 
-[Knowing which names are type names allows the syntax of every template to be checked in this way.]{.note3}
+* [#.#]{.pnum} it has a dependent initializer, [or]{.rm}
+* [[#.#]{.pnum} it has a dependent `$template-name$` or a dependent `$splice-specifier$`, or]{.addu}
+* [#.#]{.pnum} it refers to an alias template that is a member of the current instantiation and whose `$defining-type-id$` is dependent after class template argument deduction ([over.match.class.deduct]{.sref}) and substitution ([temp.alias]{.sref}).
 
-The program is ill-formed, no diagnostic required, if
+:::
+
+Account for dependent `$splice-type-specifier$`s in paragraph 10:
 
-* [#.#]{.pnum} no valid specialization, ignoring `$static_assert-declaration$`s that fail ([dcl.pre]), can be generated for a templated entity or a substatement of a constexpr if statement ([stmt.if]) within a templaetd entity and the innermost enclosing template is not instantiated, or
-* [#.#]{.pnum} no valid specialization, ignoring `$static_assert-declaration$`s that fail, can be generated for a default `$template-argument$` and the default `$template-argument$` is not used in any instantiation, or
-* [#.#]{.pnum} no specialization of an alias template ([temp.alias]) is valid and no specialization of the alias template is named in the program, or
-* [[#.#]{.pnum} any non-dependent plainly constant-evaluated expression within a templated entity produces an injected declaration ([expr.const]), or]{.addu}
-* [#.#]{.pnum} any `$constraint-expression$` in the program, introduced or otherwise, has (in its normal form) an atomic constraint `$A$` where no satisfaction check of `$A$` could be well-formed and no satisfaction check of `$A$` is performed, or
-* [#.#]{.pnum} every valid specialization of a variadic template requires an empty template parameter pack, or
-* [#.#]{.pnum} a hypothetical instantiation of a templated entity immediately following its definition would be ill-formed due to a construct (other than a `$static_assert-declaration$` that fails) that does not depend on a template parameter, or
-* [#.#]{.pnum} the interpretation of such a construct in the hypothetical instantiation is different from the interpretation of the corresponding construct in any actual instantiation of the templated entity.
+::: std
+[10]{.pnum} A type is dependent if it is
+
+* [#.#]{.pnum} a template parameter,
+* [#.#]{.pnum} ...
+* [#.11]{.pnum} denoted by a `$simple-template-id$` in which either the template name is a template parameter or any of the template arguments is a dependent type or an expression that is type-dependent or value-dependent or is a pack expansion,^121^
+* [#.#]{.pnum} a `$pack-index-specifier$`, [or]{.rm}
+* [#.#]{.pnum} denoted by `decltype($expression$)`, where `$expression$` is type-dependent[.]{.rm}[, or]{.addu}
+* [[#.#]{.pnum} denoted by a `$splice-type-specifier$` in which either the `$splice-specifier$` is dependent or any of the template arguments is a dependent type or an expression that is type-dependent or value-dependent or is a pack expansion.]{.addu}
 
 :::
 
 ### [temp.dep.expr]{.sref} Type-dependent expressions {-}
 
-Add to the list of never-type-dependent expression forms in [temp.dep.expr]{.sref}/4:
+Add to the list of never-type-dependent expression forms in paragraph 4:
 
 ::: std
 ```diff
@@ -4364,16 +4568,14 @@ Add a new paragraph at the end of [temp.dep.expr]{.sref}:
 ::: std
 ::: addu
 
-[9]{.pnum} A `$primary-expression$` of the form `$splice-specifier$` or `$splice-expr-template-specifier$ < $template-argument-list$@~_opt_~@ >` is type-dependent if
+[9]{.pnum} A `$primary-expression$` of the form `$splice-specifier$` or `template $splice-specifier$ < $template-argument-list$@~_opt_~@ >` is type-dependent if
 
-* [#.#]{.pnum} the `$splice-specifier$` or `$splice-expr-template-specifier$` is dependent, or
+* [#.#]{.pnum} the `$splice-specifier$` is dependent, or
 * [#.#]{.pnum} the optional `$template-argument-list$` contains a dependent type argument, a value-dependent non-type argument, a dependent template template argument, or a dependent `$splice-specifier$`.
 
 :::
 :::
 
-
-
 ### [temp.dep.constexpr]{.sref} Value-dependent expressions {-}
 
 Add at the end of [temp.dep.constexpr]{.sref}/2 (before the note):
@@ -4393,7 +4595,7 @@ alignof ( type-id )
 noexcept ( expression )
 ```
 
-[A `$reflect-expression$` is value-dependent if the operand following `^^` is a dependent name, names a dependent type, or contains a dependent `$pack-index-expression$`.]{.addu}
+[A `$reflect-expression$` is value-dependent if its `$nested-name-specifier$` (if any) is dependent or if it has a dependent `$type-id$`, a dependent `$qualified-namespace-specifier$`, a dependent `$template-name$`, or a value-dependent or type-dependent `$id-expression$`.]{.addu}
 :::
 
 
@@ -4402,15 +4604,88 @@ Add a new paragraph after [temp.dep.constexpr]{.sref}/5:
 ::: std
 ::: addu
 
-[6]{.pnum} A `$primary-expression$` of the form `$splice-specifier$` or `$splice-expr-template-specifier$ < $template-argument-list$@~_opt_~@ >` is value-dependent if
+[6]{.pnum} A `$primary-expression$` of the form `$splice-specifier$` or `template $splice-specifier$ < $template-argument-list$@~_opt_~@ >` is value-dependent if
 
-* [#.#]{.pnum} the `$splice-specifier$` or `$splice-expr-template-specifier$` is dependent, or
+* [#.#]{.pnum} the `$splice-specifier$` is dependent, or
 * [#.#]{.pnum} the optional `$template-argument-list$` contains a dependent type argument, a value-dependent non-type argument, a dependent template template argument, or a dependent `$splice-specifier$`.
 
 :::
 :::
 
+### 13.8.3.4+ [temp.dep.splice] Dependent splice specifiers {-}
+
+
+Add a new subsection of [temp.dep]{.sref} following [temp.dep.constexpr]{.sref}, and renumber accordingly.
+
+::: std
+::: addu
+**Dependent splice specifiers   [temp.dep.splice]**
+
+[1]{.pnum} A `$splice-specifier$` is dependent if its converted `$constant-expression$` is value-dependent. A `$splice-specialization-specifier$` or `$splice-scope-specifier$` is dependent if its `$splice-specifier$` is dependent.
+
+[2]{.pnum}
+
+:::example
+```cpp
+template <auto T, auto NS, auto C, auto V>
+void fn() {
+  using a = [:T:]<0>;  // [:T:] and [:T:]<V> are dependent
+
+  static_assert(template [:C:]<typename [:NS:]::template TCls<0>>);
+    // [:C:] and [:NS:] are dependent
+}
+
+namespace NS {
+template <auto V> struct TCls {};
+template <typename> concept Concept = requires { requires true; };
+}
+
+int main() {
+  static constexpr int v = 1;
+  fn<^^NS::TCls, ^^NS, ^^NS::Concept, ^^v>();
+}
+```
+
+:::
+:::
+:::
+
+
+### [temp.expl.spec]{.sref} Explicit specialization {-}
 
+Modify paragraph 9 to allow `$splice-specialization-specifier$`s to be used like incompletely-defined classes.
+
+::: std
+[9]{.pnum} A `$simple-template-id$` [or `$splice-specialization-specifier$`]{.addu} that [names]{.rm} [designates]{.addu} a class template explicit specialization that has been declared but not defined can be used exactly like the names of other incompletely-defined classes ([basic.types]{.sref}).
+
+:::
+
+### [temp.deduct.general]{.sref} General {-}
+
+Cover `$splice-specialization-specifier$`s in paragraph 2:
+
+::: std
+[2]{.pnum} When an explicit template argument list is specified, if the given `$template-id$` [or `$splice-specialization-specifier$`]{.addu} is not valid ([temp.names]{.sref}), type deduction fails. Otherwise, the specified template argument values are substituted for the corresponding template parameters as specified below.
+
+:::
+
+### [temp.deduct.call]{.sref} Deducing template arguments from a function call {-}
+
+Modify paragraph 4.3 to treat parameter types of function templates that are specified using `$splice-specialization-specifier$`s the same as parameter types that are specified using `$simple-template-id$`s.
+
+::: std
+- [4.3]{.pnum} If `P` is a class and `P` has the form `$simple-template-id$` [or `typename@~_opt_~@ $splice-specialization-specifier$`]{.addu}, then the transformed `A` can be a dervied class `D` of the deduced `A`. Likewise, if `P` is a pointer to a class of the form `$simple-template-id$` [or `typename@~_opt_~@ $splice-specialization-specifier$`]{.addu}, the transformed `A` can be a pointer to a derived class `D` pointed to by the deduced `A`. However, if there is a class `C` that is a (direct or indirect) base class of `D` and derived (directly or indirectly) from a class `B` and that would be a valid deduced `A`, the deduced `A` cannot be `B1` or pointer to `B`, respectively.
+
+:::
+
+### [temp.deduct.type]{.sref} Deducing template arguments from a type {-}
+
+Modify paragraph 20 to clarify that the construct enclosing a template argument might also be a `$splice-specialization-specifier$`.
+
+::: std
+[20]{.pnum} If `P` has a form that contains `<i>`, and if the type of `i` differs from the type of the corresponding template parameter of the template named by the enclosing `$simple-template-id$` [or `$splice-specialization-specifier$`]{.addu}, deduction fails. If `P` has a form that contains `[i]`, and if the type of `i` is not an integral type, deduction fails.^123^ If `P` has a form that includes `noexcept(i)` and the type of `i` is not `bool`, deduction fails.
+
+:::
 
 ### [cpp.cond]{.sref} Conditional inclusion {-}