[expr] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpunartgk5/{from.md → to.md} +2085 -994

tmp/tmpunartgk5/{from.md → to.md} RENAMED Viewed

@@ -30,12 +30,12 @@ that is, for operators applied to types for which they are defined by
 this Standard. However, these built-in operators participate in overload
 resolution, and as part of that process user-defined conversions will be
 considered where necessary to convert the operands to types appropriate
 for the built-in operator. If a built-in operator is selected, such
 conversions will be applied to the operands before the operation is
-considered further according to the rules in subclause
-[[expr.compound]]; see  [[over.match.oper]], [[over.built]].
 If during the evaluation of an expression, the result is not
 mathematically defined or not in the range of representable values for
 its type, the behavior is undefined.
@@ -111,22 +111,22 @@ Expressions are categorized according to the taxonomy in Figure
 <a id="fig:basic.lval"></a>
 ![Expression category taxonomy \[fig:basic.lval\]](images/valuecategories.svg)
 - A *glvalue* is an expression whose evaluation determines the identity
-  of an object or function.
 - A *prvalue* is an expression whose evaluation initializes an object or
   computes the value of an operand of an operator, as specified by the
   context in which it appears, or an expression that has type cv `void`.
 - An *xvalue* is a glvalue that denotes an object whose resources can be
   reused (usually because it is near the end of its lifetime).
 - An *lvalue* is a glvalue that is not an xvalue.
 - An *rvalue* is a prvalue or an xvalue.
-Every expression belongs to exactly one of the fundamental
-classifications in this taxonomy: lvalue, xvalue, or prvalue. This
-property of an expression is called its *value category*.
 [*Note 1*: The discussion of each built-in operator in
 [[expr.compound]] indicates the category of the value it yields and the
 value categories of the operands it expects. For example, the built-in
 assignment operators expect that the left operand is an lvalue and that
@@ -137,18 +137,19 @@ types. — *end note*]
 [*Note 2*: Historically, lvalues and rvalues were so-called because
 they could appear on the left- and right-hand side of an assignment
 (although this is no longer generally true); glvalues are “generalized”
 lvalues, prvalues are “pure” rvalues, and xvalues are “eXpiring”
-lvalues. Despite their names, these terms classify expressions, not
 values. — *end note*]
 [*Note 3*:
 An expression is an xvalue if it is:
-- a move-eligible *id-expression* [[expr.prim.id.unqual]],
 - the result of calling a function, whether implicitly or explicitly,
   whose return type is an rvalue reference to object type [[expr.call]],
 - a cast to an rvalue reference to object type
   [[expr.type.conv]], [[expr.dynamic.cast]], [[expr.static.cast]], [[expr.reinterpret.cast]], [[expr.const.cast]], [[expr.cast]],
 - a subscripting operation with an xvalue array operand [[expr.sub]],
@@ -187,21 +188,18 @@ xvalues. The expression `ar` is an lvalue.
 The *result* of a glvalue is the entity denoted by the expression. The
 *result* of a prvalue is the value that the expression stores into its
 context; a prvalue that has type cv `void` has no result. A prvalue
 whose result is the value *V* is sometimes said to have or name the
 value *V*. The *result object* of a prvalue is the object initialized by
-the prvalue; a non-discarded prvalue that is used to compute the value
-of an operand of a built-in operator or a prvalue that has type
-cv `void` has no result object.
 [*Note 4*: Except when the prvalue is the operand of a
-*decltype-specifier*, a prvalue of class or array type always has a
-result object. For a discarded prvalue that has type other than
-cv `void`, a temporary object is materialized; see
-[[expr.context]]. — *end note*]
-Whenever a glvalue appears as an operand of an operator that expects a
 prvalue for that operand, the lvalue-to-rvalue [[conv.lval]],
 array-to-pointer [[conv.array]], or function-to-pointer [[conv.func]]
 standard conversions are applied to convert the expression to a prvalue.
 [*Note 5*: An attempt to bind an rvalue reference to an lvalue is not
@@ -214,60 +212,69 @@ prvalue of type `int` is required. — *end note*]
 [*Note 7*: There are no prvalue bit-fields; if a bit-field is converted
 to a prvalue [[conv.lval]], a prvalue of the type of the bit-field is
 created, which might then be promoted [[conv.prom]]. — *end note*]
-Whenever a prvalue appears as an operand of an operator that expects a
-glvalue for that operand, the temporary materialization conversion
-[[conv.rval]] is applied to convert the expression to an xvalue.
-The discussion of reference initialization in  [[dcl.init.ref]] and of
-temporaries in  [[class.temporary]] indicates the behavior of lvalues
-and rvalues in other significant contexts.
 Unless otherwise indicated [[dcl.type.decltype]], a prvalue shall always
 have complete type or the `void` type; if it has a class type or
 (possibly multidimensional) array of class type, that class shall not be
 an abstract class [[class.abstract]]. A glvalue shall not have type
 cv `void`.
-[*Note 8*: A glvalue can have complete or incomplete non-`void` type.
 Class and array prvalues can have cv-qualified types; other prvalues
 always have cv-unqualified types. See [[expr.type]]. — *end note*]
 An lvalue is *modifiable* unless its type is const-qualified or is a
 function type.
-[*Note 9*: A program that attempts to modify an object through a
 nonmodifiable lvalue or through an rvalue is ill-formed
-[[expr.ass]], [[expr.post.incr]], [[expr.pre.incr]]. — *end note*]
-If a program attempts to access [[defns.access]] the stored value of an
-object through a glvalue whose type is not similar [[conv.qual]] to one
-of the following types the behavior is undefined:[^4]
-- the dynamic type of the object,
-- a type that is the signed or unsigned type corresponding to the
- dynamic type of the object, or
 - a `char`, `unsigned char`, or `std::byte` type.
 If a program invokes a defaulted copy/move constructor or copy/move
 assignment operator for a union of type `U` with a glvalue argument that
 does not denote an object of type cv `U` within its lifetime, the
 behavior is undefined.
-[*Note 10*: In C, an entire object of structure type can be accessed,
 e.g., using assignment. By contrast, C++ has no notion of accessing an
 object of class type through an lvalue of class type. — *end note*]
 ### Type <a id="expr.type">[[expr.type]]</a>
 If an expression initially has the type “reference to `T`”
 [[dcl.ref]], [[dcl.init.ref]], the type is adjusted to `T` prior to any
-further analysis. The expression designates the object or function
-denoted by the reference, and the expression is an lvalue or an xvalue,
-depending on the expression.
 [*Note 1*: Before the lifetime of the reference has started or after it
 has ended, the behavior is undefined (see
 [[basic.life]]). — *end note*]
@@ -287,15 +294,15 @@ pointer-to-member type or `std::nullptr_t`, is:
   “pointer to *cv12* `void`”, where *cv12* is the union of *cv1* and
   *cv2*;
 - if `T1` or `T2` is “pointer to `noexcept` function” and the other type
   is “pointer to function”, where the function types are otherwise the
   same, “pointer to function”;
-- if `T1` is “pointer to *cv1* `C1`” and `T2` is “pointer to *cv2*
- `C2`”, where `C1` is reference-related to `C2` or `C2` is
- reference-related to `C1` [[dcl.init.ref]], the qualification-combined
- type [[conv.qual]] of `T1` and `T2` or the qualification-combined type
- of `T2` and `T1`, respectively;
 - if `T1` or `T2` is “pointer to member of `C1` of type function”, the
   other type is “pointer to member of `C2` of type `noexcept` function”,
   and `C1` is reference-related to `C2` or `C2` is reference-related to
   `C1` [[dcl.init.ref]], where the function types are otherwise the
   same, “pointer to member of `C2` of type function” or “pointer to
@@ -327,11 +334,11 @@ pointer to `const int`”.
 — *end example*]
 ### Context dependence <a id="expr.context">[[expr.context]]</a>
 In some contexts, *unevaluated operands* appear
-[[expr.prim.req]], [[expr.typeid]], [[expr.sizeof]], [[expr.unary.noexcept]], [[dcl.type.decltype]], [[temp.pre]], [[temp.concept]].
 An unevaluated operand is not evaluated.
 [*Note 1*: In an unevaluated operand, a non-static class member can be
 named [[expr.prim.id]] and naming of objects or functions does not, by
 itself, require that a definition be provided [[basic.def.odr]]. An
@@ -345,10 +352,11 @@ standard conversions are not applied. The lvalue-to-rvalue conversion
 [[conv.lval]] is applied if and only if the expression is a glvalue of
 volatile-qualified type and it is one of the following:
 - `(` *expression* `)`, where *expression* is one of these expressions,
 - *id-expression* [[expr.prim.id]],
 - subscripting [[expr.sub]],
 - class member access [[expr.ref]],
 - indirection [[expr.unary.op]],
 - pointer-to-member operation [[expr.mptr.oper]],
 - conditional expression [[expr.cond]] where both the second and the
@@ -390,11 +398,12 @@ following order:
 [*Note 1*: A standard conversion sequence can be empty, i.e., it can
 consist of no conversions. — *end note*]
 A standard conversion sequence will be applied to an expression if
-necessary to convert it to a required destination type.
 [*Note 2*:
 Expressions with a given type will be implicitly converted to other
 types in several contexts:
@@ -412,12 +421,12 @@ types in several contexts:
   [[dcl.init.ref]].
 — *end note*]
 An expression E can be *implicitly converted* to a type `T` if and only
-if the declaration `T t=E;` is well-formed, for some invented temporary
-variable `t` [[dcl.init]].
 Certain language constructs require that an expression be converted to a
 Boolean value. An expression E appearing in such a context is said to be
 *contextually converted to `bool`* and is well-formed if and only if the
 declaration `bool t(E);` is well-formed, for some invented temporary
@@ -497,15 +506,30 @@ rules:
   `T` is volatile-qualified [[intro.execution]], and the glvalue can
   refer to an inactive member of a union [[class.union]]. — *end note*]
 - Otherwise, if `T` has a class type, the conversion copy-initializes
   the result object from the glvalue.
 - Otherwise, if the object to which the glvalue refers contains an
-  invalid pointer value [[basic.stc.dynamic.deallocation]], the behavior
- is *implementation-defined*.
 - Otherwise, the object indicated by the glvalue is read
-  [[defns.access]], and the value contained in the object is the prvalue
-  result.
 [*Note 2*: See also  [[basic.lval]]. — *end note*]
 ### Array-to-pointer conversion <a id="conv.array">[[conv.array]]</a>
@@ -554,14 +578,10 @@ element type are also taken as the cv-qualifiers cvᵢ of the array.
 [*Example 1*: The type denoted by the *type-id* `const int **` has
 three qualification-decompositions, taking `U` as “`int`”, as “pointer
 to `const int`”, and as “pointer to pointer to
 `const int`”. — *end example*]
-The n-tuple of cv-qualifiers after the first one in the longest
-qualification-decomposition of `T`, that is, cv₁, cv₂, …, cvₙ, is called
-the *cv-qualification signature* of `T`.
 Two types `T1` and `T2` are *similar* if they have
 qualification-decompositions with the same n such that corresponding Pᵢ
 components are either the same or one is “array of Nᵢ” and the other is
 “array of unknown bound of”, and the types denoted by `U` are the same.
@@ -613,24 +633,20 @@ than “*cv1* `T`”. — *end note*]
 pointer-to-member-function types) are never cv-qualified
 [[dcl.fct]]. — *end note*]
 ### Integral promotions <a id="conv.prom">[[conv.prom]]</a>
-A prvalue of an integer type other than `bool`, `char8_t`, `char16_t`,
-`char32_t`, or `wchar_t` whose integer conversion rank [[conv.rank]] is
-less than the rank of `int` can be converted to a prvalue of type `int`
-if `int` can represent all the values of the source type; otherwise, the
-source prvalue can be converted to a prvalue of type `unsigned int`.
-A prvalue of type `char8_t`, `char16_t`, `char32_t`, or `wchar_t`
-[[basic.fundamental]] can be converted to a prvalue of the first of the
-following types that can represent all the values of its underlying
-type: `int`, `unsigned int`, `long int`, `unsigned long int`,
-`long long int`, or `unsigned long long int`. If none of the types in
-that list can represent all the values of its underlying type, a prvalue
-of type `char8_t`, `char16_t`, `char32_t`, or `wchar_t` can be converted
-to a prvalue of its underlying type.
 A prvalue of an unscoped enumeration type whose underlying type is not
 fixed can be converted to a prvalue of the first of the following types
 that can represent all the values of the enumeration [[dcl.enum]]:
 `int`, `unsigned int`, `long int`, `unsigned long int`, `long long int`,
@@ -646,17 +662,25 @@ A prvalue of an unscoped enumeration type whose underlying type is fixed
 [[dcl.enum]] can be converted to a prvalue of its underlying type.
 Moreover, if integral promotion can be applied to its underlying type, a
 prvalue of an unscoped enumeration type whose underlying type is fixed
 can also be converted to a prvalue of the promoted underlying type.
-A prvalue for an integral bit-field [[class.bit]] can be converted to a
-prvalue of type `int` if `int` can represent all the values of the
-bit-field; otherwise, it can be converted to `unsigned int` if
-`unsigned int` can represent all the values of the bit-field. If the
-bit-field is larger yet, no integral promotion applies to it. If the
-bit-field has enumeration type, it is treated as any other value of that
-type for promotion purposes.
 A prvalue of type `bool` can be converted to a prvalue of type `int`,
 with `false` becoming zero and `true` becoming one.
 These conversions are called *integral promotions*.
@@ -732,60 +756,64 @@ to one.
 A *null pointer constant* is an integer literal [[lex.icon]] with value
 zero or a prvalue of type `std::nullptr_t`. A null pointer constant can
 be converted to a pointer type; the result is the null pointer value of
 that type [[basic.compound]] and is distinguishable from every other
 value of object pointer or function pointer type. Such a conversion is
-called a *null pointer conversion*. Two null pointer values of the same
-type shall compare equal. The conversion of a null pointer constant to a
-pointer to cv-qualified type is a single conversion, and not the
-sequence of a pointer conversion followed by a qualification conversion
-[[conv.qual]]. A null pointer constant of integral type can be converted
-to a prvalue of type `std::nullptr_t`.
 [*Note 1*: The resulting prvalue is not a null pointer
 value. — *end note*]
 A prvalue of type “pointer to cv `T`”, where `T` is an object type, can
 be converted to a prvalue of type “pointer to cv `void`”. The pointer
 value [[basic.compound]] is unchanged by this conversion.
-A prvalue of type “pointer to cv `D`”, where `D` is a complete class
 type, can be converted to a prvalue of type “pointer to cv `B`”, where
 `B` is a base class [[class.derived]] of `D`. If `B` is an inaccessible
 [[class.access]] or ambiguous [[class.member.lookup]] base class of `D`,
-a program that necessitates this conversion is ill-formed. The result of
-the conversion is a pointer to the base class subobject of the derived
-class object. The null pointer value is converted to the null pointer
-value of the destination type.
 ### Pointer-to-member conversions <a id="conv.mem">[[conv.mem]]</a>
 A null pointer constant [[conv.ptr]] can be converted to a
 pointer-to-member type; the result is the *null member pointer value* of
 that type and is distinguishable from any pointer to member not created
 from a null pointer constant. Such a conversion is called a *null member
-pointer conversion*. Two null member pointer values of the same type
-shall compare equal. The conversion of a null pointer constant to a
 pointer to member of cv-qualified type is a single conversion, and not
 the sequence of a pointer-to-member conversion followed by a
 qualification conversion [[conv.qual]].
 A prvalue of type “pointer to member of `B` of type cv `T`”, where `B`
 is a class type, can be converted to a prvalue of type “pointer to
 member of `D` of type cv `T`”, where `D` is a complete class derived
 [[class.derived]] from `B`. If `B` is an inaccessible [[class.access]],
 ambiguous [[class.member.lookup]], or virtual [[class.mi]] base class of
 `D`, or a base class of a virtual base class of `D`, a program that
-necessitates this conversion is ill-formed. The result of the conversion
-refers to the same member as the pointer to member before the conversion
-took place, but it refers to the base class member as if it were a
-member of the derived class. The result refers to the member in `D`’s
-instance of `B`. Since the result has type “pointer to member of `D` of
-type cv `T`”, indirection through it with a `D` object is valid. The
-result is the same as if indirecting through the pointer to member of
-`B` with the `B` subobject of `D`. The null member pointer value is
-converted to the null member pointer value of the destination type.[^8]
 ### Function pointer conversions <a id="conv.fctptr">[[conv.fctptr]]</a>
 A prvalue of type “pointer to `noexcept` function” can be converted to a
 prvalue of type “pointer to function”. The result is a pointer to the
@@ -818,17 +846,23 @@ Many binary operators that expect operands of arithmetic or enumeration
 type cause conversions and yield result types in a similar way. The
 purpose is to yield a common type, which is also the type of the result.
 This pattern is called the *usual arithmetic conversions*, which are
 defined as follows:
 - If either operand is of scoped enumeration type [[dcl.enum]], no
   conversions are performed; if the other operand does not have the same
   type, the expression is ill-formed.
 - Otherwise, if either operand is of floating-point type, the following
   rules are applied:
   - If both operands have the same type, no further conversion is
- needed.
   - Otherwise, if one of the operands is of a non-floating-point type,
     that operand is converted to the type of the operand with the
     floating-point type.
   - Otherwise, if the floating-point conversion ranks [[conv.rank]] of
     the types of the operands are ordered but not equal, then the
@@ -852,25 +886,24 @@ defined as follows:
       `U`.
     - Otherwise, if `S` can represent all of the values of `U`, `C` is
       `S`.
     - Otherwise, `C` is the unsigned integer type corresponding to `S`.
-If one operand is of enumeration type and the other operand is of a
-different enumeration type or a floating-point type, this behavior is
-deprecated [[depr.arith.conv.enum]].
 ## Primary expressions <a id="expr.prim">[[expr.prim]]</a>
 ``` bnf
 primary-expression:
     literal
     this
     '(' expression ')'
     id-expression
     lambda-expression
     fold-expression
     requires-expression
 ```
 ### Literals <a id="expr.prim.literal">[[expr.prim.literal]]</a>
 The type of a *literal* is determined based on its form as specified in
@@ -890,19 +923,26 @@ The *current class* at a program point is the class associated with the
 innermost class scope containing that point.
 [*Note 1*: A *lambda-expression* does not introduce a class
 scope. — *end note*]
 If a declaration declares a member function or member function template
 of a class `X`, the expression `this` is a prvalue of type “pointer to
 *cv-qualifier-seq* `X`” wherever `X` is the current class between the
 optional *cv-qualifier-seq* and the end of the *function-definition*,
 *member-declarator*, or *declarator*. It shall not appear within the
-declaration of either a static member function or an explicit object
-member function of the current class (although its type and value
-category are defined within such member functions as they are within an
-implicit object member function).
 [*Note 2*: This is because declaration matching does not occur until
 the complete declarator is known. — *end note*]
 [*Note 3*:
@@ -966,62 +1006,104 @@ otherwise indicated.
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
 ```
 An *id-expression* is a restricted form of a *primary-expression*.
 [*Note 1*: An *id-expression* can appear after `.` and `->` operators
 [[expr.ref]]. — *end note*]
 If an *id-expression* E denotes a member M of an anonymous union
 [[class.union.anon]] U:
 - If U is a non-static data member, E refers to M as a member of the
-  lookup context of the terminal name of E (after any transformation to
-  a class member access expression [[class.mfct.non.static]]).
-  \[*Example 1*: `o.x` is interpreted as `o.u.x`, where u names the
   anonymous union member. — *end example*]
 - Otherwise, E is interpreted as a class member access [[expr.ref]] that
   designates the member subobject M of the anonymous union variable for
-  U. \[*Note 2*: Under this interpretation, E no longer denotes a
-  non-static data member. — *end note*] \[*Example 2*: `N::x` is
   interpreted as `N::u.x`, where u names the anonymous union
   variable. — *end example*]
-An *id-expression* that denotes a non-static data member or implicit
-object member function of a class can only be used:
-- as part of a class member access [[expr.ref]] in which the object
-  expression refers to the member’s class[^10] or a class derived from
-  that class, or
 - to form a pointer to member [[expr.unary.op]], or
-- if that *id-expression* denotes a non-static data member and it
-  appears in an unevaluated operand.
-  \[*Example 3*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
   ```
   — *end example*]
 For an *id-expression* that denotes an overload set, overload resolution
 is performed to select a unique function [[over.match]], [[over.over]].
-[*Note 3*:
 A program cannot refer to a function with a trailing *requires-clause*
 whose *constraint-expression* is not satisfied, because such functions
 are never selected by overload resolution.
-[*Example 4*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
 };
@@ -1032,12 +1114,12 @@ void g() {
   decltype(A<int>::f)* p2 = nullptr;    // error: the type decltype(A<int>::f) is invalid
 }
 ```
 In each case, the constraints of `f` are not satisfied. In the
-declaration of `p2`, those constraints are required to be satisfied even
-though `f` is an unevaluated operand [[term.unevaluated.operand]].
 — *end example*]
 — *end note*]
@@ -1048,27 +1130,24 @@ unqualified-id:
     identifier
     operator-function-id
     conversion-function-id
     literal-operator-id
     '~' type-name
-    '~' decltype-specifier
     template-id
 ```
 An *identifier* is only an *id-expression* if it has been suitably
-declared [[dcl.dcl]] or if it appears as part of a *declarator-id*
-[[dcl.decl]]. An *identifier* that names a coroutine parameter refers to
-the copy of the parameter [[dcl.fct.def.coroutine]].
 [*Note 1*: For *operator-function-id*s, see  [[over.oper]]; for
 *conversion-function-id*s, see  [[class.conv.fct]]; for
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
-[[temp.names]]. A *type-name* or *decltype-specifier* prefixed by `~`
-denotes the destructor of the type so named; see  [[expr.prim.id.dtor]].
-Within the definition of a non-static member function, an *identifier*
-that names a non-static member is transformed to a class member access
-expression [[class.mfct.non.static]]. — *end note*]
 A *component name* of an *unqualified-id* U is
 - U if it is a name or
 - the component name of the *template-id* or *type-name* of U, if any.
@@ -1079,46 +1158,147 @@ several component names
 The *terminal name* of a construct is the component name of that
 construct that appears lexically last.
 The result is the entity denoted by the *unqualified-id*
-[[basic.lookup.unqual]]. If the *unqualified-id* appears in a
-*lambda-expression* at program point P and the entity is a local entity
-[[basic.pre]] or a variable declared by an *init-capture*
-[[expr.prim.lambda.capture]], then let S be the *compound-statement* of
-the innermost enclosing *lambda-expression* of P. If naming the entity
-from outside of an unevaluated operand within S would refer to an entity
-captured by copy in some intervening *lambda-expression*, then let E be
-the innermost such *lambda-expression*.
-- If there is such a *lambda-expression* and if P is in E’s function
- parameter scope but not its *parameter-declaration-clause*, then the
- type of the expression is the type of a class member access expression
-  [[expr.ref]] naming the non-static data member that would be declared
- for such a capture in the object parameter [[dcl.fct]] of the function
- call operator of E. \[*Note 3*: If E is not declared `mutable`, the
-  type of such an identifier will typically be `const`
-  qualified. — *end note*]
-- Otherwise (if there is no such *lambda-expression* or if P either
-  precedes E’s function parameter scope or is in E’s
-  *parameter-declaration-clause*), the type of the expression is the
-  type of the result.
-[*Note 4*: If the entity is a template parameter object for a template
 parameter of type `T` [[temp.param]], the type of the expression is
-`const T`. — *end note*]
-[*Note 5*: The type will be adjusted as described in [[expr.type]] if
 it is cv-qualified or is a reference type. — *end note*]
 The expression is an xvalue if it is move-eligible (see below); an
 lvalue if the entity is a function, variable, structured binding
-[[dcl.struct.bind]], data member, or template parameter object; and a
-prvalue otherwise [[basic.lval]]; it is a bit-field if the identifier
-designates a bit-field.
-[*Example 1*:
 ``` cpp
 void f() {
   float x, &r = x;
@@ -1145,27 +1325,23 @@ void f() {
 }
 ```
 — *end example*]
-An *implicitly movable entity* is a variable of automatic storage
 duration that is either a non-volatile object or an rvalue reference to
-a non-volatile object type. In the following contexts, an
-*id-expression* is *move-eligible*:
-- If the *id-expression* (possibly parenthesized) is the operand of a
-  `return` [[stmt.return]] or `co_return` [[stmt.return.coroutine]]
- statement, and names an implicitly movable entity declared in the body
- or *parameter-declaration-clause* of the innermost enclosing function
-  or *lambda-expression*, or
-- if the *id-expression* (possibly parenthesized) is the operand of a
-  *throw-expression* [[expr.throw]], and names an implicitly movable
- entity that belongs to a scope that does not contain the
-  *compound-statement* of the innermost *lambda-expression*,
-  *try-block*, or *function-try-block* (if any) whose
-  *compound-statement* or *ctor-initializer* contains the
-  *throw-expression*.
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
@@ -1175,71 +1351,152 @@ qualified-id:
 ``` bnf
 nested-name-specifier:
     '::'
     type-name '::'
     namespace-name '::'
- decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
 The component names of a *qualified-id* are those of its
 *nested-name-specifier* and *unqualified-id*. The component names of a
 *nested-name-specifier* are its *identifier* (if any) and those of its
 *type-name*, *namespace-name*, *simple-template-id*, and/or
 *nested-name-specifier*.
 A *nested-name-specifier* is *declarative* if it is part of
 - a *class-head-name*,
 - an *enum-head-name*,
 - 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
-*decltype-specifier*. 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.
-The *nested-name-specifier* `::` nominates the global namespace. A
-*nested-name-specifier* with a *decltype-specifier* nominates the type
-denoted by the *decltype-specifier*, which shall be a class or
-enumeration type. 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 by N without A. T
   shall be a class template.
   - If A is the template argument list [[temp.arg]] of the corresponding
- *template-head* H [[temp.mem]], N nominates the primary template of T;
- H shall be equivalent to the *template-head* of T [[temp.over.link]].
-- Otherwise, N nominates the partial specialization
- [[temp.spec.partial]] of T whose template argument list is equivalent
-  to A [[temp.over.link]]; the program is ill-formed if no such partial
-  specialization exists.
-Any other *nested-name-specifier* nominates the entity denoted 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.
 A *qualified-id* shall not be of the form *nested-name-specifier*
-`template`ₒₚₜ  `~` *decltype-specifier* nor of the form
-*decltype-specifier* `::` `~` *type-name*.
 The result of a *qualified-id* Q is the entity it denotes
-[[basic.lookup.qual]]. The type of the expression is the type of the
-result. The result is an lvalue if the member is
 - a function other than a non-static member function,
 - a non-static member function if Q is the operand of a unary `&`
   operator,
 - a variable,
 - a structured binding [[dcl.struct.bind]], or
 - a data member,
 and a prvalue otherwise.
 #### Destruction <a id="expr.prim.id.dtor">[[expr.prim.id.dtor]]</a>
 An *id-expression* that denotes the destructor of a type `T` names the
 destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 *id-expression* is said to name a *pseudo-destructor*.
@@ -1286,14 +1543,15 @@ lambda-introducer:
 ```
 ``` bnf
 lambda-declarator:
     lambda-specifier-seq noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
-    noexcept-specifier attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
-    trailing-return-typeₒₚₜ
     '(' parameter-declaration-clause ')' lambda-specifier-seqₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
-       trailing-return-typeₒₚₜ requires-clauseₒₚₜ
 ```
 ``` bnf
 lambda-specifier:
     consteval
@@ -1302,12 +1560,11 @@ lambda-specifier:
     static
 ```
 ``` bnf
 lambda-specifier-seq:
-    lambda-specifier
-    lambda-specifier lambda-specifier-seq
 ```
 A *lambda-expression* provides a concise way to create a simple function
 object.
@@ -1333,12 +1590,24 @@ An ambiguity can arise because a *requires-clause* can end in an
 *attribute-specifier-seq*, which collides with the
 *attribute-specifier-seq* in *lambda-expression*. In such cases, any
 attributes are treated as *attribute-specifier-seq* in
 *lambda-expression*.
-[*Note 2*: Such ambiguous cases cannot have valid semantics because the
-constraint expression would not have type `bool`. — *end note*]
 A *lambda-specifier-seq* shall contain at most one of each
 *lambda-specifier* and shall not contain both `constexpr` and
 `consteval`. If the *lambda-declarator* contains an explicit object
 parameter [[dcl.fct]], then no *lambda-specifier* in the
@@ -1348,19 +1617,20 @@ the *lambda-specifier-seq* contains `static`, there shall be no
 *lambda-capture*.
 [*Note 3*: The trailing *requires-clause* is described in
 [[dcl.decl]]. — *end note*]
-If a *lambda-declarator* does not include a
-*parameter-declaration-clause*, it is as if `()` were inserted at the
-start of the *lambda-declarator*. If the *lambda-declarator* does not
-include a *trailing-return-type*, it is considered to be `-> auto`.
 [*Note 4*: In that case, the return type is deduced from `return`
 statements as described in [[dcl.spec.auto]]. — *end note*]
-[*Example 2*:
 ``` cpp
 auto x1 = [](int i) { return i; };      // OK, return type is int
 auto x2 = []{ return { 1, 2 }; };       // error: deducing return type from braced-init-list
 int j;
@@ -1371,53 +1641,62 @@ auto x3 = [&]()->auto&& { return j; };  // OK, return type is int&
 A lambda is a *generic lambda* if the *lambda-expression* has any
 generic parameter type placeholders [[dcl.spec.auto]], or if the lambda
 has a *template-parameter-list*.
-[*Example 3*:
 ``` cpp
-int i = [](int i, auto a) { return i; }(3, 4); // OK, a generic lambda
-int j = []<class T>(T t, int i) { return i; }(3, 4); // OK, a generic lambda
 ```
 — *end example*]
 #### Closure types <a id="expr.prim.lambda.closure">[[expr.prim.lambda.closure]]</a>
 The type of a *lambda-expression* (which is also the type of the closure
 object) is a unique, unnamed non-union class type, called the *closure
 type*, whose properties are described below.
 The closure type is declared in the smallest block scope, class scope,
 or namespace scope that contains the corresponding *lambda-expression*.
 [*Note 1*: This determines the set of namespaces and classes associated
 with the closure type [[basic.lookup.argdep]]. The parameter types of a
 *lambda-declarator* do not affect these associated namespaces and
 classes. — *end note*]
-The closure type is not an aggregate type [[dcl.init.aggr]]. An
-implementation may define the closure type differently from what is
-described below provided this does not alter the observable behavior of
-the program other than by changing:
 - the size and/or alignment of the closure type,
-- whether the closure type is trivially copyable [[class.prop]], or
 - whether the closure type is a standard-layout class [[class.prop]].
 An implementation shall not add members of rvalue reference type to the
 closure type.
 The closure type for a *lambda-expression* has a public inline function
 call operator (for a non-generic lambda) or function call operator
 template (for a generic lambda) [[over.call]] whose parameters and
-return type are described by the *lambda-expression*’s
 *parameter-declaration-clause* and *trailing-return-type* respectively,
 and whose *template-parameter-list* consists of the specified
-*template-parameter-list*, if any. The *requires-clause* of the function
-call operator template is the *requires-clause* immediately following
 `<` *template-parameter-list* `>`, if any. The trailing
 *requires-clause* of the function call operator or operator template is
 the *requires-clause* of the *lambda-declarator*, if any.
 [*Note 2*: The function call operator template for a generic lambda can
@@ -1454,11 +1733,12 @@ std::cout << fact(5);                                           // OK, outputs 1
 Given a lambda with a *lambda-capture*, the type of the explicit object
 parameter, if any, of the lambda’s function call operator (possibly
 instantiated from a function call operator template) shall be either:
 - the closure type,
-- a class type derived from the closure type, or
 - a reference to a possibly cv-qualified such type.
 [*Example 2*:
 ``` cpp
@@ -1482,13 +1762,14 @@ function or static member function template [[class.static.mfct]] if the
 `static`. Otherwise, it is a non-static member function or member
 function template [[class.mfct.non.static]] that is declared `const`
 [[class.mfct.non.static]] if and only if the *lambda-expression*’s
 *parameter-declaration-clause* is not followed by `mutable` and the
 *lambda-declarator* does not contain an explicit object parameter. It is
-neither virtual nor declared `volatile`. Any *noexcept-specifier*
-specified on a *lambda-expression* applies to the corresponding function
-call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-declarator* appertains to the type of the corresponding function
 call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-expression* preceding a *lambda-declarator* appertains to the
 corresponding function call operator or operator template. The function
 call operator or any given operator template specialization is a
@@ -1567,35 +1848,80 @@ auto f = []<typename T1, C1 T2> requires C2<sizeof(T1) + sizeof(T2)>
 — *end example*]
 — *end note*]
 The closure type for a non-generic *lambda-expression* with no
-*lambda-capture* whose constraints (if any) are satisfied has a
-conversion function to pointer to function with C++ language linkage
-[[dcl.link]] having the same parameter and return types as the closure
-type’s function call operator. The conversion is to “pointer to
-`noexcept` function” if the function call operator has a non-throwing
-exception specification. If the function call operator is a static
-member function, then the value returned by this conversion function is
-the address of the function call operator. Otherwise, the value returned
-by this conversion function is the address of a function `F` that, when
-invoked, has the same effect as invoking the closure type’s function
-call operator on a default-constructed instance of the closure type. `F`
-is a constexpr function if the function call operator is a constexpr
-function and is an immediate function if the function call operator is
-an immediate function.
-For a generic lambda with no *lambda-capture*, the closure type has a
-conversion function template to pointer to function. The conversion
-function template has the same invented template parameter list, and the
-pointer to function has the same parameter types, as the function call
-operator template. The return type of the pointer to function shall
-behave as if it were a *decltype-specifier* denoting the return type of
-the corresponding function call operator template specialization.
-[*Note 4*:
 If the generic lambda has no *trailing-return-type* or the
 *trailing-return-type* contains a placeholder type, return type
 deduction of the corresponding function call operator template
 specialization has to be done. The corresponding specialization is that
@@ -1627,11 +1953,11 @@ struct Closure {
 };
 ```
 — *end note*]
-[*Example 6*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
@@ -1651,27 +1977,26 @@ int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; };        // OK
 — *end example*]
 If the function call operator template is a static member function
 template, then the value returned by any given specialization of this
-conversion function template is the address of the corresponding
-function call operator template specialization. Otherwise, the value
-returned by any given specialization of this conversion function
-template is the address of a function `F` that, when invoked, has the
-same effect as invoking the generic lambda’s corresponding function call
-operator template specialization on a default-constructed instance of
-the closure type. `F` is a constexpr function if the corresponding
-specialization is a constexpr function and `F` is an immediate function
-if the function call operator template specialization is an immediate
-function.
-[*Note 5*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
-parameter types are required to match the return type and parameter
-types of the pointer to function. — *end note*]
-[*Example 7*:
 ``` cpp
 auto GL = [](auto a) { std::cout << a; return a; };
 int (*GL_int)(int) = GL;        // OK, through conversion function template
 GL_int(3);                      // OK, same as GL(3)
@@ -1681,11 +2006,11 @@ GL_int(3);                      // OK, same as GL(3)
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing
 exception specification [[except.spec]].
-[*Example 8*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
@@ -1700,11 +2025,11 @@ static_assert(Fwd(NC,3) == 3);  // error
 The *lambda-expression*’s *compound-statement* yields the
 *function-body* [[dcl.fct.def]] of the function call operator, but it is
 not within the scope of the closure type.
-[*Example 9*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
@@ -1717,23 +2042,25 @@ struct S1 {
 };
 ```
 — *end example*]
-Further, a variable `__func__` is implicitly defined at the beginning of
-the *compound-statement* of the *lambda-expression*, with semantics as
-described in  [[dcl.fct.def.general]].
 The closure type associated with a *lambda-expression* has no default
 constructor if the *lambda-expression* has a *lambda-capture* and a
 defaulted default constructor otherwise. It has a defaulted copy
 constructor and a defaulted move constructor [[class.copy.ctor]]. It has
 a deleted copy assignment operator if the *lambda-expression* has a
 *lambda-capture* and defaulted copy and move assignment operators
 otherwise [[class.copy.assign]].
-[*Note 6*: These special member functions are implicitly defined as
 usual, which can result in them being defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].
@@ -1771,30 +2098,30 @@ capture:
 ``` bnf
 simple-capture:
     identifier '...'ₒₚₜ
     '&' identifier '...'ₒₚₜ
     this
-    '*' 'this'
 ```
 ``` bnf
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
 The body of a *lambda-expression* may refer to local entities of
-enclosing block scopes by capturing those entities, as described below.
 If a *lambda-capture* includes a *capture-default* that is `&`, no
 identifier in a *simple-capture* of that *lambda-capture* shall be
 preceded by `&`. If a *lambda-capture* includes a *capture-default* that
 is `=`, each *simple-capture* of that *lambda-capture* shall be of the
 form “`&` *identifier* `...`ₒₚₜ ”, “`this`”, or “`* this`”.
 [*Note 1*: The form `[&,this]` is redundant but accepted for
-compatibility with ISO C++14. — *end note*]
 Ignoring appearances in *initializer*s of *init-capture*s, an identifier
 or `this` shall not appear more than once in a *lambda-capture*.
 [*Example 1*:
@@ -1813,14 +2140,19 @@ void S2::f(int i) {
 ```
 — *end example*]
 A *lambda-expression* shall not have a *capture-default* or
-*simple-capture* in its *lambda-introducer* unless its innermost
-enclosing scope is a block scope [[basic.scope.block]] or it appears
-within a default member initializer and its innermost enclosing scope is
-the corresponding class scope [[basic.scope.class]].
 The *identifier* in a *simple-capture* shall denote a local entity
 [[basic.lookup.unqual]], [[basic.pre]]. The *simple-capture*s `this` and
 `* this` denote the local entity `*this`. An entity that is designated
 by a *simple-capture* is said to be *explicitly captured*.
@@ -2038,11 +2370,12 @@ void f2() {
 An entity is *captured by copy* if
 - it is implicitly captured, the *capture-default* is `=`, and the
   captured entity is not `*this`, or
 - it is explicitly captured with a capture that is not of the form
-  `this`, `&` *identifier*, or `&` *identifier* *initializer*.
 For each entity captured by copy, an unnamed non-static data member is
 declared in the closure type. The declaration order of these members is
 unspecified. The type of such a data member is the referenced type if
 the entity is a reference to an object, an lvalue reference to the
@@ -2069,11 +2402,11 @@ the closure type.
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
-    int arr[N];     // OK, not an odr-use, refers to automatic variable
     f(&N);          // OK, causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```
@@ -2240,10 +2573,12 @@ bool f(Args ...args) {
 }
 ```
 — *end example*]
 ### Requires expressions <a id="expr.prim.req">[[expr.prim.req]]</a>
 #### General <a id="expr.prim.req.general">[[expr.prim.req.general]]</a>
 A *requires-expression* provides a concise way to express requirements
@@ -2265,12 +2600,11 @@ requirement-body:
     '{' requirement-seq '}'
 ```
 ``` bnf
 requirement-seq:
-    requirement
-    requirement requirement-seq
 ```
 ``` bnf
 requirement:
     simple-requirement
@@ -2278,12 +2612,11 @@ requirement:
     compound-requirement
     nested-requirement
 ```
 A *requires-expression* is a prvalue of type `bool` whose value is
-described below. Expressions appearing within a *requirement-body* are
-unevaluated operands [[term.unevaluated.operand]].
 [*Example 1*:
 A common use of *requires-expression*s is to define requirements in
 concepts such as the one below:
@@ -2310,38 +2643,43 @@ The first `requires` introduces the *requires-clause*, and the second
 introduces the *requires-expression*.
 — *end example*]
 A *requires-expression* may introduce local parameters using a
-*parameter-declaration-clause* [[dcl.fct]]. A local parameter of a
-*requires-expression* shall not have a default argument. These
-parameters have no linkage, storage, or lifetime; they are only used as
-notation for the purpose of defining *requirement*s. The
-*parameter-declaration-clause* of a *requirement-parameter-list* shall
-not terminate with an ellipsis.
 [*Example 2*:
 ``` cpp
 template<typename T>
 concept C = requires(T t, ...) {    // error: terminates with an ellipsis
   t;
 };
 ```
 — *end example*]
-The substitution of template arguments into a *requires-expression* may
-result in the formation of invalid types or expressions in its
-*requirement*s or the violation of the semantic constraints of those
-*requirement*s. In such cases, the *requires-expression* evaluates to
-`false`; it does not cause the program to be ill-formed. The
-substitution and semantic constraint checking proceeds in lexical order
-and stops when a condition that determines the result of the
-*requires-expression* is encountered. If substitution (if any) and
-semantic constraint checking succeed, the *requires-expression*
-evaluates to `true`.
 [*Note 1*: If a *requires-expression* contains invalid types or
 expressions in its *requirement*s, and it does not appear within the
 declaration of a templated entity, then the program is
 ill-formed. — *end note*]
@@ -2353,11 +2691,11 @@ diagnostic required.
 [*Example 3*:
 ``` cpp
 template<typename T> concept C =
 requires {
-  new int[-(int)sizeof(T)]; // ill-formed, no diagnostic required
 };
 ```
 — *end example*]
@@ -2366,16 +2704,16 @@ requires {
 ``` bnf
 simple-requirement:
     expression ';'
 ```
-A *simple-requirement* asserts the validity of an *expression*.
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
-if substitution of template arguments into the *expression* fails. The
-*expression* is an unevaluated operand
-[[term.unevaluated.operand]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename T> concept C =
@@ -2395,13 +2733,17 @@ as a *simple-requirement*.
 #### Type requirements <a id="expr.prim.req.type">[[expr.prim.req.type]]</a>
 ``` bnf
 type-requirement:
     typename nested-name-specifierₒₚₜ type-name ';'
 ```
-A *type-requirement* asserts the validity of a type.
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
 if substitution of template arguments fails. — *end note*]
 [*Example 1*:
@@ -2410,13 +2752,15 @@ if substitution of template arguments fails. — *end note*]
 template<typename T, typename T::type = 0> struct S;
 template<typename T> using Ref = T&;
 template<typename T> concept C = requires {
   typename T::inner;        // required nested member name
-  typename S<T>; // required valid[temp.names] template-id;
- // fails if T::type does not exist as a type to which 0 can be implicitly converted
   typename Ref<T>;          // required alias template substitution, fails if T is void
 };
 ```
 — *end example*]
@@ -2433,13 +2777,14 @@ compound-requirement:
 ``` bnf
 return-type-requirement:
     '->' type-constraint
 ```
-A *compound-requirement* asserts properties of the *expression* E.
-Substitution of template arguments (if any) and verification of semantic
-properties proceed in the following order:
 - Substitution of template arguments (if any) into the *expression* is
   performed.
 - If the `noexcept` specifier is present, E shall not be a
   potentially-throwing expression [[except.spec]].
@@ -2529,10 +2874,115 @@ template<typename T> concept D = requires (T t) {
 `D<T>` is satisfied if `sizeof(decltype (+t)) == 1`
 [[temp.constr.atomic]].
 — *end example*]
 ## Compound expressions <a id="expr.compound">[[expr.compound]]</a>
 ### Postfix expressions <a id="expr.post">[[expr.post]]</a>
 #### General <a id="expr.post.general">[[expr.post.general]]</a>
@@ -2546,12 +2996,14 @@ postfix-expression:
     postfix-expression '(' expression-listₒₚₜ ')'
     simple-type-specifier '(' expression-listₒₚₜ ')'
     typename-specifier '(' expression-listₒₚₜ ')'
     simple-type-specifier braced-init-list
     typename-specifier braced-init-list
-    postfix-expression '.' 'template'ₒₚₜ id-expression
-    postfix-expression '->' 'template'ₒₚₜ id-expression
     postfix-expression '++'
     postfix-expression '--'
     dynamic_cast '<' type-id '>' '(' expression ')'
     static_cast '<' type-id '>' '(' expression ')'
     reinterpret_cast '<' type-id '>' '(' expression ')'
@@ -2574,23 +3026,24 @@ replacing a `>>` token by two consecutive `>` tokens
 A *subscript expression* is a postfix expression followed by square
 brackets containing a possibly empty, comma-separated list of
 *initializer-clause*s that constitute the arguments to the subscript
 operator. The *postfix-expression* and the initialization of the object
-parameter of any applicable subscript operator function is sequenced
-before each expression in the *expression-list* and also before any
-default argument. The initialization of a non-object parameter of a
-subscript operator function `S` [[over.sub]], including every associated
-value computation and side effect, is indeterminately sequenced with
-respect to that of any other non-object parameter of `S`.
 With the built-in subscript operator, an *expression-list* shall be
 present, consisting of a single *assignment-expression*. One of the
 expressions shall be a glvalue of type “array of `T`” or a prvalue of
 type “pointer to `T`” and the other shall be a prvalue of unscoped
 enumeration or integral type. The result is of type “`T`”. The type
-“`T`” shall be a completely-defined object type.[^11]
 The expression `E1[E2]` is identical (by definition) to `*((E1)+(E2))`,
 except that in the case of an array operand, the result is an lvalue if
 that operand is an lvalue and an xvalue otherwise.
@@ -2603,20 +3056,20 @@ of array types. — *end note*]
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
-[*Note 1*: If the postfix expression is a function or member function
-name, the appropriate function and the validity of the call are
-determined according to the rules in  [[over.match]]. — *end note*]
 The postfix expression shall have function type or function pointer
 type. For a call to a non-member function or to a static member
-function, the postfix expression shall either be an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
-[[conv.func]] is suppressed on the postfix expression), or have function
-pointer type.
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
@@ -2625,14 +3078,13 @@ type of the object expression is called; such a call is referred to as a
 [*Note 2*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
-[*Note 3*: If a function or member function name is used, and name
-lookup [[basic.lookup]] does not find a declaration of that name, the
-program is ill-formed. No function is implicitly declared by such a
-call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
@@ -2641,41 +3093,44 @@ different. If the *postfix-expression* names a pseudo-destructor (in
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
 denoted by the object expression of the class member access
 [[expr.ref]], [[basic.life]].
-Calling a function through an expression whose function type `E` is
-different from the function type `F` of the called function’s definition
-results in undefined behavior unless the type “pointer to `F`” can be
-converted to the type “pointer to `E`” via a function pointer conversion
-[[conv.fctptr]].
-[*Note 4*: The exception applies when the expression has the type of a
-potentially-throwing function, but the called function has a
 non-throwing exception specification, and the function types are
 otherwise the same. — *end note*]
 When a function is called, each parameter [[dcl.fct]] is initialized
-[[dcl.init]], [[class.copy.ctor]] with its corresponding argument. If
-the function is an explicit object member function and there is an
-implied object argument [[over.call.func]], the list of provided
-arguments is preceded by the implied object argument for the purposes of
-this correspondence. If there is no corresponding argument, the default
-argument for the parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
-If the function is an implicit object member function, the `this`
-parameter of the function [[expr.prim.this]] is initialized with a
-pointer to the object of the call, converted as if by an explicit type
 conversion [[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
@@ -2686,28 +3141,37 @@ class type that is either incomplete or abstract.
 [*Note 6*: This still allows a parameter to be a pointer or reference
 to such a type. However, it prevents a passed-by-value parameter to have
 an incomplete or abstract class type. — *end note*]
-It is *implementation-defined* whether the lifetime of a parameter ends
-when the function in which it is defined returns or at the end of the
-enclosing full-expression. The initialization and destruction of each
-parameter occurs within the context of the calling function.
-[*Example 2*: The access of the constructor, conversion functions or
-destructor is checked at the point of call in the calling function. If a
-constructor or destructor for a function parameter throws an exception,
-the search for a handler starts in the calling function; in particular,
-if the function called has a *function-try-block* [[except.pre]] with a
-handler that can handle the exception, this handler is not
 considered. — *end example*]
 The *postfix-expression* is sequenced before each *expression* in the
 *expression-list* and any default argument. The initialization of a
-parameter, including every associated value computation and side effect,
-is indeterminately sequenced with respect to that of any other
-parameter.
 [*Note 7*: All side effects of argument evaluations are sequenced
 before the function is entered (see
 [[intro.execution]]). — *end note*]
@@ -2751,17 +3215,26 @@ control out of the called function (if any), except in a virtual
 function call if the return type of the final overrider is different
 from the return type of the statically chosen function, the value
 returned from the final overrider is converted to the return type of the
 statically chosen function.
 [*Note 9*:  A function can change the values of its non-const
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
-reference is to a const-qualified type, `const_cast` is required to be
-used to cast away the constness in order to modify the argument’s value.
-Where a parameter is of `const` reference type a temporary object is
-introduced if needed
 [[dcl.type]], [[lex.literal]], [[lex.string]], [[dcl.array]], [[class.temporary]].
 In addition, it is possible to modify the values of non-constant objects
 through pointer parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
@@ -2787,15 +3260,16 @@ The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are performed on
 the argument expression. An argument that has type cv `std::nullptr_t`
 is converted to type `void*` [[conv.ptr]]. After these conversions, if
 the argument does not have arithmetic, enumeration, pointer,
 pointer-to-member, or class type, the program is ill-formed. Passing a
-potentially-evaluated argument of a scoped enumeration type or of a
-class type [[class]] having an eligible non-trivial copy constructor, an
-eligible non-trivial move constructor, or a non-trivial destructor
-[[special]], with no corresponding parameter, is conditionally-supported
-with *implementation-defined* semantics. If the argument has integral or
 enumeration type that is subject to the integral promotions
 [[conv.prom]], or a floating-point type that is subject to the
 floating-point promotion [[conv.fpprom]], the value of the argument is
 converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
@@ -2803,11 +3277,13 @@ referred to as the *default argument promotions*.
 Recursive calls are permitted, except to the `main` function
 [[basic.start.main]].
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
-type is an rvalue reference to object type, and a prvalue otherwise.
 #### Explicit type conversion (functional notation) <a id="expr.type.conv">[[expr.type.conv]]</a>
 A *simple-type-specifier* [[dcl.type.simple]] or *typename-specifier*
 [[temp.res]] followed by a parenthesized optional *expression-list* or
@@ -2816,11 +3292,28 @@ specified type given the initializer. If the type is a placeholder for a
 deduced class type, it is replaced by the return type of the function
 selected by overload resolution for class template deduction
 [[over.match.class.deduct]] for the remainder of this subclause.
 Otherwise, if the type contains a placeholder type, it is replaced by
 the type determined by placeholder type deduction
-[[dcl.type.auto.deduct]].
 [*Example 1*:
 ``` cpp
 struct A {};
@@ -2834,44 +3327,41 @@ void h() {
 }
 ```
 — *end example*]
-If the initializer is a parenthesized single expression, the type
-conversion expression is equivalent to the corresponding cast expression
-[[expr.cast]]. Otherwise, if the type is cv `void` and the initializer
-is `()` or `{}` (after pack expansion, if any), the expression is a
-prvalue of type `void` that performs no initialization. Otherwise, the
-expression is a prvalue of the specified type whose result object is
-direct-initialized [[dcl.init]] with the initializer. If the initializer
-is a parenthesized optional *expression-list*, the specified type shall
-not be an array type.
 #### Class member access <a id="expr.ref">[[expr.ref]]</a>
 A postfix expression followed by a dot `.` or an arrow `->`, optionally
 followed by the keyword `template`, and then followed by an
-*id-expression*, is a postfix expression. The postfix expression before
-the dot or arrow is evaluated;[^12]
-the result of that evaluation, together with the *id-expression*,
-determines the result of the entire postfix expression.
-[*Note 1*: 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*. — *end note*]
-For the first option (dot) the first expression shall be a glvalue. For
-the second option (arrow) the first expression 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).[^13]
-Abbreviating *postfix-expression*`.`*id-expression* as `E1.E2`, `E1` is
-called the *object expression*. If the object expression is of scalar
-type, `E2` shall name the pseudo-destructor of that same type (ignoring
 cv-qualifications) and `E1.E2` is a prvalue of type “function of ()
 returning `void`”.
 [*Note 2*: This value can only be used for a notional function call
 [[expr.prim.id.dtor]]. — *end note*]
@@ -2884,68 +3374,105 @@ definition of that class.
 when the class is complete [[class.member.lookup]]. — *end note*]
 [*Note 4*:  [[basic.lookup.qual]] describes how names are looked up
 after the `.` and `->` operators. — *end note*]
-If `E2` is a bit-field, `E1.E2` is a bit-field. The type and value
-category of `E1.E2` are determined as follows. In the remainder of
-[[expr.ref]], *cq* represents either `const` or the absence of `const`
-and *vq* represents either `volatile` or the absence of `volatile`. *cv*
-represents an arbitrary set of cv-qualifiers, as defined in
-[[basic.type.qualifier]].
-If `E2` is declared to have type “reference to `T`”, then `E1.E2` is an
-lvalue of type `T`. If `E2` is 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.
-- If `E2` is a static data member and the type of `E2` is `T`, then
- `E1.E2` is an lvalue; the expression designates the named member of
-  the class. The type of `E1.E2` is `T`.
-- If `E2` is a non-static data member and the type of `E1` is “*cq1 vq1*
-  `X`”, and the type of `E2` is “*cq2 vq2* `T`”, the expression
-  designates the corresponding member subobject of the object designated
-  by the first expression. If `E1` is an lvalue, then `E1.E2` is an
-  lvalue; otherwise `E1.E2` is an xvalue. Let the notation *vq12* stand
- for the “union” of *vq1* and *vq2*; that is, if *vq1* or *vq2* is
- `volatile`, then *vq12* is `volatile`. Similarly, let the notation
-  *cq12* stand for the “union” of *cq1* and *cq2*; that is, if *cq1* or
- *cq2* is `const`, then *cq12* is `const`. If `E2` is declared to be a
- `mutable` member, then the type of `E1.E2` is “*vq12* `T`”. If `E2` is
- not declared to be a `mutable` member, then the type of `E1.E2` is
- “*cq12* *vq12* `T`”.
-- If `E2` is an overload set, function overload resolution
- [[over.match]] is used to select the function to which `E2` refers.
- The type of `E1.E2` is the type of `E2` and `E1.E2` refers to the
- function referred to by `E2`.
   - If `E2` refers to a static member function, `E1.E2` is an lvalue.
   - Otherwise (when `E2` refers to a non-static member function),
-    `E1.E2` is a prvalue. The expression can be used only as the
- left-hand operand of a member function call [[class.mfct]].
- \[*Note 5*: Any redundant set of parentheses surrounding the
-    expression is ignored [[expr.prim.paren]]. — *end note*]
-- If `E2` is a nested type, the expression `E1.E2` is ill-formed.
-- If `E2` is 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.
-If `E2` is a non-static member, the program is ill-formed if the class
-of which `E2` is directly a member is an ambiguous base
-[[class.member.lookup]] of the naming class [[class.access.base]] of
-`E2`.
-[*Note 6*: The program is also ill-formed if the naming class is an
 ambiguous base of the class type of the object expression; see
 [[class.access.base]]. — *end note*]
-If `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.
-[*Example 1*:
 ``` cpp
 struct A { int i; };
 struct B { int j; };
 struct D : A, B {};
@@ -2958,33 +3485,32 @@ void f() {
 — *end example*]
 #### Increment and decrement <a id="expr.post.incr">[[expr.post.incr]]</a>
-The value of a postfix `++` expression is the value of its operand.
 [*Note 1*: The value obtained is a copy of the original
 value. — *end note*]
 The operand shall be a modifiable lvalue. The type of the operand shall
 be an arithmetic type other than cv `bool`, or a pointer to a complete
 object type. An operand with volatile-qualified type is deprecated; see
 [[depr.volatile.type]]. The value of the operand object is modified
-[[defns.access]] by adding `1` to it. The value computation of the `++`
-expression is sequenced before the modification of the operand object.
-With respect to an indeterminately-sequenced function call, the
-operation of postfix `++` is a single evaluation.
 [*Note 2*: Therefore, a function call cannot intervene between the
 lvalue-to-rvalue conversion and the side effect associated with any
 single postfix `++` operator. — *end note*]
 The result is a prvalue. The type of the result is the cv-unqualified
-version of the type of the operand. If the operand is a bit-field that
-cannot represent the incremented value, the resulting value of the
-bit-field is *implementation-defined*. See also  [[expr.add]] and
-[[expr.ass]].
 The operand of postfix `--` is decremented analogously to the postfix
 `++` operator.
 [*Note 3*: For prefix increment and decrement, see
@@ -3012,11 +3538,11 @@ If `T` is “pointer to *cv1* `B`” and `v` has type “pointer to *cv2* `D`”
 such that `B` is a base class of `D`, the result is a pointer to the
 unique `B` subobject of the `D` object pointed to by `v`, or a null
 pointer value if `v` is a null pointer value. Similarly, if `T` is
 “reference to *cv1* `B`” and `v` has type *cv2* `D` such that `B` is a
 base class of `D`, the result is the unique `B` subobject of the `D`
-object referred to by `v`.[^14]
 In both the pointer and reference cases, the program is ill-formed if
 `B` is an inaccessible or ambiguous base class of `D`.
 [*Example 1*:
@@ -3034,10 +3560,18 @@ void foo(D* dp) {
 Otherwise, `v` shall be a pointer to or a glvalue of a polymorphic type
 [[class.virtual]].
 If `v` is a null pointer value, the result is a null pointer value.
 If `T` is “pointer to cv `void`”, then the result is a pointer to the
 most derived object pointed to by `v`. Otherwise, a runtime check is
 applied to see if the object pointed or referred to by `v` can be
 converted to the type pointed or referred to by `T`.
@@ -3045,11 +3579,11 @@ Let `C` be the class type to which `T` points or refers. The runtime
 check logically executes as follows:
 - If, in the most derived object pointed (referred) to by `v`, `v`
   points (refers) to a public base class subobject of a `C` object, and
   if only one object of type `C` is derived from the subobject pointed
-  (referred) to by `v` the result points (refers) to that `C` object.
 - Otherwise, if `v` points (refers) to a public base class subobject of
   the most derived object, and the type of the most derived object has a
   base class, of type `C`, that is unambiguous and public, the result
   points (refers) to the `C` subobject of the most derived object.
 - Otherwise, the runtime check *fails*.
@@ -3095,31 +3629,35 @@ destruction. — *end note*]
 #### Type identification <a id="expr.typeid">[[expr.typeid]]</a>
 The result of a `typeid` expression is an lvalue of static type `const`
 `std::type_info` [[type.info]] and dynamic type `const` `std::type_info`
-or `const` *name* where *name* is an *implementation-defined* class
 publicly derived from `std::type_info` which preserves the behavior
-described in  [[type.info]].[^15]
 The lifetime of the object referred to by the lvalue extends to the end
 of the program. Whether or not the destructor is called for the
 `std::type_info` object at the end of the program is unspecified.
 If the type of the *expression* or *type-id* operand is a (possibly
 cv-qualified) class type or a reference to (possibly cv-qualified) class
 type, that class shall be completely defined.
 When `typeid` is applied to a glvalue whose type is a polymorphic class
 type [[class.virtual]], the result refers to a `std::type_info` object
 representing the type of the most derived object [[intro.object]] (that
-is, the dynamic type) to which the glvalue refers. If the glvalue is
-obtained by applying the unary `*` operator to a pointer[^16]
-and the pointer is a null pointer value [[basic.compound]], the `typeid`
-expression throws an exception [[except.throw]] of a type that would
-match a handler of type `std::bad_typeid` exception [[bad.typeid]].
 When `typeid` is applied to an expression other than a glvalue of a
 polymorphic class type, the result refers to a `std::type_info` object
 representing the static type of the expression. Lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
@@ -3132,11 +3670,11 @@ When `typeid` is applied to a *type-id*, the result refers to a
 `std::type_info` object representing the type of the *type-id*. If the
 type of the *type-id* is a reference to a possibly cv-qualified type,
 the result of the `typeid` expression refers to a `std::type_info`
 object representing the cv-unqualified referenced type.
-[*Note 1*: The *type-id* cannot denote a function type with a
 *cv-qualifier-seq* or a *ref-qualifier* [[dcl.fct]]. — *end note*]
 If the type of the expression or *type-id* is a cv-qualified type, the
 result of the `typeid` expression refers to a `std::type_info` object
 representing the cv-unqualified type.
@@ -3159,24 +3697,23 @@ typeid(D)  == typeid(const D&); // yields true
 The type `std::type_info` [[type.info]] is not predefined; if a standard
 library declaration [[typeinfo.syn]], [[std.modules]] of
 `std::type_info` does not precede [[basic.lookup.general]] a `typeid`
 expression, the program is ill-formed.
-[*Note 2*: Subclause [[class.cdtor]] describes the behavior of `typeid`
 applied to an object under construction or destruction. — *end note*]
 #### Static cast <a id="expr.static.cast">[[expr.static.cast]]</a>
 The result of the expression `static_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. If `T` is an lvalue reference
 type or an rvalue reference to function type, the result is an lvalue;
 if `T` is an rvalue reference to object type, the result is an xvalue;
-otherwise, the result is a prvalue. The `static_cast` operator shall not
-cast away constness [[expr.const.cast]].
 An lvalue of type “*cv1* `B`”, where `B` is a class type, can be cast to
-type “reference to *cv2* `D`”, where `D` is a class derived
 [[class.derived]] from `B`, if *cv2* is the same cv-qualification as, or
 greater cv-qualification than, *cv1*. If `B` is a virtual base class of
 `D` or a base class of a virtual base class of `D`, or if no valid
 standard conversion from “pointer to `D`” to “pointer to `B`” exists
 [[conv.ptr]], the program is ill-formed. An xvalue of type “*cv1* `B`”
@@ -3207,14 +3744,25 @@ class subobject thereof; otherwise, the lvalue-to-rvalue conversion
 used as the operand of the `static_cast` for the remainder of this
 subclause. If `T2` is an inaccessible [[class.access]] or ambiguous
 [[class.member.lookup]] base class of `T1`, a program that necessitates
 such a cast is ill-formed.
-An expression E can be explicitly converted to a type `T` if there is an
-implicit conversion sequence [[over.best.ics]] from E to `T`, if
-overload resolution for a direct-initialization [[dcl.init]] of an
-object or reference of type `T` from E would find at least one viable
 function [[over.match.viable]], or if `T` is an aggregate type
 [[dcl.init.aggr]] having a first element `x` and there is an implicit
 conversion sequence from E to the type of `x`. If `T` is a reference
 type, the effect is the same as performing the declaration and
 initialization
@@ -3225,59 +3773,23 @@ T t(E);
 for some invented temporary variable `t` [[dcl.init]] and then using the
 temporary variable as the result of the conversion. Otherwise, the
 result object is direct-initialized from E.
-[*Note 1*: The conversion is ill-formed when attempting to convert an
 expression of class type to an inaccessible or ambiguous base
 class. — *end note*]
-[*Note 2*: If `T` is “array of unknown bound of `U`”, this
 direct-initialization defines the type of the expression as
 `U[1]`. — *end note*]
-Otherwise, the `static_cast` shall perform one of the conversions listed
-below. No other conversion shall be performed explicitly using a
-`static_cast`.
-Any expression can be explicitly converted to type cv `void`, in which
-case the operand is a discarded-value expression [[expr.prop]].
-[*Note 3*: Such a `static_cast` has no result as it is a prvalue of
-type `void`; see  [[basic.lval]]. — *end note*]
-[*Note 4*: However, if the value is in a temporary object
-[[class.temporary]], the destructor for that object is not executed
-until the usual time, and the value of the object is preserved for the
-purpose of executing the destructor. — *end note*]
-The inverse of any standard conversion sequence [[conv]] not containing
-an lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]],
-function-to-pointer [[conv.func]], null pointer [[conv.ptr]], null
-member pointer [[conv.mem]], boolean [[conv.bool]], or function pointer
-[[conv.fctptr]] conversion, can be performed explicitly using
-`static_cast`. A program is ill-formed if it uses `static_cast` to
-perform the inverse of an ill-formed standard conversion sequence.
-[*Example 2*:
-``` cpp
-struct B { };
-struct D : private B { };
-void f() {
-  static_cast<D*>((B*)0);               // error: B is a private base of D
-  static_cast<int B::*>((int D::*)0);   // error: B is a private base of D
-}
-```
-— *end example*]
-The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
-function-to-pointer [[conv.func]] conversions are applied to the
-operand. Such a `static_cast` is subject to the restriction that the
-explicit conversion does not cast away constness [[expr.const.cast]],
-and the following additional rules for specific cases:
 A value of a scoped enumeration type [[dcl.enum]] can be explicitly
 converted to an integral type; the result is the same as that of
 converting to the enumeration’s underlying type and then to the
 destination type. A value of a scoped enumeration type can also be
@@ -3330,14 +3842,13 @@ pointer-to-member-function types) are never cv-qualified
 If no valid standard conversion from “pointer to member of `B` of type
 `T`” to “pointer to member of `D` of type `T`” exists [[conv.mem]], the
 program is ill-formed. The null member pointer value [[conv.mem]] is
 converted to the null member pointer value of the destination type. If
-class `B` contains the original member, or is a base or derived class of
-the class containing the original member, the resulting pointer to
-member points to the original member. Otherwise, the behavior is
-undefined.
 [*Note 6*: Although class `B` need not contain the original member, the
 dynamic type of the object with which indirection through the pointer to
 member is performed must contain the original member; see
 [[expr.mptr.oper]]. — *end note*]
@@ -3345,17 +3856,18 @@ member is performed must contain the original member; see
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
 prvalue of type “pointer to *cv2* `T`”, where `T` is an object type and
 *cv2* is the same cv-qualification as, or greater cv-qualification than,
 *cv1*. If the original pointer value represents the address `A` of a
 byte in memory and `A` does not satisfy the alignment requirement of
-`T`, then the resulting pointer value is unspecified. Otherwise, if the
-original pointer value points to an object *a*, and there is an object
-*b* of type similar to `T` that is pointer-interconvertible
-[[basic.compound]] with *a*, the result is a pointer to *b*. Otherwise,
-the pointer value is unchanged by the conversion.
-[*Example 3*:
 ``` cpp
 T* p1 = new T;
 const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
 bool b = p1 == p2;  // b will have the value true.
@@ -3400,12 +3912,12 @@ the conversion has the same meaning and validity as a conversion of
 any type to the type `std::nullptr_t`. — *end note*]
 A value of integral type or enumeration type can be explicitly converted
 to a pointer. A pointer converted to an integer of sufficient size (if
 any such exists on the implementation) and back to the same pointer type
-will have its original value; mappings between pointers and integers are
-otherwise *implementation-defined*.
 A function pointer can be explicitly converted to a function pointer of
 a different type.
 [*Note 4*: The effect of calling a function through a pointer to a
@@ -3415,21 +3927,18 @@ definition of the function is undefined [[expr.call]]. — *end note*]
 Except that converting a prvalue of type “pointer to `T1`” to the type
 “pointer to `T2`” (where `T1` and `T2` are function types) and back to
 its original type yields the original pointer value, the result of such
 a pointer conversion is unspecified.
-[*Note 5*: See also  [[conv.ptr]] for more details of pointer
-conversions. — *end note*]
 An object pointer can be explicitly converted to an object pointer of a
-different type.[^17]
 When a prvalue `v` of object pointer type is converted to the object
 pointer type “pointer to cv `T`”, the result is
 `static_cast<cv T*>(static_cast<cv~void*>(v))`.
-[*Note 6*: Converting a pointer of type “pointer to `T1`” that points
 to an object of type `T1` to the type “pointer to `T2`” (where `T2` is
 an object type and the alignment requirements of `T2` are no stricter
 than those of `T1`) and back to its original type yields the original
 pointer value. — *end note*]
@@ -3441,19 +3950,19 @@ other type and back, possibly with different cv-qualification, shall
 yield the original pointer value.
 The null pointer value [[basic.compound]] is converted to the null
 pointer value of the destination type.
-[*Note 7*: A null pointer constant of type `std::nullptr_t` cannot be
 converted to a pointer type, and a null pointer constant of integral
 type is not necessarily converted to a null pointer
 value. — *end note*]
 A prvalue of type “pointer to member of `X` of type `T1`” can be
 explicitly converted to a prvalue of a different type “pointer to member
 of `Y` of type `T2`” if `T1` and `T2` are both function types or both
-object types.[^18]
 The null member pointer value [[conv.mem]] is converted to the null
 member pointer value of the destination type. The result of this
 conversion is unspecified, except in the following cases:
@@ -3464,79 +3973,83 @@ conversion is unspecified, except in the following cases:
   `T1`” to the type “pointer to data member of `Y` of type `T2`” (where
   the alignment requirements of `T2` are no stricter than those of `T1`)
   and back to its original type yields the original pointer-to-member
   value.
-A glvalue of type `T1`, designating an object *x*, can be cast to the
-type “reference to `T2`” if an expression of type “pointer to `T1`” can
-be explicitly converted to the type “pointer to `T2`” using a
-`reinterpret_cast`. The result is that of `*reinterpret_cast<T2 *>(p)`
-where `p` is a pointer to *x* of type “pointer to `T1`”. No temporary is
-created, no copy is made, and no constructors [[class.ctor]] or
-conversion functions [[class.conv]] are called.[^19]
 #### Const cast <a id="expr.const.cast">[[expr.const.cast]]</a>
 The result of the expression `const_cast<T>(v)` is of type `T`. If `T`
 is an lvalue reference to object type, the result is an lvalue; if `T`
 is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue and the lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
 [[conv.func]] standard conversions are performed on the expression `v`.
-Conversions that can be performed explicitly using `const_cast` are
-listed below. No other conversion shall be performed explicitly using
-`const_cast`.
 [*Note 1*: Subject to the restrictions in this subclause, an expression
 can be cast to its own type using a `const_cast`
 operator. — *end note*]
-For two similar types `T1` and `T2` [[conv.qual]], a prvalue of type
-`T1` may be explicitly converted to the type `T2` using a `const_cast`
-if, considering the qualification-decompositions of both types, each P¹ᵢ
-is the same as P²ᵢ for all i. The result of a `const_cast` refers to the
-original entity.
-[*Example 1*:
-``` cpp
-typedef int *A[3];                  // array of 3 pointer to int
-typedef const int *const CA[3];     // array of 3 const pointer to const int
-CA &&r = A{};                       // OK, reference binds to temporary array object
-                                    // after qualification conversion to type CA
-A &&r1 = const_cast<A>(CA{});       // error: temporary array decayed to pointer
-A &&r2 = const_cast<A&&>(CA{});     // OK
-```
-— *end example*]
 For two object types `T1` and `T2`, if a pointer to `T1` can be
 explicitly converted to the type “pointer to `T2`” using a `const_cast`,
 then the following conversions can also be made:
 - an lvalue of type `T1` can be explicitly converted to an lvalue of
   type `T2` using the cast `const_cast<T2&>`;
 - a glvalue of type `T1` can be explicitly converted to an xvalue of
   type `T2` using the cast `const_cast<T2&&>`; and
-- if `T1` is a class type, a prvalue of type `T1` can be explicitly
-  converted to an xvalue of type `T2` using the cast `const_cast<T2&&>`.
-The result of a reference `const_cast` refers to the original object if
-the operand is a glvalue and to the result of applying the temporary
-materialization conversion [[conv.rval]] otherwise.
-A null pointer value [[basic.compound]] is converted to the null pointer
-value of the destination type. The null member pointer value
-[[conv.mem]] is converted to the null member pointer value of the
-destination type.
 [*Note 2*:
 Depending on the type of the object, a write operation through the
 pointer, lvalue or pointer to data member resulting from a `const_cast`
-that casts away a const-qualifier[^20]
 can produce undefined behavior [[dcl.type.cv]].
 — *end note*]
@@ -3582,10 +4095,11 @@ unary-expression:
     sizeof '...' '(' identifier ')'
     alignof '(' type-id ')'
     noexcept-expression
     new-expression
     delete-expression
 ```
 ``` bnf
 %% Ed. note: character protrusion would misalign operators.
@@ -3595,33 +4109,42 @@ unary-operator: one of
 #### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
 The unary `*` operator performs *indirection*. Its operand shall be a
 prvalue of type “pointer to `T`”, where `T` is an object or function
-type. The operator yields an lvalue of type `T` denoting the object or
-function to which the operand points.
-[*Note 1*: Indirection through a pointer to an incomplete type (other
 than cv `void`) is valid. The lvalue thus obtained can be used in
 limited ways (to initialize a reference, for example); this lvalue must
 not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
 Each of the following unary operators yields a prvalue.
 The operand of the unary `&` operator shall be an lvalue of some type
-`T`. The result is a prvalue.
-- If the operand is a *qualified-id* naming a non-static or variant
-  member `m` of some class `C`, other than an explicit object member
-  function, the result has type “pointer to member of class `C` of type
- `T`” and designates `C::m`.
 - Otherwise, the result has type “pointer to `T`” and points to the
   designated object [[intro.memory]] or function [[basic.compound]]. If
-  the operand names an explicit object member function [[dcl.fct]], the
-  operand shall be a *qualified-id*. \[*Note 2*: In particular, taking
- the address of a variable of type “cv `T`” yields a pointer of type
-  “pointer to cv `T`”. — *end note*]
 [*Example 1*:
 ``` cpp
 struct A { int i; };
@@ -3633,18 +4156,19 @@ int* p2 = p1 + 1;   // defined behavior
 bool b = p2 > p1;   // defined behavior, with value true
 ```
 — *end example*]
-[*Note 3*: A pointer to member formed from a `mutable` non-static data
 member [[dcl.stc]] does not reflect the `mutable` specifier associated
 with the non-static data member. — *end note*]
 A pointer to member is only formed when an explicit `&` is used and its
-operand is a *qualified-id* not enclosed in parentheses.
-[*Note 4*: That is, the expression `&(qualified-id)`, where the
 *qualified-id* is enclosed in parentheses, does not form an expression
 of type “pointer to member”. Neither does `qualified-id`, because there
 is no implicit conversion from a *qualified-id* for a non-static member
 function to the type “pointer to member function” as there is from an
 lvalue of function type to the type “pointer to function” [[conv.func]].
@@ -3654,99 +4178,96 @@ the *unqualified-id*’s class. — *end note*]
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
-[*Note 5*: The address of an overload set [[over]] can be taken only in
 a context that uniquely determines which function is referred to (see
 [[over.over]]). Since the context can affect whether the operand is a
 static or non-static member function, the context can also affect
 whether the expression has type “pointer to function” or “pointer to
 member function”. — *end note*]
-The operand of the unary `+` operator shall have arithmetic, unscoped
-enumeration, or pointer type and the result is the value of the
 argument. Integral promotion is performed on integral or enumeration
 operands. The type of the result is the type of the promoted operand.
-The operand of the unary `-` operator shall have arithmetic or unscoped
-enumeration type and the result is the negative of its operand. Integral
-promotion is performed on integral or enumeration operands. The negative
-of an unsigned quantity is computed by subtracting its value from 2ⁿ,
-where n is the number of bits in the promoted operand. The type of the
-result is the type of the promoted operand.
-[*Note 6*: The result is the two’s complement of the operand (where
 operand and result are considered as unsigned). — *end note*]
 The operand of the logical negation operator `!` is contextually
 converted to `bool` [[conv]]; its value is `true` if the converted
 operand is `false` and `false` otherwise. The type of the result is
 `bool`.
-The operand of the `~` operator shall have integral or unscoped
-enumeration type. Integral promotions are performed. The type of the
-result is the type of the promoted operand. Given the coefficients `xᵢ`
-of the base-2 representation [[basic.fundamental]] of the promoted
-operand `x`, the coefficient `rᵢ` of the base-2 representation of the
-result `r` is 1 if `xᵢ` is 0, and 0 otherwise.
-[*Note 7*: The result is the ones’ complement of the operand (where
 operand and result are considered as unsigned). — *end note*]
 There is an ambiguity in the grammar when `~` is followed by a
-*type-name* or *decltype-specifier*. The ambiguity is resolved by
 treating `~` as the operator rather than as the start of an
 *unqualified-id* naming a destructor.
-[*Note 8*: Because the grammar does not permit an operator to follow
 the `.`, `->`, or `::` tokens, a `~` followed by a *type-name* or
-*decltype-specifier* in a member access expression or *qualified-id* is
-unambiguously parsed as a destructor name. — *end note*]
 #### Increment and decrement <a id="expr.pre.incr">[[expr.pre.incr]]</a>
-The operand of prefix `++` is modified [[defns.access]] by adding `1`.
-The operand shall be a modifiable lvalue. The type of the operand shall
-be an arithmetic type other than cv `bool`, or a pointer to a
-completely-defined object type. An operand with volatile-qualified type
-is deprecated; see  [[depr.volatile.type]]. The result is the updated
-operand; it is an lvalue, and it is a bit-field if the operand is a
-bit-field. The expression `++x` is equivalent to `x+=1`.
-[*Note 1*: See the discussions of addition [[expr.add]] and assignment
-operators [[expr.ass]] for information on conversions. — *end note*]
-The operand of prefix `--` is modified [[defns.access]] by subtracting
-`1`. The requirements on the operand of prefix `--` and the properties
-of its result are otherwise the same as those of prefix `++`.
-[*Note 2*: For postfix increment and decrement, see
 [[expr.post.incr]]. — *end note*]
 #### Await <a id="expr.await">[[expr.await]]</a>
 The `co_await` expression is used to suspend evaluation of a coroutine
 [[dcl.fct.def.coroutine]] while awaiting completion of the computation
-represented by the operand expression.
 ``` bnf
 await-expression:
- 'co_await' cast-expression
 ```
-An *await-expression* shall appear only in a potentially-evaluated
-expression within the *compound-statement* of a *function-body* outside
-of a *handler* [[except.pre]]. In a *declaration-statement* or in the
 *simple-declaration* (if any) of an *init-statement*, an
 *await-expression* shall appear only in an *initializer* of that
 *declaration-statement* or *simple-declaration*. An *await-expression*
 shall not appear in a default argument [[dcl.fct.default]]. An
 *await-expression* shall not appear in the initializer of a block
-variable with static or thread storage duration. A context within a
-function where an *await-expression* can appear is called a *suspension
-context* of the function.
 Evaluation of an *await-expression* involves the following auxiliary
 types, expressions, and objects:
 - *p* is an lvalue naming the promise object [[dcl.fct.def.coroutine]]
@@ -3866,11 +4387,11 @@ to any other fundamental type [[basic.fundamental]] is
 [*Note 1*:
 In particular, the values of `sizeof(bool)`, `sizeof(char16_t)`,
 `sizeof(char32_t)`, and `sizeof(wchar_t)` are
-implementation-defined.[^21]
 — *end note*]
 [*Note 2*: See  [[intro.memory]] for the definition of byte and
 [[term.object.representation]] for the definition of object
@@ -3879,83 +4400,84 @@ representation. — *end note*]
 When applied to a reference type, the result is the size of the
 referenced type. When applied to a class, the result is the number of
 bytes in an object of that class including any padding required for
 placing objects of that type in an array. The result of applying
 `sizeof` to a potentially-overlapping subobject is the size of the type,
-not the size of the subobject.[^22]
 When applied to an array, the result is the total number of bytes in the
 array. This implies that the size of an array of n elements is n times
 the size of an element.
 The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are not applied
 to the operand of `sizeof`. If the operand is a prvalue, the temporary
 materialization conversion [[conv.rval]] is applied.
-The identifier in a `sizeof...` expression shall name a pack. The
 `sizeof...` operator yields the number of elements in the pack
 [[temp.variadic]]. A `sizeof...` expression is a pack expansion
 [[temp.variadic]].
 [*Example 1*:
 ``` cpp
 template<class... Types>
 struct count {
-  static const std::size_t value = sizeof...(Types);
 };
 ```
 — *end example*]
 The result of `sizeof` and `sizeof...` is a prvalue of type
 `std::size_t`.
 [*Note 3*: A `sizeof` expression is an integral constant expression
-[[expr.const]]. The type `std::size_t` is defined in the standard header
-`<cstddef>` [[cstddef.syn]], [[support.types.layout]]. — *end note*]
 #### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 An `alignof` expression yields the alignment requirement of its operand
 type. The operand shall be a *type-id* representing a complete object
 type, or an array thereof, or a reference to one of those types.
 The result is a prvalue of type `std::size_t`.
 [*Note 1*: An `alignof` expression is an integral constant expression
-[[expr.const]]. The type `std::size_t` is defined in the standard header
-`<cstddef>` [[cstddef.syn]], [[support.types.layout]]. — *end note*]
 When `alignof` is applied to a reference type, the result is the
 alignment of the referenced type. When `alignof` is applied to an array
 type, the result is the alignment of the element type.
 #### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
-The `noexcept` operator determines whether the evaluation of its
-operand, which is an unevaluated operand [[term.unevaluated.operand]],
-can throw an exception [[except.throw]].
 ``` bnf
 noexcept-expression:
   noexcept '(' expression ')'
 ```
-The result of the `noexcept` operator is a prvalue of type `bool`.
 [*Note 1*: A *noexcept-expression* is an integral constant expression
 [[expr.const]]. — *end note*]
-The result of the `noexcept` operator is `true` unless the *expression*
-is potentially-throwing [[except.spec]].
 #### New <a id="expr.new">[[expr.new]]</a>
-The *new-expression* attempts to create an object of the *type-id*
-[[dcl.name]] or *new-type-id* to which it is applied. The type of that
 object is the *allocated type*. This type shall be a complete object
 type [[term.incomplete.type]], but not an abstract class type
 [[class.abstract]] or array thereof [[intro.object]].
 [*Note 1*: Because references are not objects, references cannot be
@@ -3997,17 +4519,17 @@ noptr-new-declarator:
 new-initializer:
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
-If a placeholder type [[dcl.spec.auto]] appears in the
-*type-specifier-seq* of a *new-type-id* or *type-id* of a
-*new-expression*, the allocated type is deduced as follows: Let *init*
-be the *new-initializer*, if any, and `T` be the *new-type-id* or
-*type-id* of the *new-expression*, then the allocated type is the type
-deduced for the variable `x` in the invented declaration
-[[dcl.spec.auto]]:
 ``` cpp
 T x init ;
 ```
@@ -4079,34 +4601,41 @@ converted constant expression [[expr.const]] of type `std::size_t` and
 its value shall be greater than zero.
 [*Example 4*: Given the definition `int n = 42`, `new float[n][5]` is
 well-formed (because `n` is the *expression* of a
 *noptr-new-declarator*), but `new float[5][n]` is ill-formed (because
-`n` is not a constant expression). — *end example*]
 If the *type-id* or *new-type-id* denotes an array type of unknown bound
 [[dcl.array]], the *new-initializer* shall not be omitted; the allocated
 object is an array with `n` elements, where `n` is determined from the
 number of initial elements supplied in the *new-initializer*
 [[dcl.init.aggr]], [[dcl.init.string]].
 If the *expression* in a *noptr-new-declarator* is present, it is
-implicitly converted to `std::size_t`. The *expression* is erroneous if:
 - the expression is of non-class type and its value before converting to
   `std::size_t` is less than zero;
 - the expression is of class type and its value before application of
-  the second standard conversion [[over.ics.user]][^23] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
   the *implementation-defined* limit [[implimits]]; or
 - the *new-initializer* is a *braced-init-list* and the number of array
   elements for which initializers are provided (including the
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
-If the *expression* is erroneous after converting to `std::size_t`:
 - if the *expression* is a potentially-evaluated core constant
   expression, the program is ill-formed;
 - otherwise, an allocation function is not called; instead
   - if the allocation function that would have been called has a
@@ -4118,24 +4647,34 @@ If the *expression* is erroneous after converting to `std::size_t`:
     `std::bad_array_new_length` [[new.badlength]].
 When the value of the *expression* is zero, the allocation function is
 called to allocate an array with no elements.
 Objects created by a *new-expression* have dynamic storage duration
 [[basic.stc.dynamic]].
-[*Note 5*:  The lifetime of such an object is not necessarily
 restricted to the scope in which it is created. — *end note*]
 When the allocated type is “array of `N` `T`” (that is, the
 *noptr-new-declarator* syntax is used or the *new-type-id* or *type-id*
 denotes an array type), the *new-expression* yields a prvalue of type
 “pointer to `T`” that points to the initial element (if any) of the
 array. Otherwise, let `T` be the allocated type; the *new-expression* is
 a prvalue of type “pointer to T” that points to the object created.
-[*Note 6*: Both `new int` and `new int[10]` have type `int*` and the
 type of `new int[i][10]` is `int (*)[10]`. — *end note*]
 A *new-expression* may obtain storage for the object by calling an
 allocation function [[basic.stc.dynamic.allocation]]. If the
 *new-expression* terminates by throwing an exception, it may release
@@ -4144,11 +4683,11 @@ storage by calling a deallocation function
 type, the allocation function’s name is `operator new` and the
 deallocation function’s name is `operator delete`. If the allocated type
 is an array type, the allocation function’s name is `operator new[]` and
 the deallocation function’s name is `operator delete[]`.
-[*Note 7*: An implementation is required to provide default definitions
 for the global allocation functions
 [[basic.stc.dynamic]], [[new.delete.single]], [[new.delete.array]]. A
 C++ program can provide alternative definitions of these functions
 [[replacement.functions]] and/or class-specific versions [[class.free]].
 The set of allocation and deallocation functions that can be called by a
@@ -4165,16 +4704,12 @@ global scope.
 An implementation is allowed to omit a call to a replaceable global
 allocation function [[new.delete.single]], [[new.delete.array]]. When it
 does so, the storage is instead provided by the implementation or
 provided by extending the allocation of another *new-expression*.
-During an evaluation of a constant expression, a call to an allocation
-function is always omitted.
-[*Note 8*: Only *new-expression*s that would otherwise result in a call
-to a replaceable global allocation function can be evaluated in constant
-expressions [[expr.const]]. — *end note*]
 The implementation may extend the allocation of a *new-expression* `e1`
 to provide storage for a *new-expression* `e2` if the following would be
 true were the allocation not extended:
@@ -4313,13 +4848,13 @@ not be done, the deallocation function shall not be called, and the
 value of the *new-expression* shall be null.
 [*Note 11*: When the allocation function returns a value other than
 null, it must be a pointer to a block of storage in which space for the
 object has been reserved. The block of storage is assumed to be
-appropriately aligned and of the requested size. The address of the
-created object will not necessarily be the same as that of the block if
-the object is an array. — *end note*]
 A *new-expression* that creates an object of type `T` initializes that
 object as follows:
 - If the *new-initializer* is omitted, the object is default-initialized
@@ -4331,18 +4866,14 @@ object as follows:
 The invocation of the allocation function is sequenced before the
 evaluations of expressions in the *new-initializer*. Initialization of
 the allocated object is sequenced before the value computation of the
 *new-expression*.
-If the *new-expression* creates an object or an array of objects of
-class type, access and ambiguity control are done for the allocation
-function, the deallocation function [[basic.stc.dynamic.deallocation]],
-and the constructor [[class.ctor]] selected for the initialization (if
-any). If the *new-expression* creates an array of objects of class type,
-the destructor is potentially invoked [[class.dtor]].
-If any part of the object initialization described above[^24]
 terminates by throwing an exception and a suitable deallocation function
 can be found, the deallocation function is called to free the memory in
 which the object was being constructed, after which the exception
 continues to propagate in the context of the *new-expression*. If no
@@ -4367,11 +4898,13 @@ single matching deallocation function, that function will be called;
 otherwise, no deallocation function will be called. If the lookup finds
 a usual deallocation function and that function, considered as a
 placement deallocation function, would have been selected as a match for
 the allocation function, the program is ill-formed. For a non-placement
 allocation function, the normal deallocation function lookup is used to
-find the matching deallocation function [[expr.delete]].
 [*Example 7*:
 ``` cpp
 struct S {
@@ -4410,30 +4943,26 @@ delete-expression:
 ```
 The first alternative is a *single-object delete expression*, and the
 second is an *array delete expression*. Whenever the `delete` keyword is
 immediately followed by empty square brackets, it shall be interpreted
-as the second alternative.[^25]
-The operand shall be of pointer to object type or of class type. If of
-class type, the operand is contextually implicitly converted [[conv]] to
-a pointer to object type.[^26]
-The *delete-expression* has type `void`.
-If the operand has a class type, the operand is converted to a pointer
-type by calling the above-mentioned conversion function, and the
-converted operand is used in place of the original operand for the
-remainder of this subclause. In a single-object delete expression, the
-value of the operand of `delete` may be a null pointer value, a pointer
-value that resulted from a previous non-array *new-expression*, or a
-pointer to a base class subobject of an object created by such a
-*new-expression*. If not, the behavior is undefined. In an array delete
-expression, the value of the operand of `delete` may be a null pointer
-value or a pointer value that resulted from a previous array
-*new-expression* whose allocation function was not a non-allocating form
-[[new.delete.placement]].[^27]
 If not, the behavior is undefined.
 [*Note 1*: This means that the syntax of the *delete-expression* must
 match the type of the object allocated by `new`, not the syntax of the
@@ -4451,24 +4980,21 @@ delete, the static type shall be a base class of the dynamic type of the
 object to be deleted and the static type shall have a virtual destructor
 or the behavior is undefined. In an array delete expression, if the
 dynamic type of the object to be deleted is not similar to its static
 type, the behavior is undefined.
-The *cast-expression* in a *delete-expression* shall be evaluated
-exactly once.
 If the object being deleted has incomplete class type at the point of
-deletion and the complete class has a non-trivial destructor or a
-deallocation function, the behavior is undefined.
 If the value of the operand of the *delete-expression* is not a null
 pointer value and the selected deallocation function (see below) is not
-a destroying operator delete, the *delete-expression* will invoke the
-destructor (if any) for the object or the elements of the array being
-deleted. In the case of an array, the elements will be destroyed in
-order of decreasing address (that is, in reverse order of the completion
-of their constructor; see  [[class.base.init]]).
 If the value of the operand of the *delete-expression* is not a null
 pointer value, then:
 - If the allocation call for the *new-expression* for the object to be
@@ -4525,12 +5051,11 @@ declarations other than of usual deallocation functions
 [*Note 5*: If only a placement deallocation function is found in a
 class, the program is ill-formed because the lookup set is empty
 [[basic.lookup]]. — *end note*]
-If more than one deallocation function is found, the function to be
-called is selected as follows:
 - If any of the deallocation functions is a destroying operator delete,
   all deallocation functions that are not destroying operator deletes
   are eliminated from further consideration.
 - If the type has new-extended alignment, a function with a parameter of
@@ -4546,10 +5071,15 @@ called is selected as follows:
   or a (possibly multidimensional) array thereof, the function with a
   parameter of type `std::size_t` is selected.
 - Otherwise, it is unspecified whether a deallocation function with a
   parameter of type `std::size_t` is selected.
 For a single-object delete expression, the deleted object is the object
 A pointed to by the operand if the static type of A does not have a
 virtual destructor, and the most-derived object of A otherwise.
 [*Note 6*: If the deallocation function is not a destroying operator
@@ -4580,12 +5110,181 @@ passed as the corresponding argument.
 function, and either the first argument was not the result of a prior
 call to a replaceable allocation function or the second or third
 argument was not the corresponding argument in said call, the behavior
 is undefined [[new.delete.single]], [[new.delete.array]]. — *end note*]
-Access and ambiguity control are done for both the deallocation function
-and the destructor [[class.dtor]], [[class.free]].
 ### Explicit type conversion (cast notation) <a id="expr.cast">[[expr.cast]]</a>
 The result of the expression `(T)` *cast-expression* is of type `T`. The
 result is an lvalue if `T` is an lvalue reference type or an rvalue
@@ -4635,12 +5334,13 @@ conversion is valid even if the base class is inaccessible:
   of a derived class type, respectively.
 If a conversion can be interpreted in more than one of the ways listed
 above, the interpretation that appears first in the list is used, even
 if a cast resulting from that interpretation is ill-formed. If a
-conversion can be interpreted in more than one way as a `static_cast`
-followed by a `const_cast`, the conversion is ill-formed.
 [*Example 1*:
 ``` cpp
 struct A { };
@@ -4648,10 +5348,19 @@ struct I1 : A { };
 struct I2 : A { };
 struct D : I1, I2 { };
 A* foo( D* p ) {
   return (A*)( p );             // ill-formed static_cast interpretation
 }
 ```
 — *end example*]
 The operand of a cast using the cast notation can be a prvalue of type
@@ -4661,13 +5370,13 @@ operand and destination types are class types and one or both are
 incomplete, it is unspecified whether the `static_cast` or the
 `reinterpret_cast` interpretation is used, even if there is an
 inheritance relationship between the two classes.
 [*Note 2*: For example, if the classes were defined later in the
-translation unit, a multi-pass compiler would be permitted to interpret
-a cast between pointers to the classes as if the class types were
-complete at the point of the cast. — *end note*]
 ### Pointer-to-member operators <a id="expr.mptr.oper">[[expr.mptr.oper]]</a>
 The pointer-to-member operators `->*` and `.*` group left-to-right.
@@ -4676,21 +5385,21 @@ pm-expression:
     cast-expression
     pm-expression '.*' cast-expression
     pm-expression '->*' cast-expression
 ```
-The binary operator `.*` binds its second operand, which shall be of
-type “pointer to member of `T`” to its first operand, which shall be a
-glvalue of class `T` or of a class of which `T` is an unambiguous and
-accessible base class. The result is an object or a function of the type
-specified by the second operand.
-The binary operator `->*` binds its second operand, which shall be of
-type “pointer to member of `T`” to its first operand, which shall be of
-type “pointer to `U`” where `U` is either `T` or a class of which `T` is
-an unambiguous and accessible base class. The expression `E1->*E2` is
-converted into the equivalent form `(*(E1)).*E2`.
 Abbreviating *pm-expression*`.*`*cast-expression* as `E1.*E2`, `E1` is
 called the *object expression*. If the result of `E1` is an object whose
 type is not similar to the type of `E1`, or whose most derived object
 does not contain the member to which `E2` refers, the behavior is
@@ -4766,77 +5475,80 @@ are performed on the operands and determine the type of the result.
 The binary `*` operator indicates multiplication.
 The binary `/` operator yields the quotient, and the binary `%` operator
 yields the remainder from the division of the first expression by the
-second. If the second operand of `/` or `%` is zero the behavior is
-undefined. For integral operands the `/` operator yields the algebraic
-quotient with any fractional part discarded;[^28]
 if the quotient `a/b` is representable in the type of the result,
 `(a/b)*b + a%b` is equal to `a`; otherwise, the behavior of both `a/b`
 and `a%b` is undefined.
 ### Additive operators <a id="expr.add">[[expr.add]]</a>
-The additive operators `+` and `-` group left-to-right. The usual
-arithmetic conversions [[expr.arith.conv]] are performed for operands of
-arithmetic or enumeration type.
 ``` bnf
 additive-expression:
     multiplicative-expression
     additive-expression '+' multiplicative-expression
     additive-expression '-' multiplicative-expression
 ```
-For addition, either both operands shall have arithmetic or unscoped
-enumeration type, or one operand shall be a pointer to a
-completely-defined object type and the other shall have integral or
-unscoped enumeration type.
 For subtraction, one of the following shall hold:
-- both operands have arithmetic or unscoped enumeration type; or
 - both operands are pointers to cv-qualified or cv-unqualified versions
   of the same completely-defined object type; or
 - the left operand is a pointer to a completely-defined object type and
-  the right operand has integral or unscoped enumeration type.
 The result of the binary `+` operator is the sum of the operands. The
 result of the binary `-` operator is the difference resulting from the
 subtraction of the second operand from the first.
 When an expression `J` that has integral type is added to or subtracted
 from an expression `P` of pointer type, the result has the type of `P`.
 - If `P` evaluates to a null pointer value and `J` evaluates to 0, the
   result is a null pointer value.
-- Otherwise, if `P` points to an array element i of an array object `x`
-  with n elements [[dcl.array]],[^29] the expressions `P + J` and
-  `J + P` (where `J` has the value j) point to the
-  (possibly-hypothetical) array element i + j of `x` if 0 ≤ i + j ≤ n
-  and the expression `P - J` points to the (possibly-hypothetical) array
-  element i - j of `x` if 0 ≤ i - j ≤ n.
 - Otherwise, the behavior is undefined.
 [*Note 1*: Adding a value other than 0 or 1 to a pointer to a base
 class subobject, a member subobject, or a complete object results in
 undefined behavior. — *end note*]
 When two pointer expressions `P` and `Q` are subtracted, the type of the
 result is an *implementation-defined* signed integral type; this type
-shall be the same type that is defined as `std::ptrdiff_t` in the
 `<cstddef>` header [[support.types.layout]].
 - If `P` and `Q` both evaluate to null pointer values, the result is 0.
 - Otherwise, if `P` and `Q` point to, respectively, array elements i and
   j of the same array object `x`, the expression `P - Q` has the value
-  i - j.
-- Otherwise, the behavior is undefined. \[*Note 2*: If the value i - j
- is not in the range of representable values of type `std::ptrdiff_t`,
- the behavior is undefined. — *end note*]
 For addition or subtraction, if the expressions `P` or `Q` have type
 “pointer to cv `T`”, where `T` and the array element type are not
 similar [[conv.qual]], the behavior is undefined.
@@ -4860,23 +5572,24 @@ shift-expression:
     additive-expression
     shift-expression '<<' additive-expression
     shift-expression '>>' additive-expression
 ```
-The operands shall be of integral or unscoped enumeration type and
-integral promotions are performed. The type of the result is that of the
-promoted left operand. The behavior is undefined if the right operand is
-negative, or greater than or equal to the width of the promoted left
-operand.
 The value of `E1 << E2` is the unique value congruent to `E1` × 2^`E2`
 modulo 2ᴺ, where N is the width of the type of the result.
 [*Note 1*: `E1` is left-shifted `E2` bit positions; vacated bits are
 zero-filled. — *end note*]
-The value of `E1 >> E2` is `E1` / 2^`E2`, rounded down.
 [*Note 2*: `E1` is right-shifted `E2` bit positions. Right-shift on
 signed integral types is an arithmetic right shift, which performs
 sign-extension. — *end note*]
@@ -4969,28 +5682,28 @@ relational-expression:
     relational-expression '>' compare-expression
     relational-expression '<=' compare-expression
     relational-expression '>=' compare-expression
 ```
-The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
-function-to-pointer [[conv.func]] standard conversions are performed on
-the operands. The comparison is deprecated if both operands were of
-array type prior to these conversions [[depr.array.comp]].
 The converted operands shall have arithmetic, enumeration, or pointer
 type. The operators `<` (less than), `>` (greater than), `<=` (less than
 or equal to), and `>=` (greater than or equal to) all yield `false` or
 `true`. The type of the result is `bool`.
 The usual arithmetic conversions [[expr.arith.conv]] are performed on
-operands of arithmetic or enumeration type. If both operands are
-pointers, pointer conversions [[conv.ptr]] and qualification conversions
-[[conv.qual]] are performed to bring them to their composite pointer
-type [[expr.type]]. After conversions, the operands shall have the same
-type.
-The result of comparing unequal pointers to objects[^30]
 is defined in terms of a partial order consistent with the following
 rules:
 - If two pointers point to different elements of the same array, or to
@@ -5010,12 +5723,12 @@ a pointer to object `p` compares greater than a pointer `q`, `p>=q`,
 `p>q`, `q<=p`, and `q<p` all yield `true` and `p<=q`, `p<q`, `q>=p`, and
 `q>p` all yield `false`. Otherwise, the result of each of the operators
 is unspecified.
 [*Note 1*: A relational operator applied to unequal function pointers
-or to unequal pointers to `void` yields an unspecified
-result. — *end note*]
 If both operands (after conversions) are of arithmetic or enumeration
 type, each of the operators shall yield `true` if the specified
 relationship is true and `false` if it is false.
@@ -5027,31 +5740,30 @@ equality-expression:
     equality-expression '==' relational-expression
     equality-expression '!=' relational-expression
 ```
 The `==` (equal to) and the `!=` (not equal to) operators group
-left-to-right. The lvalue-to-rvalue [[conv.lval]], array-to-pointer
-[[conv.array]], and function-to-pointer [[conv.func]] standard
-conversions are performed on the operands. The comparison is deprecated
-if both operands were of array type prior to these conversions
-[[depr.array.comp]].
-The converted operands shall have arithmetic, enumeration, pointer, or
-pointer-to-member type, 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.
-If at least one of the operands is a pointer, pointer conversions
-[[conv.ptr]], function pointer conversions [[conv.fctptr]], and
-qualification conversions [[conv.qual]] are performed on both operands
-to bring them to their composite pointer type [[expr.type]]. Comparing
-pointers is defined as follows:
 - If one pointer represents the address of a complete object, and
   another pointer represents the address one past the last element of a
-  different complete object,[^31] the result of the comparison is
   unspecified.
 - Otherwise, if the pointers are both null, both point to the same
   function, or both represent the same address [[basic.compound]], they
   compare equal.
 - Otherwise, the pointers compare unequal.
@@ -5111,10 +5823,23 @@ performed on both operands to bring them to their composite pointer type
   — *end example*]
 Two operands of type `std::nullptr_t` or one operand of type
 `std::nullptr_t` and the other a null pointer constant compare equal.
 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.
@@ -5269,33 +5994,36 @@ type `T2` of the operand expression `E2` as follows:
   but an implicit conversion sequence can only be formed if the
   reference would bind directly.
 - If `E2` is a prvalue or if neither of the conversion sequences above
   can be formed and at least one of the operands has (possibly
   cv-qualified) class type:
-  - if `T1` and `T2` are the same class type (ignoring cv-qualification)
- and `T2` is at least as cv-qualified as `T1`, the target type is
       `T2`,
   - otherwise, if `T2` is a base class of `T1`, the target type is *cv1*
-    `T2`, where *cv1* denotes the cv-qualifiers of `T1`,
   - otherwise, the target type is the type that `E2` would have after
     applying the lvalue-to-rvalue [[conv.lval]], array-to-pointer
     [[conv.array]], and function-to-pointer [[conv.func]] standard
     conversions.
 Using this process, it is determined whether an implicit conversion
 sequence can be formed from the second operand to the target type
-determined for the third operand, and vice versa. If both sequences can
-be formed, or one can be formed but it is the ambiguous conversion
-sequence, the program is ill-formed. If no conversion sequence can be
-formed, the operands are left unchanged and further checking is
-performed as described below. Otherwise, if exactly one conversion
-sequence can be formed, that conversion is applied to the chosen operand
-and the converted operand is used in place of the original operand for
-the remainder of this subclause.
-[*Note 3*: The conversion might be ill-formed even if an implicit
-conversion sequence could be formed. — *end note*]
 If the second and third operands are glvalues of the same value category
 and have the same type, the result is of that type and value category
 and it is a bit-field if the second or the third operand is a bit-field,
 or if both are bit-fields.
@@ -5307,41 +6035,40 @@ to be applied to the operands [[over.match.oper]], [[over.built]]. If
 the overload resolution fails, the program is ill-formed. Otherwise, the
 conversions thus determined are applied, and the converted operands are
 used in place of the original operands for the remainder of this
 subclause.
-Lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
-function-to-pointer [[conv.func]] standard conversions are performed on
-the second and third operands. After those conversions, one of the
-following shall hold:
 - The second and third operands have the same type; the result is of
-  that type and the result object is initialized using the selected
   operand.
 - The second and third operands have arithmetic or enumeration type; the
   usual arithmetic conversions [[expr.arith.conv]] are performed to
   bring them to a common type, and the result is of that type.
 - One or both of the second and third operands have pointer type;
- pointer conversions [[conv.ptr]], function pointer conversions
   [[conv.fctptr]], and qualification conversions [[conv.qual]] are
   performed to bring them to their composite pointer type [[expr.type]].
   The result is of the composite pointer type.
 - One or both of the second and third operands have pointer-to-member
-  type; pointer to member conversions [[conv.mem]], function pointer
- conversions [[conv.fctptr]], and qualification conversions
   [[conv.qual]] are performed to bring them to their composite pointer
   type [[expr.type]]. The result is of the composite pointer type.
 - Both the second and third operands have type `std::nullptr_t` or one
   has that type and the other is a null pointer constant. The result is
   of type `std::nullptr_t`.
 ### Yielding a value <a id="expr.yield">[[expr.yield]]</a>
 ``` bnf
 yield-expression:
- 'co_yield' assignment-expression
- 'co_yield' braced-init-list
 ```
 A *yield-expression* shall appear only within a suspension context of a
 function [[expr.await]]. Let *e* be the operand of the
 *yield-expression* and *p* be an lvalue naming the promise object of the
@@ -5393,20 +6120,24 @@ throw-expression:
     throw assignment-expressionₒₚₜ
 ```
 A *throw-expression* is of type `void`.
-Evaluating a *throw-expression* with an operand throws an exception
-[[except.throw]]; the type of the exception object is determined by
-removing any top-level *cv-qualifier*s from the static type of the
-operand and adjusting the type from “array of `T`” or function type `T`
-to “pointer to `T`”.
 A *throw-expression* with no operand rethrows the currently handled
-exception [[except.handle]]. The exception is reactivated with the
-existing exception object; no new exception object is created. The
-exception is no longer considered to be caught.
 [*Example 1*:
 An exception handler that cannot completely handle the exception itself
 can be written like this:
@@ -5420,15 +6151,11 @@ try {
 }
 ```
 — *end example*]
-If no exception is presently being handled, evaluating a
-*throw-expression* with no operand calls `std::{}terminate()`
-[[except.terminate]].
-### Assignment and compound assignment operators <a id="expr.ass">[[expr.ass]]</a>
 The assignment operator (`=`) and the compound assignment operators all
 group right-to-left. All require a modifiable lvalue as their left
 operand; their result is an lvalue of the type of the left operand,
 referring to the left operand. The result in all cases is a bit-field if
@@ -5454,13 +6181,14 @@ assignment-expression:
 ``` bnf
 assignment-operator: one of
     '= *= /= %= += -= >>= <<= &= ^= |='
 ```
-In simple assignment (`=`), the object referred to by the left operand
-is modified [[defns.access]] by replacing its value with the result of
-the right operand.
 If the right operand is an expression, it is implicitly converted
 [[conv]] to the cv-unqualified type of the left operand.
 When the left operand of an assignment operator is a bit-field that
@@ -5490,19 +6218,18 @@ the behavior is undefined.
 [*Note 3*: This restriction applies to the relationship between the
 left and right sides of the assignment operation; it is not a statement
 about how the target of the assignment can be aliased in general. See
 [[basic.lval]]. — *end note*]
-A *braced-init-list* may appear on the right-hand side of
-- an assignment to a scalar, in which case the initializer list shall
- have at most a single element. The meaning of `x = {v}`, where `T` is
- the scalar type of the expression `x`, is that of `x = T{v}`. The
-  meaning of `x = {}` is `x = T{}`.
-- an assignment to an object of class type, in which case the
- initializer list is passed as the argument to the assignment operator
-  function selected by overload resolution [[over.ass]], [[over.match]].
 [*Example 1*:
 ``` cpp
 complex<double> z;
@@ -5558,31 +6285,130 @@ has three arguments, the second of which has the value `5`.
 Certain contexts require expressions that satisfy additional
 requirements as detailed in this subclause; other contexts have
 different semantics depending on whether or not an expression satisfies
 these requirements. Expressions that satisfy these requirements,
 assuming that copy elision [[class.copy.elision]] is not performed, are
-called *constant expressions*.
 [*Note 1*: Constant expressions can be evaluated during
 translation. — *end note*]
 ``` bnf
 constant-expression:
     conditional-expression
 ```
-A variable or temporary object `o` is *constant-initialized* if
-- either it has an initializer or its default-initialization results in
-  some initialization being performed, and
 - the full-expression of its initialization is a constant expression
-  when interpreted as a *constant-expression*, except that if `o` is an
- object, that full-expression may also invoke constexpr constructors
- for `o` and its subobjects even if those objects are of non-literal
- class types. \[*Note 2*: Such a class can have a non-trivial
- destructor. Within this evaluation, `std::is_constant_evaluated()`
- [[meta.const.eval]] returns `true`. — *end note*]
 A variable is *potentially-constant* if it is constexpr or it has
 reference or non-volatile const-qualified integral or enumeration type.
 A constant-initialized potentially-constant variable V is *usable in
@@ -5591,54 +6417,80 @@ reachable from P and
 - V is constexpr,
 - V is not initialized to a TU-local value, or
 - P is in the same translation unit as D.
-An object or reference is *usable in constant expressions* if it is
-- a variable that is usable in constant expressions, or
-- a template parameter object [[temp.param]], or
-- a string literal object [[lex.string]], or
 - a temporary object of non-volatile const-qualified literal type whose
   lifetime is extended [[class.temporary]] to that of a variable that is
-  usable in constant expressions, or
-- a non-mutable subobject or reference member of any of the above.
 An expression E is a *core constant expression* unless the evaluation of
 E, following the rules of the abstract machine [[intro.execution]],
 would evaluate one of the following:
 - `this` [[expr.prim.this]], except
   - in a constexpr function [[dcl.constexpr]] that is being evaluated as
     part of E or
   - when appearing as the *postfix-expression* of an implicit or
     explicit class member access expression [[expr.ref]];
-- a control flow that passes through a declaration of a variable with
- static [[basic.stc.static]] or thread [[basic.stc.thread]] storage
-  duration, unless that variable is usable in constant expressions;
- \[*Example 1*:
   ``` cpp
   constexpr char test() {
     static const int x = 5;
     static constexpr char c[] = "Hello World";
     return *(c + x);
   }
   static_assert(' ' == test());
   ```
   — *end example*]
-- an invocation of a non-constexpr function;[^32]
 - an invocation of an undefined constexpr function;
 - an invocation of an instantiated constexpr function that is not
   constexpr-suitable;
 - an invocation of a virtual function [[class.virtual]] for an object
   whose dynamic type is constexpr-unknown;
 - an expression that would exceed the implementation-defined limits (see
   [[implimits]]);
-- an operation that would have undefined behavior as specified in
-  [[intro]] through [[cpp]], excluding [[dcl.attr.assume]];[^33]
 - an lvalue-to-rvalue conversion [[conv.lval]] unless it is applied to
   - a non-volatile glvalue that refers to an object that is usable in
     constant expressions, or
   - a non-volatile glvalue of literal type that refers to a non-volatile
     object whose lifetime began within the evaluation of E;
 - an lvalue-to-rvalue conversion that is applied to a glvalue that
@@ -5651,11 +6503,11 @@ would evaluate one of the following:
   evaluation of E;
 - in a *lambda-expression*, a reference to `this` or to a variable with
   automatic storage duration defined outside that *lambda-expression*,
   where the reference would be an odr-use
   [[term.odr.use]], [[expr.prim.lambda]];
-  \[*Example 2*:
   ``` cpp
   void g() {
     const int n = 0;
     [=] {
       constexpr int i = n;        // OK, n is not odr-used here
@@ -5663,17 +6515,17 @@ would evaluate one of the following:
     };
   }
   ```
   — *end example*]
-  \[*Note 3*:
   If the odr-use occurs in an invocation of a function call operator of
   a closure type, it no longer refers to `this` or to an enclosing
-  automatic variable due to the transformation
   [[expr.prim.lambda.capture]] of the *id-expression* into an access of
   the corresponding data member.
-  \[*Example 3*:
   ``` cpp
   auto monad = [](auto v) { return [=] { return v; }; };
   auto bind = [](auto m) {
     return [=](auto fvm) { return fvm(m()); };
   };
@@ -5682,61 +6534,82 @@ would evaluate one of the following:
   static_assert(bind(monad(2))(monad)() == monad(2)());
   ```
   — *end example*]
   — *end note*]
-- a conversion from type cv `void*` to a pointer-to-object type;
 - a `reinterpret_cast` [[expr.reinterpret.cast]];
 - a modification of an object
-  [[expr.ass]], [[expr.post.incr]], [[expr.pre.incr]] unless it is
   applied to a non-volatile lvalue of literal type that refers to a
   non-volatile object whose lifetime began within the evaluation of E;
 - an invocation of a destructor [[class.dtor]] or a function call whose
   *postfix-expression* names a pseudo-destructor [[expr.call]], in
   either case for an object whose lifetime did not begin within the
   evaluation of E;
-- a *new-expression* [[expr.new]], unless the selected allocation
-  function is a replaceable global allocation function
- [[new.delete.single]], [[new.delete.array]] and the allocated storage
- is deallocated within the evaluation of E;
 - a *delete-expression* [[expr.delete]], unless it deallocates a region
   of storage allocated within the evaluation of E;
 - a call to an instance of `std::allocator<T>::allocate`
   [[allocator.members]], unless the allocated storage is deallocated
   within the evaluation of E;
 - a call to an instance of `std::allocator<T>::deallocate`
   [[allocator.members]], unless it deallocates a region of storage
   allocated within the evaluation of E;
 - an *await-expression* [[expr.await]];
 - a *yield-expression* [[expr.yield]];
 - a three-way comparison [[expr.spaceship]], relational [[expr.rel]], or
   equality [[expr.eq]] operator where the result is unspecified;
-- a *throw-expression* [[expr.throw]];
 - a `dynamic_cast` [[expr.dynamic.cast]] or `typeid` [[expr.typeid]]
   expression on a glvalue that refers to an object whose dynamic type is
-  constexpr-unknown or that would throw an exception;
 - an *asm-declaration* [[dcl.asm]];
 - an invocation of the `va_arg` macro [[cstdarg.syn]];
 - a non-constant library call [[defns.nonconst.libcall]]; or
-- a `goto` statement [[stmt.goto]].
 It is unspecified whether E is a core constant expression if E satisfies
 the constraints of a core constant expression, but evaluation of E would
 evaluate
 - an operation that has undefined behavior as specified in [[library]]
-  through [[thread]],
-- an invocation of the `va_start` macro [[cstdarg.syn]], or
-- a statement with an assumption [[dcl.attr.assume]] whose converted
-  *conditional-expression*, if evaluated where the assumption appears,
-  would not disqualify E from being a core constant expression and would
-  not evaluate to `true`. \[*Note 4*: E is not disqualified from being a
-  core constant expression if the hypothetical evaluation of the
-  converted *conditional-expression* would disqualify E from being a
-  core constant expression. — *end note*]
-[*Example 4*:
 ``` cpp
 int x;                              // not constant
 struct A {
   constexpr A(bool b) : m(b?42:x) { }
@@ -5777,38 +6650,70 @@ constexpr int y = h(1);             // OK, initializes y with the value 2
 — *end example*]
 For the purposes of determining whether an expression E is a core
 constant expression, the evaluation of the body of a member function of
 `std::allocator<T>` as defined in [[allocator.members]], where `T` is a
-literal type, is ignored. Similarly, the evaluation of the body of
-`std::construct_at` or `std::ranges::construct_at` is considered to
-include only the underlying constructor call if the first argument (of
-type `T*`) points to storage allocated with `std::allocator<T>` or to an
-object whose lifetime began within the evaluation of E.
 For the purposes of determining whether E is a core constant expression,
 the evaluation of a call to a trivial copy/move constructor or copy/move
 assignment operator of a union is considered to copy/move the active
 member of the union, if any.
-[*Note 5*: The copy/move of the active member is
 trivial. — *end note*]
 During the evaluation of an expression E as a core constant expression,
-all *id-expression*s and uses of `*this` that refer to an object or
-reference whose lifetime did not begin with the evaluation of E are
-treated as referring to a specific instance of that object or reference
-whose lifetime and that of all subobjects (including all union members)
-includes the entire constant evaluation. For such an object that is not
-usable in constant expressions, the dynamic type of the object is
-*constexpr-unknown*. For such a reference that is not usable in constant
-expressions, the reference is treated as binding to an unspecified
-object of the referenced type whose lifetime and that of all subobjects
-includes the entire constant evaluation and whose dynamic type is
-constexpr-unknown.
-[*Example 5*:
 ``` cpp
 template <typename T, size_t N>
 constexpr size_t array_size(T (&)[N]) {
   return N;
@@ -5860,36 +6765,36 @@ constexpr auto& sandeno   = typeid(dc);         // OK, can only be typeid(Swim)
 constexpr auto& gallagher = typeid(trident);    // error: constexpr-unknown dynamic type
 ```
 — *end example*]
-An object `a` is said to have *constant destruction* if:
 - it is not of class type nor (possibly multidimensional) array thereof,
   or
 - it is of class type or (possibly multidimensional) array thereof, that
-  class type has a constexpr destructor, and for a hypothetical
-  expression E whose only effect is to destroy `a`, E would be a core
-  constant expression if the lifetime of `a` and its non-mutable
-  subobjects (but not its mutable subobjects) were considered to start
-  within E.
 An *integral constant expression* is an expression of integral or
 unscoped enumeration type, implicitly converted to a prvalue, where the
 converted expression is a core constant expression.
-[*Note 6*: Such expressions can be used as bit-field lengths
 [[class.bit]], as enumerator initializers if the underlying type is not
 fixed [[dcl.enum]], and as alignments [[dcl.align]]. — *end note*]
 If an expression of literal class type is used in a context where an
 integral constant expression is required, then that expression is
 contextually implicitly converted [[conv]] to an integral or unscoped
 enumeration type and the selected conversion function shall be
 `constexpr`.
-[*Example 6*:
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
   constexpr operator int() const { return val; }
@@ -5914,82 +6819,110 @@ constant expression and the implicit conversion sequence contains only
 - function-to-pointer conversions [[conv.func]],
 - qualification conversions [[conv.qual]],
 - integral promotions [[conv.prom]],
 - integral conversions [[conv.integral]] other than narrowing
   conversions [[dcl.init.list]],
 - null pointer conversions [[conv.ptr]] from `std::nullptr_t`,
 - null member pointer conversions [[conv.mem]] from `std::nullptr_t`,
   and
 - function pointer conversions [[conv.fctptr]],
 and where the reference binding (if any) binds directly.
-[*Note 7*: Such expressions can be used in `new` expressions
 [[expr.new]], as case expressions [[stmt.switch]], as enumerator
 initializers if the underlying type is fixed [[dcl.enum]], as array
-bounds [[dcl.array]], and as non-type template arguments
-[[temp.arg]]. — *end note*]
 A *contextually converted constant expression of type `bool`* is an
 expression, contextually converted to `bool` [[conv]], where the
 converted expression is a constant expression and the conversion
 sequence contains only the conversions above.
-A *constant expression* is either a glvalue core constant expression
-that refers to an entity that is a permitted result of a constant
-expression (as defined below), or a prvalue core constant expression
-whose value satisfies the following constraints:
-- 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,
-- if the value is an object of scalar type, it does not have an
-  indeterminate value [[basic.indet]],
-- if the value is of pointer type, it contains the address of an object
-  with static storage duration, the address past the end of such an
-  object [[expr.add]], the address of a non-immediate function, or a
-  null pointer value,
-- if the value is of pointer-to-member-function type, it does not
-  designate an immediate function, and
-- if the value is an object of class or array type, each subobject
-  satisfies these constraints for the value.
-An entity is a *permitted result of a constant expression* if it is an
-object with static storage duration that either is not a temporary
-object or is a temporary object whose value satisfies the above
-constraints, or if it is a non-immediate function.
-[*Note 8*: A glvalue core constant expression that either refers to or
 points to an unspecified object is not a constant
 expression. — *end note*]
-[*Example 7*:
 ``` cpp
 consteval int f() { return 42; }
 consteval auto g() { return f; }
 consteval int h(int (*p)() = g()) { return p(); }
 constexpr int r = h();                          // OK
 constexpr auto e = g();                         // error: a pointer to an immediate function is
                                                 // not a permitted result of a constant expression
 ```
 — *end example*]
 *Recommended practice:* Implementations should provide consistent
 results of floating-point evaluations, irrespective of whether the
 evaluation is performed during translation or during program execution.
-[*Note 9*:
 Since this document imposes no restrictions on the accuracy of
 floating-point operations, it is unspecified whether the evaluation of a
 floating-point expression during translation yields the same result as
 the evaluation of the same expression (or the same operations on the
 same values) during program execution.
-[*Example 8*:
 ``` cpp
 bool f() {
     char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Must be evaluated during translation
     int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // May be evaluated at runtime
@@ -6018,17 +6951,18 @@ potentially-evaluated explicit or implicit invocation of an immediate
 function and is not in an immediate function context. An aggregate
 initialization is an immediate invocation if it evaluates a default
 member initializer that has a subexpression that is an
 immediate-escalating expression.
-An expression or conversion is *immediate-escalating* if it is not
-initially in an immediate function context and it is either
-- a potentially-evaluated *id-expression* that denotes an immediate
- function that is not a subexpression of an immediate invocation, or
-- an immediate invocation that is not a constant expression and is not a
-  subexpression of an immediate invocation.
 An *immediate-escalating* function is
 - the call operator of a lambda that is not declared with the
   `consteval` specifier,
@@ -6038,18 +6972,22 @@ An *immediate-escalating* function is
   defined with the `constexpr` specifier.
 An immediate-escalating expression shall appear only in an
 immediate-escalating function.
-An *immediate function* is a function or constructor that is
 - declared with the `consteval` specifier, or
-- an immediate-escalating function `F` whose function body contains an
- immediate-escalating expression `E` such that `E`’s innermost
- enclosing non-block scope is `F`’s function parameter scope.
-[*Example 9*:
 ``` cpp
 consteval int id(int i) { return i; }
 constexpr char id(char c) { return c; }
@@ -6079,16 +7017,17 @@ static_assert(is_not(5, is_even));      // OK
 int x = 0;
 template<class T>
 constexpr T h(T t = id(x)) {    // h<int> is not an immediate function
     return t;
 }
 template<class T>
-constexpr T hh() {              // hh<int> is an immediate function
-  return h<T>();
 }
 int i = hh<int>();              // error: hh<int>() is an immediate-escalating expression
                                 // outside of an immediate-escalating function
@@ -6099,10 +7038,19 @@ struct A {
 template<class T>
 constexpr int k(int) {          // k<int> is not an immediate function because A(42) is a
   return A(42).y;               // constant expression and thus not immediate-escalating
 }
 ```
 — *end example*]
 An expression or conversion is *manifestly constant-evaluated* if it is:
@@ -6111,12 +7059,12 @@ An expression or conversion is *manifestly constant-evaluated* if it is:
 - the condition of a constexpr if statement [[stmt.if]], or
 - an immediate invocation, or
 - the result of substitution into an atomic constraint expression to
   determine whether it is satisfied [[temp.constr.atomic]], or
 - the initializer of a variable that is usable in constant expressions
-  or has constant initialization [[basic.start.static]].[^34]
-  \[*Example 10*:
   ``` cpp
   template<bool> struct X {};
   X<std::is_constant_evaluated()> x;                      // type X<true>
   int y;
   const int a = std::is_constant_evaluated() ? y : 1;     // dynamic initialization to 1
@@ -6135,22 +7083,140 @@ An expression or conversion is *manifestly constant-evaluated* if it is:
   int q = p + f();                                        // m is 17 for this call; initialized to 56
   ```
   — *end example*]
-[*Note 10*: A manifestly constant-evaluated expression is evaluated
-even in an unevaluated operand
-[[term.unevaluated.operand]]. — *end note*]
 An expression or conversion is *potentially constant evaluated* if it
 is:
 - a manifestly constant-evaluated expression,
 - a potentially-evaluated expression [[basic.def.odr]],
-- an immediate subexpression of a *braced-init-list*,[^35]
 - an expression of the form `&` *cast-expression* that occurs within a
-  templated entity,[^36] or
 - a potentially-evaluated subexpression [[intro.execution]] of one of
   the above.
 A function or variable is *needed for constant evaluation* if it is:
@@ -6158,42 +7224,51 @@ A function or variable is *needed for constant evaluation* if it is:
   that is potentially constant evaluated, or
 - a potentially-constant variable named by a potentially constant
   evaluated expression.
 <!-- Link reference definitions -->
 [allocator.members]: mem.md#allocator.members
 [bad.alloc]: support.md#bad.alloc
 [bad.cast]: support.md#bad.cast
 [bad.typeid]: support.md#bad.typeid
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.indet]: basic.md#basic.indet
 [basic.life]: basic.md#basic.life
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.general]: basic.md#basic.lookup.general
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: #basic.lval
 [basic.pre]: basic.md#basic.pre
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.class]: basic.md#basic.scope.class
 [basic.scope.lambda]: basic.md#basic.scope.lambda
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.static]: basic.md#basic.start.static
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [class]: class.md#class
 [class.abstract]: class.md#class.abstract
 [class.access]: class.md#class.access
 [class.access.base]: class.md#class.access.base
 [class.base.init]: class.md#class.base.init
 [class.bit]: class.md#class.bit
 [class.cdtor]: class.md#class.cdtor
 [class.conv]: class.md#class.conv
 [class.conv.fct]: class.md#class.conv.fct
@@ -6204,14 +7279,15 @@ A function or variable is *needed for constant evaluation* if it is:
 [class.derived]: class.md#class.derived
 [class.dtor]: class.md#class.dtor
 [class.free]: class.md#class.free
 [class.friend]: class.md#class.friend
 [class.mem]: class.md#class.mem
 [class.member.lookup]: basic.md#class.member.lookup
-[class.mfct]: class.md#class.mfct
 [class.mfct.non.static]: class.md#class.mfct.non.static
 [class.mi]: class.md#class.mi
 [class.prop]: class.md#class.prop
 [class.spaceship]: class.md#class.spaceship
 [class.static.mfct]: class.md#class.static.mfct
 [class.temporary]: basic.md#class.temporary
 [class.union]: class.md#class.union
@@ -6234,62 +7310,67 @@ A function or variable is *needed for constant evaluation* if it is:
 [conv.prom]: #conv.prom
 [conv.ptr]: #conv.ptr
 [conv.qual]: #conv.qual
 [conv.rank]: basic.md#conv.rank
 [conv.rval]: #conv.rval
-[cpp]: cpp.md#cpp
 [cstdarg.syn]: support.md#cstdarg.syn
 [cstddef.syn]: support.md#cstddef.syn
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
 [dcl.asm]: dcl.md#dcl.asm
-[dcl.attr.assume]: dcl.md#dcl.attr.assume
 [dcl.constexpr]: dcl.md#dcl.constexpr
-[dcl.dcl]: dcl.md#dcl.dcl
 [dcl.decl]: dcl.md#dcl.decl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.init.string]: dcl.md#dcl.init.string
 [dcl.link]: dcl.md#dcl.link
 [dcl.mptr]: dcl.md#dcl.mptr
 [dcl.name]: dcl.md#dcl.name
 [dcl.ptr]: dcl.md#dcl.ptr
 [dcl.ref]: dcl.md#dcl.ref
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.struct.bind]: dcl.md#dcl.struct.bind
 [dcl.type]: dcl.md#dcl.type
 [dcl.type.auto.deduct]: dcl.md#dcl.type.auto.deduct
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [dcl.type.decltype]: dcl.md#dcl.type.decltype
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [defns.access]: intro.md#defns.access
 [defns.nonconst.libcall]: intro.md#defns.nonconst.libcall
-[depr.arith.conv.enum]: future.md#depr.arith.conv.enum
-[depr.array.comp]: future.md#depr.array.comp
 [depr.capture.this]: future.md#depr.capture.this
 [depr.volatile.type]: future.md#depr.volatile.type
 [except]: except.md#except
 [except.handle]: except.md#except.handle
 [except.pre]: except.md#except.pre
 [except.spec]: except.md#except.spec
 [except.terminate]: except.md#except.terminate
 [except.throw]: except.md#except.throw
 [expr]: #expr
 [expr.add]: #expr.add
 [expr.alignof]: #expr.alignof
 [expr.arith.conv]: #expr.arith.conv
-[expr.ass]: #expr.ass
 [expr.await]: #expr.await
 [expr.bit.and]: #expr.bit.and
 [expr.call]: #expr.call
 [expr.cast]: #expr.cast
 [expr.comma]: #expr.comma
@@ -6312,30 +7393,34 @@ A function or variable is *needed for constant evaluation* if it is:
 [expr.post.incr]: #expr.post.incr
 [expr.pre]: #expr.pre
 [expr.pre.incr]: #expr.pre.incr
 [expr.prim]: #expr.prim
 [expr.prim.fold]: #expr.prim.fold
 [expr.prim.id]: #expr.prim.id
 [expr.prim.id.dtor]: #expr.prim.id.dtor
 [expr.prim.id.general]: #expr.prim.id.general
 [expr.prim.id.qual]: #expr.prim.id.qual
 [expr.prim.id.unqual]: #expr.prim.id.unqual
 [expr.prim.lambda]: #expr.prim.lambda
 [expr.prim.lambda.capture]: #expr.prim.lambda.capture
 [expr.prim.lambda.closure]: #expr.prim.lambda.closure
 [expr.prim.lambda.general]: #expr.prim.lambda.general
 [expr.prim.literal]: #expr.prim.literal
 [expr.prim.paren]: #expr.prim.paren
 [expr.prim.req]: #expr.prim.req
 [expr.prim.req.compound]: #expr.prim.req.compound
 [expr.prim.req.general]: #expr.prim.req.general
 [expr.prim.req.nested]: #expr.prim.req.nested
 [expr.prim.req.simple]: #expr.prim.req.simple
 [expr.prim.req.type]: #expr.prim.req.type
 [expr.prim.this]: #expr.prim.this
 [expr.prop]: #expr.prop
 [expr.ref]: #expr.ref
 [expr.reinterpret.cast]: #expr.reinterpret.cast
 [expr.rel]: #expr.rel
 [expr.shift]: #expr.shift
 [expr.sizeof]: #expr.sizeof
 [expr.spaceship]: #expr.spaceship
@@ -6358,67 +7443,81 @@ A function or variable is *needed for constant evaluation* if it is:
 [intro.memory]: basic.md#intro.memory
 [intro.object]: basic.md#intro.object
 [lex.ext]: lex.md#lex.ext
 [lex.icon]: lex.md#lex.icon
 [lex.literal]: lex.md#lex.literal
 [lex.string]: lex.md#lex.string
 [library]: library.md#library
 [meta.const.eval]: meta.md#meta.const.eval
 [namespace.udecl]: dcl.md#namespace.udecl
 [new.badlength]: support.md#new.badlength
 [new.delete.array]: support.md#new.delete.array
 [new.delete.placement]: support.md#new.delete.placement
 [new.delete.single]: support.md#new.delete.single
 [over]: over.md#over
-[over.ass]: over.md#over.ass
 [over.best.ics]: over.md#over.best.ics
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
 [over.call.func]: over.md#over.call.func
 [over.ics.user]: over.md#over.ics.user
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.class.deduct]: over.md#over.match.class.deduct
 [over.match.oper]: over.md#over.match.oper
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [over.sub]: over.md#over.sub
 [replacement.functions]: library.md#replacement.functions
 [special]: class.md#special
 [std.modules]: library.md#std.modules
 [stmt.goto]: stmt.md#stmt.goto
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: support.md#support.runtime
 [support.types.layout]: support.md#support.types.layout
 [temp.arg]: temp.md#temp.arg
 [temp.concept]: temp.md#temp.concept
 [temp.constr.atomic]: temp.md#temp.constr.atomic
 [temp.constr.constr]: temp.md#temp.constr.constr
 [temp.constr.decl]: temp.md#temp.constr.decl
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.mem]: temp.md#temp.mem
 [temp.names]: temp.md#temp.names
 [temp.over.link]: temp.md#temp.over.link
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
 [temp.spec.partial]: temp.md#temp.spec.partial
 [temp.variadic]: temp.md#temp.variadic
 [term.incomplete.type]: basic.md#term.incomplete.type
 [term.object.representation]: basic.md#term.object.representation
 [term.odr.use]: basic.md#term.odr.use
 [term.unevaluated.operand]: #term.unevaluated.operand
-[thread]: thread.md#thread
 [type.info]: support.md#type.info
 [typeinfo.syn]: support.md#typeinfo.syn
 [^1]: The precedence of operators is not directly specified, but it can
     be derived from the syntax.
@@ -6426,23 +7525,22 @@ A function or variable is *needed for constant evaluation* if it is:
 [^2]: Overloaded operators are never assumed to be associative or
     commutative.
 [^3]: The cast and assignment operators must still perform their
     specific conversions as described in  [[expr.type.conv]],
-    [[expr.cast]], [[expr.static.cast]] and  [[expr.ass]].
 [^4]: The intent of this list is to specify those circumstances in which
     an object can or cannot be aliased.
 [^5]: For historical reasons, this conversion is called the
     “lvalue-to-rvalue” conversion, even though that name does not
     accurately reflect the taxonomy of expressions described in
     [[basic.lval]].
 [^6]: In C++ class and array prvalues can have cv-qualified types. This
-    differs from ISO C, in which non-lvalues never have cv-qualified
-    types.
 [^7]: This conversion never applies to non-static member functions
     because an lvalue that refers to a non-static member function cannot
     be obtained.
@@ -6458,99 +7556,92 @@ A function or variable is *needed for constant evaluation* if it is:
 [^9]: As a consequence, operands of type `bool`, `char8_t`, `char16_t`,
     `char32_t`, `wchar_t`, or of enumeration type are converted to some
     integral type.
-[^10]: This also applies when the object expression is an implicit
-    `(*this)` [[class.mfct.non.static]].
-[^11]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
 [^12]: If the class member access expression is evaluated, the
     subexpression evaluation happens even if the result is unnecessary
     to determine the value of the entire postfix expression, for example
     if the *id-expression* denotes a static member.
-[^13]: Note that `(*(E1))` is an lvalue.
-[^14]: The most derived object [[intro.object]] pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
-[^15]: The recommended name for such a class is `extended_type_info`.
-[^16]: If `p` is an expression of pointer type, then `*p`, `(*p)`,
-    `*(p)`, `((*p))`, `*((p))`, and so on all meet this requirement.
-[^17]: The types can have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^18]: `T1` and `T2` can have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^19]: This is sometimes referred to as a type pun when the result
     refers to the same object as the source glvalue.
-[^20]: `const_cast` is not limited to conversions that cast away a
     const-qualifier.
-[^21]: `sizeof``(``bool``)` is not required to be `1`.
-[^22]: The actual size of a potentially-overlapping subobject can be
     less than the result of applying `sizeof` to the subobject, due to
     virtual base classes and less strict padding requirements on
     potentially-overlapping subobjects.
-[^23]: If the conversion function returns a signed integer type, the
     second standard conversion converts to the unsigned type
     `std::size_t` and thus thwarts any attempt to detect a negative
     value afterwards.
-[^24]: This can include evaluating a *new-initializer* and/or calling a
     constructor.
-[^25]: A *lambda-expression* with a *lambda-introducer* that consists of
     empty square brackets can follow the `delete` keyword if the
     *lambda-expression* is enclosed in parentheses.
-[^26]: This implies that an object cannot be deleted using a pointer of
-    type `void*` because `void` is not an object type.
-[^27]: For nonzero-length arrays, this is the same as a pointer to the
     first element of the array created by that *new-expression*.
     Zero-length arrays do not have a first element.
-[^28]: This is often called truncation towards zero.
-[^29]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose and a pointer past the last element of an array of n
     elements is considered to be equivalent to a pointer to a
     hypothetical array element n for this purpose.
-[^30]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose and a pointer past the last element of an array of n
     elements is considered to be equivalent to a pointer to a
     hypothetical array element n for this purpose.
-[^31]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose.
-[^32]: Overload resolution [[over.match]] is applied as usual.
-[^33]: This includes, for example, signed integer overflow [[expr.pre]],
     certain pointer arithmetic [[expr.add]], division by zero
     [[expr.mul]], or certain shift operations [[expr.shift]].
-[^34]: Testing this condition can involve a trial evaluation of its
-    initializer as described above.
-[^35]: In some cases, constant evaluation is needed to determine whether
     a narrowing conversion is performed [[dcl.init.list]].
-[^36]: In some cases, constant evaluation is needed to determine whether
     such an expression is value-dependent [[temp.dep.constexpr]].

 this Standard. However, these built-in operators participate in overload
 resolution, and as part of that process user-defined conversions will be
 considered where necessary to convert the operands to types appropriate
 for the built-in operator. If a built-in operator is selected, such
 conversions will be applied to the operands before the operation is
+considered further according to the rules in [[expr.compound]]; see
+[[over.match.oper]], [[over.built]].
 If during the evaluation of an expression, the result is not
 mathematically defined or not in the range of representable values for
 its type, the behavior is undefined.
 <a id="fig:basic.lval"></a>
 ![Expression category taxonomy \[fig:basic.lval\]](images/valuecategories.svg)
 - A *glvalue* is an expression whose evaluation determines the identity
+  of an object, function, or non-static data member.
 - A *prvalue* is an expression whose evaluation initializes an object or
   computes the value of an operand of an operator, as specified by the
   context in which it appears, or an expression that has type cv `void`.
 - An *xvalue* is a glvalue that denotes an object whose resources can be
   reused (usually because it is near the end of its lifetime).
 - An *lvalue* is a glvalue that is not an xvalue.
 - An *rvalue* is a prvalue or an xvalue.
+Every expression belongs to exactly one of the fundamental categories in
+this taxonomy: lvalue, xvalue, or prvalue. This property of an
+expression is called its *value category*.
 [*Note 1*: The discussion of each built-in operator in
 [[expr.compound]] indicates the category of the value it yields and the
 value categories of the operands it expects. For example, the built-in
 assignment operators expect that the left operand is an lvalue and that
 [*Note 2*: Historically, lvalues and rvalues were so-called because
 they could appear on the left- and right-hand side of an assignment
 (although this is no longer generally true); glvalues are “generalized”
 lvalues, prvalues are “pure” rvalues, and xvalues are “eXpiring”
+lvalues. Despite their names, these terms apply to expressions, not
 values. — *end note*]
 [*Note 3*:
 An expression is an xvalue if it is:
+- a move-eligible *id-expression* [[expr.prim.id.unqual]] or
+  *splice-expression* [[expr.prim.splice]],
 - the result of calling a function, whether implicitly or explicitly,
   whose return type is an rvalue reference to object type [[expr.call]],
 - a cast to an rvalue reference to object type
   [[expr.type.conv]], [[expr.dynamic.cast]], [[expr.static.cast]], [[expr.reinterpret.cast]], [[expr.const.cast]], [[expr.cast]],
 - a subscripting operation with an xvalue array operand [[expr.sub]],
 The *result* of a glvalue is the entity denoted by the expression. The
 *result* of a prvalue is the value that the expression stores into its
 context; a prvalue that has type cv `void` has no result. A prvalue
 whose result is the value *V* is sometimes said to have or name the
 value *V*. The *result object* of a prvalue is the object initialized by
+the prvalue; a prvalue that has type cv `void` has no result object.
 [*Note 4*: Except when the prvalue is the operand of a
+*decltype-specifier*, a prvalue of object type always has a result
+object. For a discarded prvalue that has type other than cv `void`, a
+temporary object is materialized; see [[expr.context]]. — *end note*]
+Whenever a glvalue appears as an operand of an operator that requires a
 prvalue for that operand, the lvalue-to-rvalue [[conv.lval]],
 array-to-pointer [[conv.array]], or function-to-pointer [[conv.func]]
 standard conversions are applied to convert the expression to a prvalue.
 [*Note 5*: An attempt to bind an rvalue reference to an lvalue is not
 [*Note 7*: There are no prvalue bit-fields; if a bit-field is converted
 to a prvalue [[conv.lval]], a prvalue of the type of the bit-field is
 created, which might then be promoted [[conv.prom]]. — *end note*]
+Unless otherwise specified
+[[expr.reinterpret.cast]], [[expr.const.cast]], whenever a prvalue that
+is not the result of the lvalue-to-rvalue conversion [[conv.lval]]
+appears as an operand of an operator, the temporary materialization
+conversion [[conv.rval]] is applied to convert the expression to an
+xvalue.
+[*Note 8*: The discussion of reference initialization in
+[[dcl.init.ref]] and of temporaries in  [[class.temporary]] indicates
+the behavior of lvalues and rvalues in other significant
+contexts. — *end note*]
 Unless otherwise indicated [[dcl.type.decltype]], a prvalue shall always
 have complete type or the `void` type; if it has a class type or
 (possibly multidimensional) array of class type, that class shall not be
 an abstract class [[class.abstract]]. A glvalue shall not have type
 cv `void`.
+[*Note 9*: A glvalue can have complete or incomplete non-`void` type.
 Class and array prvalues can have cv-qualified types; other prvalues
 always have cv-unqualified types. See [[expr.type]]. — *end note*]
 An lvalue is *modifiable* unless its type is const-qualified or is a
 function type.
+[*Note 10*: A program that attempts to modify an object through a
 nonmodifiable lvalue or through an rvalue is ill-formed
+[[expr.assign]], [[expr.post.incr]], [[expr.pre.incr]]. — *end note*]
+An object of dynamic type `T`_obj is *type-accessible* through a glvalue
+of type `T`_ref if `T`_ref is similar [[conv.qual]] to:
+- `T`_obj,
+- a type that is the signed or unsigned type corresponding to `T`_obj,
+  or
 - a `char`, `unsigned char`, or `std::byte` type.
+If a program attempts to access [[defns.access]] the stored value of an
+object through a glvalue through which it is not type-accessible, the
+behavior is undefined.[^4]
 If a program invokes a defaulted copy/move constructor or copy/move
 assignment operator for a union of type `U` with a glvalue argument that
 does not denote an object of type cv `U` within its lifetime, the
 behavior is undefined.
+[*Note 11*: In C, an entire object of structure type can be accessed,
 e.g., using assignment. By contrast, C++ has no notion of accessing an
 object of class type through an lvalue of class type. — *end note*]
 ### Type <a id="expr.type">[[expr.type]]</a>
 If an expression initially has the type “reference to `T`”
 [[dcl.ref]], [[dcl.init.ref]], the type is adjusted to `T` prior to any
+further analysis; the value category of the expression is not altered.
+Let X be the object or function denoted by the reference. If a pointer
+to X would be valid in the context of the evaluation of the expression
+[[basic.fundamental]], the result designates X; otherwise, the behavior
+is undefined.
 [*Note 1*: Before the lifetime of the reference has started or after it
 has ended, the behavior is undefined (see
 [[basic.life]]). — *end note*]
   “pointer to *cv12* `void`”, where *cv12* is the union of *cv1* and
   *cv2*;
 - if `T1` or `T2` is “pointer to `noexcept` function” and the other type
   is “pointer to function”, where the function types are otherwise the
   same, “pointer to function”;
+- if `T1` is “pointer to `C1`” and `T2` is “pointer to `C2`”, where `C1`
+  is reference-related to `C2` or `C2` is reference-related to `C1`
+  [[dcl.init.ref]], the qualification-combined type [[conv.qual]] of
+  `T1` and `T2` or the qualification-combined type of `T2` and `T1`,
+  respectively;
 - if `T1` or `T2` is “pointer to member of `C1` of type function”, the
   other type is “pointer to member of `C2` of type `noexcept` function”,
   and `C1` is reference-related to `C2` or `C2` is reference-related to
   `C1` [[dcl.init.ref]], where the function types are otherwise the
   same, “pointer to member of `C2` of type function” or “pointer to
 — *end example*]
 ### Context dependence <a id="expr.context">[[expr.context]]</a>
 In some contexts, *unevaluated operands* appear
+[[expr.prim.req.simple]], [[expr.prim.req.compound]], [[expr.typeid]], [[expr.sizeof]], [[expr.unary.noexcept]], [[expr.reflect]], [[dcl.type.decltype]], [[temp.pre]], [[temp.concept]].
 An unevaluated operand is not evaluated.
 [*Note 1*: In an unevaluated operand, a non-static class member can be
 named [[expr.prim.id]] and naming of objects or functions does not, by
 itself, require that a definition be provided [[basic.def.odr]]. An
 [[conv.lval]] is applied if and only if the expression is a glvalue of
 volatile-qualified type and it is one of the following:
 - `(` *expression* `)`, where *expression* is one of these expressions,
 - *id-expression* [[expr.prim.id]],
+- *splice-expression* [[expr.prim.splice]],
 - subscripting [[expr.sub]],
 - class member access [[expr.ref]],
 - indirection [[expr.unary.op]],
 - pointer-to-member operation [[expr.mptr.oper]],
 - conditional expression [[expr.cond]] where both the second and the
 [*Note 1*: A standard conversion sequence can be empty, i.e., it can
 consist of no conversions. — *end note*]
 A standard conversion sequence will be applied to an expression if
+necessary to convert it to an expression having a required destination
+type and value category.
 [*Note 2*:
 Expressions with a given type will be implicitly converted to other
 types in several contexts:
   [[dcl.init.ref]].
 — *end note*]
 An expression E can be *implicitly converted* to a type `T` if and only
+if the declaration `T t = E;` is well-formed, for some invented
+temporary variable `t` [[dcl.init]].
 Certain language constructs require that an expression be converted to a
 Boolean value. An expression E appearing in such a context is said to be
 *contextually converted to `bool`* and is well-formed if and only if the
 declaration `bool t(E);` is well-formed, for some invented temporary
   `T` is volatile-qualified [[intro.execution]], and the glvalue can
   refer to an inactive member of a union [[class.union]]. — *end note*]
 - Otherwise, if `T` has a class type, the conversion copy-initializes
   the result object from the glvalue.
 - Otherwise, if the object to which the glvalue refers contains an
+  invalid pointer value [[basic.compound]], the behavior is
+  *implementation-defined*.
+- Otherwise, if the bits in the value representation of the object to
+  which the glvalue refers are not valid for the object’s type, the
+  behavior is undefined.
+  \[*Example 2*:
+  ``` cpp
+  bool f() {
+    bool b = true;
+    char c = 42;
+    memcpy(&b, &c, 1);
+    return b;         // undefined behavior if 42 is not a valid value representation for bool
+  }
+  ```
+  — *end example*]
 - Otherwise, the object indicated by the glvalue is read
+  [[defns.access]]. Let `V` be the value contained in the object. If `T`
+ is an integer type, the prvalue result is the value of type `T`
+  congruent [[basic.fundamental]] to `V`, and `V` otherwise.
 [*Note 2*: See also  [[basic.lval]]. — *end note*]
 ### Array-to-pointer conversion <a id="conv.array">[[conv.array]]</a>
 [*Example 1*: The type denoted by the *type-id* `const int **` has
 three qualification-decompositions, taking `U` as “`int`”, as “pointer
 to `const int`”, and as “pointer to pointer to
 `const int`”. — *end example*]
 Two types `T1` and `T2` are *similar* if they have
 qualification-decompositions with the same n such that corresponding Pᵢ
 components are either the same or one is “array of Nᵢ” and the other is
 “array of unknown bound of”, and the types denoted by `U` are the same.
 pointer-to-member-function types) are never cv-qualified
 [[dcl.fct]]. — *end note*]
 ### Integral promotions <a id="conv.prom">[[conv.prom]]</a>
+For the purposes of [[conv.prom]], a *converted bit-field* is a prvalue
+that is the result of an lvalue-to-rvalue conversion [[conv.lval]]
+applied to a bit-field [[class.bit]].
+A prvalue that is not a converted bit-field and has an integer type
+other than `bool`, `char8_t`, `char16_t`, `char32_t`, or `wchar_t` whose
+integer conversion rank [[conv.rank]] is less than the rank of `int` can
+be converted to a prvalue of type `int` if `int` can represent all the
+values of the source type; otherwise, the source prvalue can be
+converted to a prvalue of type `unsigned int`.
 A prvalue of an unscoped enumeration type whose underlying type is not
 fixed can be converted to a prvalue of the first of the following types
 that can represent all the values of the enumeration [[dcl.enum]]:
 `int`, `unsigned int`, `long int`, `unsigned long int`, `long long int`,
 [[dcl.enum]] can be converted to a prvalue of its underlying type.
 Moreover, if integral promotion can be applied to its underlying type, a
 prvalue of an unscoped enumeration type whose underlying type is fixed
 can also be converted to a prvalue of the promoted underlying type.
+[*Note 1*: A converted bit-field of enumeration type is treated as any
+other value of that type for promotion purposes. — *end note*]
+A converted bit-field of integral type can be converted to a prvalue of
+type `int` if `int` can represent all the values of the bit-field;
+otherwise, it can be converted to `unsigned int` if `unsigned int` can
+represent all the values of the bit-field.
+A prvalue of type `char8_t`, `char16_t`, `char32_t`, or `wchar_t`
+[[basic.fundamental]] (including a converted bit-field that was not
+already promoted to `int` or `unsigned int` according to the rules
+above) can be converted to a prvalue of the first of the following types
+that can represent all the values of its underlying type: `int`,
+`unsigned int`, `long int`, `unsigned long int`, `long long int`,
+`unsigned long long int`, or its underlying type.
 A prvalue of type `bool` can be converted to a prvalue of type `int`,
 with `false` becoming zero and `true` becoming one.
 These conversions are called *integral promotions*.
 A *null pointer constant* is an integer literal [[lex.icon]] with value
 zero or a prvalue of type `std::nullptr_t`. A null pointer constant can
 be converted to a pointer type; the result is the null pointer value of
 that type [[basic.compound]] and is distinguishable from every other
 value of object pointer or function pointer type. Such a conversion is
+called a *null pointer conversion*. The conversion of a null pointer
+constant to a pointer to cv-qualified type is a single conversion, and
+not the sequence of a pointer conversion followed by a qualification
+conversion [[conv.qual]]. A null pointer constant of integral type can
+be converted to a prvalue of type `std::nullptr_t`.
 [*Note 1*: The resulting prvalue is not a null pointer
 value. — *end note*]
 A prvalue of type “pointer to cv `T`”, where `T` is an object type, can
 be converted to a prvalue of type “pointer to cv `void`”. The pointer
 value [[basic.compound]] is unchanged by this conversion.
+A prvalue `v` of type “pointer to cv `D`”, where `D` is a complete class
 type, can be converted to a prvalue of type “pointer to cv `B`”, where
 `B` is a base class [[class.derived]] of `D`. If `B` is an inaccessible
 [[class.access]] or ambiguous [[class.member.lookup]] base class of `D`,
+a program that necessitates this conversion is ill-formed. If `v` is a
+null pointer value, the result is a null pointer value. Otherwise, if
+`B` is a virtual base class of `D` and `v` does not point to an object
+whose type is similar [[conv.qual]] to `D` and that is within its
+lifetime or within its period of construction or destruction
+[[class.cdtor]], the behavior is undefined. Otherwise, the result is a
+pointer to the base class subobject of the derived class object.
 ### Pointer-to-member conversions <a id="conv.mem">[[conv.mem]]</a>
 A null pointer constant [[conv.ptr]] can be converted to a
 pointer-to-member type; the result is the *null member pointer value* of
 that type and is distinguishable from any pointer to member not created
 from a null pointer constant. Such a conversion is called a *null member
+pointer conversion*. The conversion of a null pointer constant to a
 pointer to member of cv-qualified type is a single conversion, and not
 the sequence of a pointer-to-member conversion followed by a
 qualification conversion [[conv.qual]].
 A prvalue of type “pointer to member of `B` of type cv `T`”, where `B`
 is a class type, can be converted to a prvalue of type “pointer to
 member of `D` of type cv `T`”, where `D` is a complete class derived
 [[class.derived]] from `B`. If `B` is an inaccessible [[class.access]],
 ambiguous [[class.member.lookup]], or virtual [[class.mi]] base class of
 `D`, or a base class of a virtual base class of `D`, a program that
+necessitates this conversion is ill-formed. If class `D` does not
+contain the original member and is not a base class of the class
+containing the original member, the behavior is undefined. Otherwise,
+the result of the conversion refers to the same member as the pointer to
+member before the conversion took place, but it refers to the base class
+member as if it were a member of the derived class. The result refers to
+the member in `D`’s instance of `B`. Since the result has type “pointer
+to member of `D` of type cv `T`”, indirection through it with a `D`
+object is valid. The result is the same as if indirecting through the
+pointer to member of `B` with the `B` subobject of `D`. The null member
+pointer value is converted to the null member pointer value of the
+destination type.[^8]
 ### Function pointer conversions <a id="conv.fctptr">[[conv.fctptr]]</a>
 A prvalue of type “pointer to `noexcept` function” can be converted to a
 prvalue of type “pointer to function”. The result is a pointer to the
 type cause conversions and yield result types in a similar way. The
 purpose is to yield a common type, which is also the type of the result.
 This pattern is called the *usual arithmetic conversions*, which are
 defined as follows:
+- The lvalue-to-rvalue conversion [[conv.lval]] is applied to each
+  operand and the resulting prvalues are used in place of the original
+  operands for the remainder of this section.
 - If either operand is of scoped enumeration type [[dcl.enum]], no
   conversions are performed; if the other operand does not have the same
   type, the expression is ill-formed.
+- Otherwise, if one operand is of enumeration type and the other operand
+  is of a different enumeration type or a floating-point type, the
+  expression is ill-formed.
 - Otherwise, if either operand is of floating-point type, the following
   rules are applied:
   - If both operands have the same type, no further conversion is
+ performed.
   - Otherwise, if one of the operands is of a non-floating-point type,
     that operand is converted to the type of the operand with the
     floating-point type.
   - Otherwise, if the floating-point conversion ranks [[conv.rank]] of
     the types of the operands are ordered but not equal, then the
       `U`.
     - Otherwise, if `S` can represent all of the values of `U`, `C` is
       `S`.
     - Otherwise, `C` is the unsigned integer type corresponding to `S`.
 ## Primary expressions <a id="expr.prim">[[expr.prim]]</a>
+### Grammar <a id="expr.prim.grammar">[[expr.prim.grammar]]</a>
 ``` bnf
 primary-expression:
     literal
     this
     '(' expression ')'
     id-expression
     lambda-expression
     fold-expression
     requires-expression
+    splice-expression
 ```
 ### Literals <a id="expr.prim.literal">[[expr.prim.literal]]</a>
 The type of a *literal* is determined based on its form as specified in
 innermost class scope containing that point.
 [*Note 1*: A *lambda-expression* does not introduce a class
 scope. — *end note*]
+If the expression `this` appears within the predicate of a contract
+assertion [[basic.contract.general]] (including as the result of an
+implicit transformation [[expr.prim.id.general]] and including in the
+bodies of nested *lambda-expression*s) and the current class encloses
+the contract assertion, `const` is combined with the *cv-qualifier-seq*
+used to generate the resulting type (see below).
 If a declaration declares a member function or member function template
 of a class `X`, the expression `this` is a prvalue of type “pointer to
 *cv-qualifier-seq* `X`” wherever `X` is the current class between the
 optional *cv-qualifier-seq* and the end of the *function-definition*,
 *member-declarator*, or *declarator*. It shall not appear within the
+declaration of a static or explicit object member function of the
+current class (although its type and value category are defined within
+such member functions as they are within an implicit object member
+function).
 [*Note 2*: This is because declaration matching does not occur until
 the complete declarator is known. — *end note*]
 [*Note 3*:
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
+    pack-index-expression
 ```
 An *id-expression* is a restricted form of a *primary-expression*.
 [*Note 1*: An *id-expression* can appear after `.` and `->` operators
 [[expr.ref]]. — *end note*]
+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]] is `X`
+and
+- E is potentially evaluated or `C` is `X` or a base class of `X`, and
+- E is not the *id-expression* of a class member access expression
+  [[expr.ref]], and
+- E is not the *id-expression* of a *reflect-expression*
+  [[expr.reflect]], and
+- if E is a *qualified-id*, E is not the un-parenthesized operand of the
+  unary `&` operator [[expr.unary.op]],
+the *id-expression* is transformed into a class member access expression
+using `(*this)` as the object expression. If this transformation occurs
+in the predicate of a precondition assertion of a constructor of `X` or
+a postcondition assertion of a destructor of `X`, the expression is
+ill-formed.
+[*Note 2*: If `C` is not `X` or a base class of `X`, the class member
+access expression is ill-formed. Also, if the *id-expression* occurs
+within a static or explicit object member function, the class member
+access is ill-formed. — *end note*]
+This transformation does not apply in the template definition context
+[[temp.dep.type]].
+[*Example 1*:
+``` cpp
+struct C {
+  bool b;
+  C() pre(b)                // error
+      pre(&this->b)         // OK
+      pre(sizeof(b) > 0);   // OK, b is not potentially evaluated.
+};
+```
+— *end example*]
 If an *id-expression* E denotes a member M of an anonymous union
 [[class.union.anon]] U:
 - If U is a non-static data member, E refers to M as a member of the
+  lookup context of the terminal name of E (after any implicit
+ transformation to a class member access expression).
+  \[*Example 2*: `o.x` is interpreted as `o.u.x`, where u names the
   anonymous union member. — *end example*]
 - Otherwise, E is interpreted as a class member access [[expr.ref]] that
   designates the member subobject M of the anonymous union variable for
+  U. \[*Note 3*: Under this interpretation, E no longer denotes a
+  non-static data member. — *end note*] \[*Example 3*: `N::x` is
   interpreted as `N::u.x`, where u names the anonymous union
   variable. — *end example*]
+An *id-expression* or *splice-expression* that designates a non-static
+data member or implicit object member function of a class can only be
+used:
+- 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
 - to form a pointer to member [[expr.unary.op]], or
+- if that *id-expression* or *splice-expression* designates a non-static
+ data member and it appears in an unevaluated operand.
+  \[*Example 4*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
+  int S::*k = &[:^^S::m:];        // OK
   ```
   — *end example*]
 For an *id-expression* that denotes an overload set, overload resolution
 is performed to select a unique function [[over.match]], [[over.over]].
+[*Note 4*:
 A program cannot refer to a function with a trailing *requires-clause*
 whose *constraint-expression* is not satisfied, because such functions
 are never selected by overload resolution.
+[*Example 5*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
 };
   decltype(A<int>::f)* p2 = nullptr;    // error: the type decltype(A<int>::f) is invalid
 }
 ```
 In each case, the constraints of `f` are not satisfied. In the
+declaration of `p2`, those constraints need to be satisfied even though
+`f` is an unevaluated operand [[term.unevaluated.operand]].
 — *end example*]
 — *end note*]
     identifier
     operator-function-id
     conversion-function-id
     literal-operator-id
     '~' type-name
+    '~' computed-type-specifier
     template-id
 ```
 An *identifier* is only an *id-expression* if it has been suitably
+declared [[dcl]] or if it appears as part of a *declarator-id*
+[[dcl.decl]].
 [*Note 1*: For *operator-function-id*s, see  [[over.oper]]; for
 *conversion-function-id*s, see  [[class.conv.fct]]; for
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
+[[temp.names]]. A *type-name* or *computed-type-specifier* prefixed by
+`~` denotes the destructor of the type so named; see
+[[expr.prim.id.dtor]]. — *end note*]
 A *component name* of an *unqualified-id* U is
 - U if it is a name or
 - the component name of the *template-id* or *type-name* of U, if any.
 The *terminal name* of a construct is the component name of that
 construct that appears lexically last.
 The result is the entity denoted by the *unqualified-id*
+[[basic.lookup.unqual]].
+If
+- the *unqualified-id* appears in a *lambda-expression* at program point
+  P,
+- the entity is a local entity [[basic.pre]] or a variable declared by
+  an *init-capture* [[expr.prim.lambda.capture]],
+- naming the entity within the *compound-statement* of the innermost
+  enclosing *lambda-expression* of P, but not in an unevaluated operand,
+ would refer to an entity captured by copy in some intervening
+ *lambda-expression*, and
+- P is in the function parameter scope, but not the
+ *parameter-declaration-clause*, of the innermost such
+  *lambda-expression* E,
+then the type of the expression is the type of a class member access
+expression [[expr.ref]] naming the non-static data member that would be
+declared for such a capture in the object parameter [[dcl.fct]] of the
+function call operator of E.
+[*Note 3*: If E is not declared `mutable`, the type of such an
+identifier will typically be `const` qualified. — *end note*]
+Otherwise, if the *unqualified-id* names a coroutine parameter, the type
+of the expression is that of the copy of the parameter
+[[dcl.fct.def.coroutine]], and the result is that copy.
+Otherwise, if the *unqualified-id* names a result binding
+[[dcl.contract.res]] attached to a function with return type `U`,
+- if `U` is “reference to `T`”, then the type of the expression is
+  `const T`;
+- otherwise, the type of the expression is `const U`.
+Otherwise, if the *unqualified-id* appears in the predicate of a
+contract assertion C [[basic.contract]] and the entity is
+- a variable declared outside of C of object type `T`,
+- a variable or template parameter declared outside of C of type
+  “reference to `T`”, or
+- a structured binding of type `T` whose corresponding variable is
+  declared outside of C,
+then the type of the expression is `const` `T`.
+[*Example 1*:
+``` cpp
+int n = 0;
+struct X { bool m(); };
+struct Y {
+  int z = 0;
+  void f(int i, int* p, int& r, X x, X* px)
+    pre (++n)       // error: attempting to modify const lvalue
+    pre (++i)       // error: attempting to modify const lvalue
+    pre (++(*p))    // OK
+    pre (++r)       // error: attempting to modify const lvalue
+    pre (x.m())     // error: calling non-const member function
+    pre (px->m())   // OK
+    pre ([=,&i,*this] mutable {
+      ++n;          // error: attempting to modify const lvalue
+      ++i;          // error: attempting to modify const lvalue
+      ++p;          // OK, refers to member of closure type
+      ++r;          // OK, refers to non-reference member of closure type
+      ++this->z;    // OK, captured *this
+      ++z;          // OK, captured *this
+      int j = 17;
+      [&]{
+        int k = 34;
+        ++i;    // error: attempting to modify const lvalue
+        ++j;    // OK
+        ++k;    // OK
+      }();
+      return true;
+    }());
+  template <int N, int& R, int* P>
+  void g()
+    pre(++N)        // error: attempting to modify prvalue
+    pre(++R)        // error: attempting to modify const lvalue
+    pre(++(*P));    // OK
+  int h()
+    post(r : ++r)   // error: attempting to modify const lvalue
+    post(r: [=] mutable {
+       ++r;         // OK, refers to member of closure type
+       return true;
+     }());
+  int& k()
+    post(r : ++r);  // error: attempting to modify const lvalue
+};
+```
+— *end example*]
+Otherwise, if the entity is a template parameter object for a template
 parameter of type `T` [[temp.param]], the type of the expression is
+`const T`.
+In all other cases, the type of the expression is the type of the
+entity.
+[*Note 4*: The type will be adjusted as described in [[expr.type]] if
 it is cv-qualified or is a reference type. — *end note*]
 The expression is an xvalue if it is move-eligible (see below); an
 lvalue if the entity is a function, variable, structured binding
+[[dcl.struct.bind]], result binding [[dcl.contract.res]], data member,
+or template parameter object; and a prvalue otherwise [[basic.lval]]; it
+is a bit-field if the identifier designates a bit-field.
+If an *id-expression* E appears in the predicate of a function contract
+assertion attached to a function *f* and denotes a function parameter of
+*f* and the implementation introduces any temporary objects to hold the
+value of that parameter as specified in [[class.temporary]],
+- if the contract assertion is a precondition assertion and the
+  evaluation of the precondition assertion is sequenced before the
+  initialization of the parameter object, E refers to the most recently
+  initialized such temporary object, and
+- if the contract assertion is a postcondition assertion, it is
+  unspecified whether E refers to one of the temporary objects or the
+  parameter object; the choice is consistent within a single evaluation
+  of a postcondition assertion.
+If an *id-expression* E names a result binding in a postcondition
+assertion and the implementation introduces any temporary objects to
+hold the result object as specified in [[class.temporary]], and the
+postcondition assertion is sequenced before the initialization of the
+result object [[expr.call]], E refers to the most recently initialized
+such temporary object.
+[*Example 2*:
 ``` cpp
 void f() {
   float x, &r = x;
 }
 ```
 — *end example*]
+An *implicitly movable entity* is a variable with automatic storage
 duration that is either a non-volatile object or an rvalue reference to
+a non-volatile object type. An *id-expression* or *splice-expression*
+[[expr.prim.splice]] is *move-eligible* if
+- it designates an implicitly movable entity,
+- it is the (possibly parenthesized) operand of a `return`
+ [[stmt.return]] or `co_return` [[stmt.return.coroutine]] statement or
+ of a *throw-expression* [[expr.throw]], and
+- each intervening scope between the declaration of the entity and the
+  innermost enclosing scope of the expression is a block scope and, for
+ a *throw-expression*, is not the block scope of a *try-block* or
+ *function-try-block*.
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
 ``` bnf
 nested-name-specifier:
     '::'
     type-name '::'
     namespace-name '::'
+ computed-type-specifier '::'
+    splice-scope-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
+``` bnf
+splice-scope-specifier:
+    splice-specifier
+    templateₒₚₜ splice-specialization-specifier
+```
 The component names of a *qualified-id* are those of its
 *nested-name-specifier* and *unqualified-id*. The component names of a
 *nested-name-specifier* are its *identifier* (if any) and those of its
 *type-name*, *namespace-name*, *simple-template-id*, and/or
 *nested-name-specifier*.
+A *splice-specifier* or *splice-specialization-specifier* that is not
+followed by `::` is never interpreted as part of a
+*splice-scope-specifier*. The keyword `template` may only be omitted
+from the form `\opt{template} splice-specialization-specifier ::` when
+the *splice-specialization-specifier* is preceded by `typename`.
+[*Example 1*:
+``` cpp
+template<int V>
+struct TCls {
+  static constexpr int s = V;
+  using type = int;
+};
+int v1 = [:^^TCls<1>:]::s;
+int v2 = template [:^^TCls:]<2>::s;             // OK, template binds to splice-scope-specifier
+typename [:^^TCls:]<3>::type v3 = 3;            // OK, typename binds to the qualified name
+template [:^^TCls:]<3>::type v4 = 4;            // OK, template binds to the splice-scope-specifier
+typename template [:^^TCls:]<3>::type v5 = 5;   // OK, same as v3
+[:^^TCls:]<3>::type v6 = 6;                     // error: unexpected <
+```
+— *end example*]
 A *nested-name-specifier* is *declarative* if it is part of
 - a *class-head-name*,
 - an *enum-head-name*,
 - 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-scope-specifier*. 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.
+The entity designated by a *nested-name-specifier* is determined as
+follows:
+- The *nested-name-specifier* `::` designates the global namespace.
+- A *nested-name-specifier* with a *computed-type-specifier* designates
+  the same type designated by the *computed-type-specifier*, which shall
+  be a class or enumeration type.
+- For a *nested-name-specifier* of the form `splice-specifier ::`, the
+  *splice-specifier* shall designate a class or enumeration type or a
+  namespace. The *nested-name-specifier* designates the same entity as
+  the *splice-specifier*.
+- For a *nested-name-specifier* of the form
+  `\opt{template} splice-specialization-specifier ::`, the
+  *splice-specifier* of the *splice-specialization-specifier* shall
+  designate a class template or an alias template T. Letting S be the
+  specialization of T corresponding to the template argument list 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 the
+  underlying entity of S.
+- 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 by N without A. T
   shall be a class template.
   - If A is the template argument list [[temp.arg]] of the corresponding
+ *template-head* H [[temp.mem]], N designates the primary template of
+    T; H shall be equivalent to the *template-head* of T
+    [[temp.over.link]].
+ - Otherwise, N designates the partial specialization
+ [[temp.spec.partial]] of T whose template argument list is
+    equivalent to A [[temp.over.link]]; the program is ill-formed if no
+    such partial specialization exists.
+- Any other *nested-name-specifier* designates the entity denotes 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.
 A *qualified-id* shall not be of the form *nested-name-specifier*
+`template`ₒₚₜ  `~` *computed-type-specifier* nor of the form
+*computed-type-specifier* `::` `~` *type-name*.
 The result of a *qualified-id* Q is the entity it denotes
+[[basic.lookup.qual]].
+If Q appears in the predicate of a contract assertion C
+[[basic.contract]] and the entity is
+- a variable declared outside of C of object type `T`,
+- a variable declared outside of C of type “reference to `T`”, or
+- a structured binding of type `T` whose corresponding variable is
+  declared outside of C,
+then the type of the expression is `const` `T`.
+Otherwise, the type of the expression is the type of the result.
+The result is an lvalue if the member is
 - a function other than a non-static member function,
 - a non-static member function if Q is the operand of a unary `&`
   operator,
 - a variable,
 - a structured binding [[dcl.struct.bind]], or
 - a data member,
 and a prvalue otherwise.
+#### Pack indexing expression <a id="expr.prim.pack.index">[[expr.prim.pack.index]]</a>
+``` bnf
+pack-index-expression:
+    id-expression '...' '[' constant-expression ']'
+```
+The *id-expression* P in a *pack-index-expression* shall be an
+*identifier* that denotes a pack.
+The *constant-expression* shall be a converted constant expression
+[[expr.const]] of type `std::size_t` whose value V, termed the index, is
+such that 0 ≤ V < `sizeof...($P$)`.
+A *pack-index-expression* is a pack expansion [[temp.variadic]].
+[*Note 1*: A *pack-index-expression* denotes the Vᵗʰ element of the
+pack. — *end note*]
 #### Destruction <a id="expr.prim.id.dtor">[[expr.prim.id.dtor]]</a>
 An *id-expression* that denotes the destructor of a type `T` names the
 destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 *id-expression* is said to name a *pseudo-destructor*.
 ```
 ``` bnf
 lambda-declarator:
     lambda-specifier-seq noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
+       function-contract-specifier-seqₒₚₜ
+ noexcept-specifier attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ function-contract-specifier-seqₒₚₜ
+    trailing-return-typeₒₚₜ function-contract-specifier-seqₒₚₜ
     '(' parameter-declaration-clause ')' lambda-specifier-seqₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
+       trailing-return-typeₒₚₜ requires-clauseₒₚₜ function-contract-specifier-seqₒₚₜ
 ```
 ``` bnf
 lambda-specifier:
     consteval
     static
 ```
 ``` bnf
 lambda-specifier-seq:
+    lambda-specifier lambda-specifier-seqₒₚₜ
 ```
 A *lambda-expression* provides a concise way to create a simple function
 object.
 *attribute-specifier-seq*, which collides with the
 *attribute-specifier-seq* in *lambda-expression*. In such cases, any
 attributes are treated as *attribute-specifier-seq* in
 *lambda-expression*.
+[*Note 2*:
+Such ambiguous cases cannot have valid semantics because the constraint
+expression would not have type `bool`.
+[*Example 2*:
+``` cpp
+auto x = []<class T> requires T::operator int [[some_attribute]] (int) { }
+```
+— *end example*]
+— *end note*]
 A *lambda-specifier-seq* shall contain at most one of each
 *lambda-specifier* and shall not contain both `constexpr` and
 `consteval`. If the *lambda-declarator* contains an explicit object
 parameter [[dcl.fct]], then no *lambda-specifier* in the
 *lambda-capture*.
 [*Note 3*: The trailing *requires-clause* is described in
 [[dcl.decl]]. — *end note*]
+A *lambda-expression*'s *parameter-declaration-clause* is the
+*parameter-declaration-clause* of the *lambda-expression*'s
+*lambda-declarator*, if any, or empty otherwise. If the
+*lambda-declarator* does not include a *trailing-return-type*, it is
+considered to be `-> auto`.
 [*Note 4*: In that case, the return type is deduced from `return`
 statements as described in [[dcl.spec.auto]]. — *end note*]
+[*Example 3*:
 ``` cpp
 auto x1 = [](int i) { return i; };      // OK, return type is int
 auto x2 = []{ return { 1, 2 }; };       // error: deducing return type from braced-init-list
 int j;
 A lambda is a *generic lambda* if the *lambda-expression* has any
 generic parameter type placeholders [[dcl.spec.auto]], or if the lambda
 has a *template-parameter-list*.
+[*Example 4*:
 ``` cpp
+auto x = [](int i, auto a) { return i; }; // OK, a generic lambda
+auto y = [](this auto self, int i) { return i; }; // OK, a generic lambda
+auto z = []<class T>(int i) { return i; };              // OK, a generic lambda
 ```
 — *end example*]
 #### Closure types <a id="expr.prim.lambda.closure">[[expr.prim.lambda.closure]]</a>
 The type of a *lambda-expression* (which is also the type of the closure
 object) is a unique, unnamed non-union class type, called the *closure
 type*, whose properties are described below.
+The closure type is incomplete until the end of its corresponding
+*compound-statement*.
 The closure type is declared in the smallest block scope, class scope,
 or namespace scope that contains the corresponding *lambda-expression*.
 [*Note 1*: This determines the set of namespaces and classes associated
 with the closure type [[basic.lookup.argdep]]. The parameter types of a
 *lambda-declarator* do not affect these associated namespaces and
 classes. — *end note*]
+The closure type is not an aggregate type [[dcl.init.aggr]]; it is a
+structural type [[term.structural.type]] if and only if the lambda has
+no *lambda-capture*. An implementation may define the closure type
+differently from what is described below provided this does not alter
+the observable behavior of the program other than by changing:
 - the size and/or alignment of the closure type,
+- whether the closure type is trivially copyable [[class.prop]],
+- whether the closure type is trivially relocatable [[class.prop]],
+- whether the closure type is replaceable [[class.prop]], or
 - whether the closure type is a standard-layout class [[class.prop]].
 An implementation shall not add members of rvalue reference type to the
 closure type.
 The closure type for a *lambda-expression* has a public inline function
 call operator (for a non-generic lambda) or function call operator
 template (for a generic lambda) [[over.call]] whose parameters and
+return type are those of the *lambda-expression*'s
 *parameter-declaration-clause* and *trailing-return-type* respectively,
 and whose *template-parameter-list* consists of the specified
+*template-parameter-list*, if any. The function call operator or the
+function call operator template are direct members of the closure type.
+The *requires-clause* of the function call operator template is the
+*requires-clause* immediately following
 `<` *template-parameter-list* `>`, if any. The trailing
 *requires-clause* of the function call operator or operator template is
 the *requires-clause* of the *lambda-declarator*, if any.
 [*Note 2*: The function call operator template for a generic lambda can
 Given a lambda with a *lambda-capture*, the type of the explicit object
 parameter, if any, of the lambda’s function call operator (possibly
 instantiated from a function call operator template) shall be either:
 - the closure type,
+- a class type publicly and unambiguously derived from the closure type,
+  or
 - a reference to a possibly cv-qualified such type.
 [*Example 2*:
 ``` cpp
 `static`. Otherwise, it is a non-static member function or member
 function template [[class.mfct.non.static]] that is declared `const`
 [[class.mfct.non.static]] if and only if the *lambda-expression*’s
 *parameter-declaration-clause* is not followed by `mutable` and the
 *lambda-declarator* does not contain an explicit object parameter. It is
+neither virtual nor declared `volatile`. Any *noexcept-specifier* or
+*function-contract-specifier* [[dcl.contract.func]] specified on a
+*lambda-expression* applies to the corresponding function call operator
+or operator template. An *attribute-specifier-seq* in a
 *lambda-declarator* appertains to the type of the corresponding function
 call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-expression* preceding a *lambda-declarator* appertains to the
 corresponding function call operator or operator template. The function
 call operator or any given operator template specialization is a
 — *end example*]
 — *end note*]
+If all potential references to a local entity implicitly captured by a
+*lambda-expression* L occur within the function contract assertions
+[[dcl.contract.func]] of the call operator or operator template of L or
+within *assertion-statement*s [[stmt.contract.assert]] within the body
+of L, the program is ill-formed.
+[*Note 4*: Adding a contract assertion to an existing C++ program
+cannot cause additional captures. — *end note*]
+[*Example 6*:
+``` cpp
+static int i = 0;
+void test() {
+  auto f1 = [=] pre(i > 0) {};  // OK, no local entities are captured.
+  int i = 1;
+  auto f2 = [=] pre(i > 0) {};  // error: cannot implicitly capture i here
+  auto f3 = [i] pre(i > 0) {};  // OK, i is captured explicitly.
+  auto f4 = [=] {
+    contract_assert(i > 0);     // error: cannot implicitly capture i here
+  };
+  auto f5 = [=] {
+    contract_assert(i > 0);     // OK, i is referenced elsewhere.
+    (void)i;
+  };
+  auto f6 = [=] pre(                // #1
+    []{
+      bool x = true;
+      return [=]{ return x; }();    // OK, #1 captures nothing.
+    }()) {};
+  bool y = true;
+  auto f7 = [=] pre([=]{ return y; }());    // error: outer capture of y is invalid.
+}
+```
+— *end example*]
 The closure type for a non-generic *lambda-expression* with no
+*lambda-capture* and no explicit object parameter [[dcl.fct]] whose
+constraints (if any) are satisfied has a conversion function to pointer
+to function with C++ language linkage [[dcl.link]] having the same
+parameter and return types as the closure type’s function call operator.
+The conversion is to “pointer to `noexcept` function” if the function
+call operator has a non-throwing exception specification. If the
+function call operator is a static member function, then the value
+returned by this conversion function is a pointer to the function call
+operator. Otherwise, the value returned by this conversion function is a
+pointer to a function `F` that, when invoked, has the same effect as
+invoking the closure type’s function call operator on a
+default-constructed instance of the closure type. `F` is a constexpr
+function if the function call operator is a constexpr function and is an
+immediate function if the function call operator is an immediate
+function.
+For a generic lambda with no *lambda-capture* and no explicit object
+parameter [[dcl.fct]], the closure type has a conversion function
+template to pointer to function. The conversion function template has
+the same invented template parameter list, and the pointer to function
+has the same parameter types, as the function call operator template.
+The return type of the pointer to function shall behave as if it were a
+*decltype-specifier* denoting the return type of the corresponding
+function call operator template specialization.
+[*Note 5*:
 If the generic lambda has no *trailing-return-type* or the
 *trailing-return-type* contains a placeholder type, return type
 deduction of the corresponding function call operator template
 specialization has to be done. The corresponding specialization is that
 };
 ```
 — *end note*]
+[*Example 7*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 — *end example*]
 If the function call operator template is a static member function
 template, then the value returned by any given specialization of this
+conversion function template is a pointer to the corresponding function
+call operator template specialization. Otherwise, the value returned by
+any given specialization of this conversion function template is a
+pointer to a function `F` that, when invoked, has the same effect as
+invoking the generic lambda’s corresponding function call operator
+template specialization on a default-constructed instance of the closure
+type. `F` is a constexpr function if the corresponding specialization is
+a constexpr function and `F` is an immediate function if the function
+call operator template specialization is an immediate function.
+[*Note 6*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
+parameter types need to match the return type and parameter types of the
+pointer to function. — *end note*]
+[*Example 8*:
 ``` cpp
 auto GL = [](auto a) { std::cout << a; return a; };
 int (*GL_int)(int) = GL;        // OK, through conversion function template
 GL_int(3);                      // OK, same as GL(3)
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing
 exception specification [[except.spec]].
+[*Example 9*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
 The *lambda-expression*’s *compound-statement* yields the
 *function-body* [[dcl.fct.def]] of the function call operator, but it is
 not within the scope of the closure type.
+[*Example 10*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
 };
 ```
 — *end example*]
+Unless the *compound-statement* is that of a
+*consteval-block-declaration* [[dcl.pre]], a variable `__func__` is
+implicitly defined at the beginning of the *compound-statement* of the
+*lambda-expression*, with semantics as described in
+[[dcl.fct.def.general]].
 The closure type associated with a *lambda-expression* has no default
 constructor if the *lambda-expression* has a *lambda-capture* and a
 defaulted default constructor otherwise. It has a defaulted copy
 constructor and a defaulted move constructor [[class.copy.ctor]]. It has
 a deleted copy assignment operator if the *lambda-expression* has a
 *lambda-capture* and defaulted copy and move assignment operators
 otherwise [[class.copy.assign]].
+[*Note 7*: These special member functions are implicitly defined as
 usual, which can result in them being defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].
 ``` bnf
 simple-capture:
     identifier '...'ₒₚₜ
     '&' identifier '...'ₒₚₜ
     this
+    '*' this
 ```
 ``` bnf
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
 The body of a *lambda-expression* may refer to local entities of
+enclosing scopes by capturing those entities, as described below.
 If a *lambda-capture* includes a *capture-default* that is `&`, no
 identifier in a *simple-capture* of that *lambda-capture* shall be
 preceded by `&`. If a *lambda-capture* includes a *capture-default* that
 is `=`, each *simple-capture* of that *lambda-capture* shall be of the
 form “`&` *identifier* `...`ₒₚₜ ”, “`this`”, or “`* this`”.
 [*Note 1*: The form `[&,this]` is redundant but accepted for
+compatibility with C++14. — *end note*]
 Ignoring appearances in *initializer*s of *init-capture*s, an identifier
 or `this` shall not appear more than once in a *lambda-capture*.
 [*Example 1*:
 ```
 — *end example*]
 A *lambda-expression* shall not have a *capture-default* or
+*simple-capture* in its *lambda-introducer* unless
+- its innermost enclosing scope is a block scope [[basic.scope.block]],
+- it appears within a default member initializer and its innermost
+  enclosing scope is the corresponding class scope
+  [[basic.scope.class]], or
+- it appears within a contract assertion and its innermost enclosing
+  scope is the corresponding contract-assertion scope
+  [[basic.scope.contract]].
 The *identifier* in a *simple-capture* shall denote a local entity
 [[basic.lookup.unqual]], [[basic.pre]]. The *simple-capture*s `this` and
 `* this` denote the local entity `*this`. An entity that is designated
 by a *simple-capture* is said to be *explicitly captured*.
 An entity is *captured by copy* if
 - it is implicitly captured, the *capture-default* is `=`, and the
   captured entity is not `*this`, or
 - it is explicitly captured with a capture that is not of the form
+  `this`, `&` *identifier* `...`ₒₚₜ , or `&` `...`ₒₚₜ  *identifier*
+  *initializer*.
 For each entity captured by copy, an unnamed non-static data member is
 declared in the closure type. The declaration order of these members is
 unspecified. The type of such a data member is the referenced type if
 the entity is a reference to an object, an lvalue reference to the
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
+    int arr[N];     // OK, not an odr-use, refers to variable with automatic storage duration
     f(&N);          // OK, causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```
 }
 ```
 — *end example*]
+A fold expression is a pack expansion.
 ### Requires expressions <a id="expr.prim.req">[[expr.prim.req]]</a>
 #### General <a id="expr.prim.req.general">[[expr.prim.req.general]]</a>
 A *requires-expression* provides a concise way to express requirements
     '{' requirement-seq '}'
 ```
 ``` bnf
 requirement-seq:
+    requirement requirement-seqₒₚₜ
 ```
 ``` bnf
 requirement:
     simple-requirement
     compound-requirement
     nested-requirement
 ```
 A *requires-expression* is a prvalue of type `bool` whose value is
+described below.
 [*Example 1*:
 A common use of *requires-expression*s is to define requirements in
 concepts such as the one below:
 introduces the *requires-expression*.
 — *end example*]
 A *requires-expression* may introduce local parameters using a
+*parameter-declaration-clause*. A local parameter of a
+*requires-expression* shall not have a default argument. The type of
+such a parameter is determined as specified for a function parameter in
+[[dcl.fct]]. These parameters have no linkage, storage, or lifetime;
+they are only used as notation for the purpose of defining
+*requirement*s. The *parameter-declaration-clause* of a
+*requirement-parameter-list* shall not terminate with an ellipsis.
 [*Example 2*:
 ``` cpp
 template<typename T>
 concept C = requires(T t, ...) {    // error: terminates with an ellipsis
   t;
 };
+template<typename T>
+concept C2 = requires(T p[2]) {
+  (decltype(p))nullptr;             // OK, p has type ``pointer to T''
+};
 ```
 — *end example*]
+The substitution of template arguments into a *requires-expression* can
+result in the formation of invalid types or expressions in the immediate
+context of its *requirement*s [[temp.deduct.general]] or the violation
+of the semantic constraints of those *requirement*s. In such cases, the
+*requires-expression* evaluates to `false`; it does not cause the
+program to be ill-formed. The substitution and semantic constraint
+checking proceeds in lexical order and stops when a condition that
+determines the result of the *requires-expression* is encountered. If
+substitution (if any) and semantic constraint checking succeed, the
+*requires-expression* evaluates to `true`.
 [*Note 1*: If a *requires-expression* contains invalid types or
 expressions in its *requirement*s, and it does not appear within the
 declaration of a templated entity, then the program is
 ill-formed. — *end note*]
 [*Example 3*:
 ``` cpp
 template<typename T> concept C =
 requires {
+  new decltype((void)T{}); // ill-formed, no diagnostic required
 };
 ```
 — *end example*]
 ``` bnf
 simple-requirement:
     expression ';'
 ```
+A *simple-requirement* asserts the validity of an *expression*. The
+*expression* is an unevaluated operand.
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
+if substitution of template arguments into the *expression*
+fails. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename T> concept C =
 #### Type requirements <a id="expr.prim.req.type">[[expr.prim.req.type]]</a>
 ``` bnf
 type-requirement:
     typename nested-name-specifierₒₚₜ type-name ';'
+    typename splice-specifier
+    typename splice-specialization-specifier
 ```
+A *type-requirement* asserts the validity of a type. The component names
+of a *type-requirement* are those of its *nested-name-specifier* (if
+any) and *type-name* (if any).
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
 if substitution of template arguments fails. — *end note*]
 [*Example 1*:
 template<typename T, typename T::type = 0> struct S;
 template<typename T> using Ref = T&;
 template<typename T> concept C = requires {
   typename T::inner;        // required nested member name
+  typename S<T>; // required valid[temp.names] template-id; fails if T::type does not exist as a type
+ // to which 0 can be implicitly converted
   typename Ref<T>;          // required alias template substitution, fails if T is void
+  typename [:T::r1:];       // fails if T::r1 is not a reflection of a type
+  typename [:T::r2:]<int>;  // fails if T::r2 is not a reflection of a template Z for which Z<int> is a type
 };
 ```
 — *end example*]
 ``` bnf
 return-type-requirement:
     '->' type-constraint
 ```
+A *compound-requirement* asserts properties of the *expression* E. The
+*expression* is an unevaluated operand. Substitution of template
+arguments (if any) and verification of semantic properties proceed in
+the following order:
 - Substitution of template arguments (if any) into the *expression* is
   performed.
 - If the `noexcept` specifier is present, E shall not be a
   potentially-throwing expression [[except.spec]].
 `D<T>` is satisfied if `sizeof(decltype (+t)) == 1`
 [[temp.constr.atomic]].
 — *end example*]
+### Expression splicing <a id="expr.prim.splice">[[expr.prim.splice]]</a>
+``` bnf
+splice-expression:
+    splice-specifier
+    template splice-specifier
+    template splice-specialization-specifier
+```
+A *splice-specifier* or *splice-specialization-specifier* immediately
+followed by `::` or preceded by `typename` is never interpreted as part
+of a *splice-expression*.
+[*Example 1*:
+``` cpp
+struct S { static constexpr int a = 1; };
+template<typename> struct TCls { static constexpr int b = 2; };
+constexpr int c = [:^^S:]::a;                   // OK, [:^^ S:] is not an expression
+constexpr int d = template [:^^TCls:]<int>::b;  // OK, template [:^^ TCls:]<int> is not an expression
+template<auto V> constexpr int e = [:V:];       // OK
+constexpr int f = template [:^^e:]<^^S::a>;     // OK
+constexpr auto g = typename [:^^int:](42);      // OK, typename [:^^ int:] is a splice-type-specifier
+constexpr auto h = ^^g;
+constexpr auto i = e<[:^^h:]>;          // error: unparenthesized splice-expression used as template argument
+constexpr auto j = e<([:^^h:])>;        // OK
+```
+— *end example*]
+For a *splice-expression* of the form *splice-specifier*, let S be the
+construct designated by *splice-specifier*.
+- The expression is ill-formed if S is
+  - a constructor,
+  - a destructor,
+  - an unnamed bit-field, or
+  - a local entity [[basic.pre]] such that
+    - there is a lambda scope that intervenes between the expression and
+      the point at which S was introduced and
+    - the expression would be potentially evaluated if the effect of any
+      enclosing `typeid` expressions [[expr.typeid]] were ignored.
+- Otherwise, if S is a function F, the expression denotes an overload
+  set containing all declarations of F that precede either the
+  expression or the point immediately following the *class-specifier* of
+  the outermost class for which the expression is in a complete-class
+  context; overload resolution is performed
+  [[over.match]], [[over.over]].
+- Otherwise, if S is an object or a non-static data member, the
+  expression is an lvalue designating S. The expression has the same
+  type as that of S, and is a bit-field if and only if S is a bit-field.
+  \[*Note 1*: The implicit transformation whereby an *id-expression*
+  denoting a non-static member becomes a class member access
+  [[expr.prim.id]] does not apply to a
+  *splice-expression*. — *end note*]
+- 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 that of S, and is a bit-field if and only if X is a bit-field.
+  \[*Note 2*: 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]]. — *end note*]
+- Otherwise, if S is a value or an enumerator, the expression is a
+  prvalue that computes S and whose type is the same as that of S.
+- Otherwise, the expression is ill-formed.
+For a *splice-expression* of the form `template splice-specifier`, the
+*splice-specifier* shall designate a function template T that is not a
+constructor template. The expression denotes an overload set containing
+all declarations of T that precede either the expression or the point
+immediately following the *class-specifier* of the outermost class for
+which the expression is in a complete-class context; overload resolution
+is performed.
+[*Note 3*: During overload resolution, candidate function templates
+undergo template argument deduction and the resulting specializations
+are considered as candidate functions. — *end note*]
+For a *splice-expression* of the form
+`template splice-specialization-specifier`, the *splice-specifier* of
+the *splice-specialization-specifier* shall designate a template T.
+- If T is a function template, the expression denotes an overload set
+  containing all declarations of T that precede either the expression or
+  the point immediately following the *class-specifier* of the outermost
+  class for which the expression is in a complete-class context;
+  overload resolution is performed [[over.match]], [[over.over]].
+- Otherwise, if T is a variable template, let S be the specialization of
+  T corresponding to the template argument list of the
+  *splice-specialization-specifier*. The expression is an lvalue
+  referring to the object associated with S and has the same type as
+  that of S.
+- Otherwise, the expression is ill-formed.
+[*Note 4*: Class members are accessible from any point when designated
+by *splice-expression*s [[class.access.base]]. A class member access
+expression [[expr.ref]] whose right operand is a *splice-expression* is
+ill-formed if the left operand (considered as a pointer) cannot be
+implicitly converted to a pointer to the designating class of the right
+operand. — *end note*]
 ## Compound expressions <a id="expr.compound">[[expr.compound]]</a>
 ### Postfix expressions <a id="expr.post">[[expr.post]]</a>
 #### General <a id="expr.post.general">[[expr.post.general]]</a>
     postfix-expression '(' expression-listₒₚₜ ')'
     simple-type-specifier '(' expression-listₒₚₜ ')'
     typename-specifier '(' expression-listₒₚₜ ')'
     simple-type-specifier braced-init-list
     typename-specifier braced-init-list
+    postfix-expression '.' templateₒₚₜ id-expression
+    postfix-expression '.' splice-expression
+    postfix-expression '->' templateₒₚₜ id-expression
+    postfix-expression '->' splice-expression
     postfix-expression '++'
     postfix-expression '--'
     dynamic_cast '<' type-id '>' '(' expression ')'
     static_cast '<' type-id '>' '(' expression ')'
     reinterpret_cast '<' type-id '>' '(' expression ')'
 A *subscript expression* is a postfix expression followed by square
 brackets containing a possibly empty, comma-separated list of
 *initializer-clause*s that constitute the arguments to the subscript
 operator. The *postfix-expression* and the initialization of the object
+parameter [[dcl.fct]] of any applicable subscript operator function
+[[over.sub]] is sequenced before each expression in the
+*expression-list* and also before any default argument
+[[dcl.fct.default]]. The initialization of a non-object parameter of a
+subscript operator function `S`, including every associated value
+computation and side effect, is indeterminately sequenced with respect
+to that of any other non-object parameter of `S`.
 With the built-in subscript operator, an *expression-list* shall be
 present, consisting of a single *assignment-expression*. One of the
 expressions shall be a glvalue of type “array of `T`” or a prvalue of
 type “pointer to `T`” and the other shall be a prvalue of unscoped
 enumeration or integral type. The result is of type “`T`”. The type
+“`T`” shall be a completely-defined object type.[^10]
 The expression `E1[E2]` is identical (by definition) to `*((E1)+(E2))`,
 except that in the case of an array operand, the result is an lvalue if
 that operand is an lvalue and an xvalue otherwise.
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
+[*Note 1*: If the postfix expression is a function name, the
+appropriate function and the validity of the call are determined
+according to the rules in  [[over.match]]. — *end note*]
 The postfix expression shall have function type or function pointer
 type. For a call to a non-member function or to a static member
+function, the postfix expression shall be either an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
+[[conv.func]] is suppressed on the postfix expression), or a prvalue of
+function pointer type.
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
 [*Note 2*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
+[*Note 3*: If a function name is used, and name lookup [[basic.lookup]]
+does not find a declaration of that name, the program is ill-formed. No
+function is implicitly declared by such a call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
 denoted by the object expression of the class member access
 [[expr.ref]], [[basic.life]].
+A type `T`_call is *call-compatible* with a function type `T`_func if
+`T`_call is the same type as `T`_func or if the type “pointer to
+`T`_func” can be converted to type “pointer to `T`_call” via a function
+pointer conversion [[conv.fctptr]]. Calling a function through an
+expression whose function type is not call-compatible with the type of
+the called function’s definition results in undefined behavior.
+[*Note 4*: This requirement allows the case when the expression has the
+type of a potentially-throwing function, but the called function has a
 non-throwing exception specification, and the function types are
 otherwise the same. — *end note*]
 When a function is called, each parameter [[dcl.fct]] is initialized
+[[dcl.init]], [[class.copy.ctor]] with its corresponding argument, and
+each precondition assertion of the function is evaluated
+[[dcl.contract.func]]. If the function is an explicit object member
+function and there is an implied object argument [[over.call.func]], the
+list of provided arguments is preceded by the implied object argument
+for the purposes of this correspondence. If there is no corresponding
+argument, the default argument for the parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
+If the function is an implicit object member function, the object
+expression of the class member access shall be a glvalue and the
+implicit object parameter of the function [[over.match.funcs]] is
+initialized with that glvalue, converted as if by an explicit type
 conversion [[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
 [*Note 6*: This still allows a parameter to be a pointer or reference
 to such a type. However, it prevents a passed-by-value parameter to have
 an incomplete or abstract class type. — *end note*]
+It is *implementation-defined* whether a parameter is destroyed when the
+function in which it is defined exits
+[[stmt.return]], [[except.ctor]], [[expr.await]] or at the end of the
+enclosing full-expression; parameters are always destroyed in the
+reverse order of their construction. The initialization and destruction
+of each parameter occurs within the context of the full-expression
+[[intro.execution]] where the function call appears.
+[*Example 2*: The access [[class.access.general]] of the constructor,
+conversion functions, or destructor is checked at the point of call. If
+a constructor or destructor for a function parameter throws an
+exception, any *function-try-block* [[except.pre]] of the called
+function with a handler that can handle the exception is not
 considered. — *end example*]
 The *postfix-expression* is sequenced before each *expression* in the
 *expression-list* and any default argument. The initialization of a
+parameter or, if the implementation introduces any temporary objects to
+hold the values of function parameters [[class.temporary]], the
+initialization of those temporaries, including every associated value
+computation and side effect, is indeterminately sequenced with respect
+to that of any other parameter. These evaluations are sequenced before
+the evaluation of the precondition assertions of the function, which are
+evaluated in sequence [[dcl.contract.func]]. For any temporaries
+introduced to hold the values of function parameters, the initialization
+of the parameter objects from those temporaries is indeterminately
+sequenced with respect to the evaluation of each precondition assertion.
 [*Note 7*: All side effects of argument evaluations are sequenced
 before the function is entered (see
 [[intro.execution]]). — *end note*]
 function call if the return type of the final overrider is different
 from the return type of the statically chosen function, the value
 returned from the final overrider is converted to the return type of the
 statically chosen function.
+When the called function exits normally [[stmt.return]], [[expr.await]],
+all postcondition assertions of the function are evaluated in sequence
+[[dcl.contract.func]]. If the implementation introduces any temporary
+objects to hold the result value as specified in [[class.temporary]],
+the evaluation of each postcondition assertion is indeterminately
+sequenced with respect to the initialization of any of those temporaries
+or the result object. These evaluations, in turn, are sequenced before
+the destruction of any function parameters.
 [*Note 9*:  A function can change the values of its non-const
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
+reference is to a const-qualified type, `const_cast` needs to be used to
+cast away the constness in order to modify the argument’s value. Where a
+parameter is of `const` reference type a temporary object is introduced
+if needed
 [[dcl.type]], [[lex.literal]], [[lex.string]], [[dcl.array]], [[class.temporary]].
 In addition, it is possible to modify the values of non-constant objects
 through pointer parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
 function-to-pointer [[conv.func]] standard conversions are performed on
 the argument expression. An argument that has type cv `std::nullptr_t`
 is converted to type `void*` [[conv.ptr]]. After these conversions, if
 the argument does not have arithmetic, enumeration, pointer,
 pointer-to-member, or class type, the program is ill-formed. Passing a
+potentially-evaluated argument of a scoped enumeration type [[dcl.enum]]
+or of a class type [[class]] having an eligible non-trivial copy
+constructor [[special]], [[class.copy.ctor]], an eligible non-trivial
+move constructor, or a non-trivial destructor [[class.dtor]], with no
+corresponding parameter, is conditionally-supported with
+*implementation-defined* semantics. If the argument has integral or
 enumeration type that is subject to the integral promotions
 [[conv.prom]], or a floating-point type that is subject to the
 floating-point promotion [[conv.fpprom]], the value of the argument is
 converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
 Recursive calls are permitted, except to the `main` function
 [[basic.start.main]].
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
+type is an rvalue reference to object type, and a prvalue otherwise. If
+it is a non-void prvalue, the type of the function call expression shall
+be complete, except as specified in [[dcl.type.decltype]].
 #### Explicit type conversion (functional notation) <a id="expr.type.conv">[[expr.type.conv]]</a>
 A *simple-type-specifier* [[dcl.type.simple]] or *typename-specifier*
 [[temp.res]] followed by a parenthesized optional *expression-list* or
 deduced class type, it is replaced by the return type of the function
 selected by overload resolution for class template deduction
 [[over.match.class.deduct]] for the remainder of this subclause.
 Otherwise, if the type contains a placeholder type, it is replaced by
 the type determined by placeholder type deduction
+[[dcl.type.auto.deduct]]. Let `T` denote the resulting type. Then:
+- If the initializer is a parenthesized single expression, the type
+  conversion expression is equivalent to the corresponding cast
+  expression [[expr.cast]].
+- Otherwise, if `T` is cv `void`, the initializer shall be `()` or `{}`
+  (after pack expansion, if any), and the expression is a prvalue of
+  type `void` that performs no initialization.
+- Otherwise, if `T` is a reference type, the expression has the same
+  effect as direct-initializing an invented variable `t` of type `T`
+  from the initializer and then using `t` as the result of the
+  expression; the result is an lvalue if `T` is an lvalue reference type
+  or an rvalue reference to function type and an xvalue otherwise.
+- Otherwise, the expression is a prvalue of type `T` whose result object
+  is direct-initialized [[dcl.init]] with the initializer.
+If the initializer is a parenthesized optional *expression-list*, `T`
+shall not be an array type.
 [*Example 1*:
 ``` cpp
 struct A {};
 }
 ```
 — *end example*]
 #### Class member access <a id="expr.ref">[[expr.ref]]</a>
 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*, is a postfix expression.
+[*Note 1*: If the keyword `template` is used and followed by an
+*id-expression*, the 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*. — *end note*]
+For a dot that is followed by an expression that designates a static
+member or an enumerator, the first expression is a discarded-value
+expression [[expr.context]]; if the expression after the dot designates
+a non-static data member, the first expression shall be a glvalue. A
+postfix expression that is followed by an arrow 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 form using a dot.[^11]
+The postfix expression before the dot is evaluated;[^12]
+the result of that evaluation, together with the *id-expression* or
+*splice-expression*, determines the result of the entire postfix
+expression.
+Abbreviating *postfix-expression*`.`*id-expression* or
+*postfix-expression*`.`*splice-expression* as `E1.E2`, `E1` is called
+the *object expression*. If the object expression is of scalar type,
+`E2` shall name the pseudo-destructor of that same type (ignoring
 cv-qualifications) and `E1.E2` is a prvalue of type “function of ()
 returning `void`”.
 [*Note 2*: This value can only be used for a notional function call
 [[expr.prim.id.dtor]]. — *end note*]
 when the class is complete [[class.member.lookup]]. — *end note*]
 [*Note 4*:  [[basic.lookup.qual]] describes how names are looked up
 after the `.` and `->` operators. — *end note*]
+If `E2` is a *splice-expression*, then let `T1` be the type of `E1`.
+`E2` shall designate either a member of `T1` or a direct base class
+relationship (`T1`, `B`).
+If `E2` designates a bit-field, `E1.E2` is a bit-field. The type and
+value category of `E1.E2` are determined as follows. In the remainder
+of  [[expr.ref]], *cq* represents either `const` or the absence of
+`const` and *vq* represents either `volatile` or the absence of
+`volatile`. *cv* represents an arbitrary set of cv-qualifiers, as
+defined in  [[basic.type.qualifier]].
+If `E2` designates an entity that is declared to have type “reference to
+`T`”, then `E1.E2` is an lvalue of type `T`. In that case, if `E2`
+designates 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.
+- If `E2` designates a static data member and the type of `E2` is `T`,
+ then `E1.E2` is an lvalue; the expression designates the named member
+ of the class. The type of `E1.E2` is `T`.
+- Otherwise, if `E2` designates a non-static data member and the type of
+  `E1` is “*cq1 vq1* `X`”, and the type of `E2` is “*cq2 vq2* `T`”, the
+ expression designates the corresponding member subobject of the object
+ designated by `E1`. If `E1` is an lvalue, then `E1.E2` is an lvalue;
+ otherwise `E1.E2` is an xvalue. Let the notation *vq12* stand for the
+  “union” of *vq1* and *vq2*; that is, if *vq1* or *vq2* is `volatile`,
+ then *vq12* is `volatile`. Similarly, let the notation *cq12* stand
+ for the “union” of *cq1* and *cq2*; that is, if *cq1* or *cq2* is
+ `const`, then *cq12* is `const`. If the entity designated by `E2` is
+  declared to be a `mutable` member, then the type of `E1.E2` is “*vq12*
+  `T`”. If the entity designated by `E2` is not declared to be a
+  `mutable` member, then the type of `E1.E2` is “*cq12* *vq12* `T`”.
+- Otherwise, if `E2` denotes an overload set, the expression shall be
+  the (possibly-parenthesized) left-hand operand of a member function
+  call [[expr.call]], and function overload resolution [[over.match]] is
+  used to select the function to which `E2` refers. The type of `E1.E2`
+  is the type of `E2` and `E1.E2` refers to the function referred to by
+  `E2`.
   - If `E2` refers to a static member function, `E1.E2` is an lvalue.
   - Otherwise (when `E2` refers to a non-static member function),
+    `E1.E2` is a prvalue. \[*Note 5*: Any redundant set of parentheses
+ surrounding the expression is ignored
+    [[expr.prim.paren]]. — *end note*]
+- Otherwise, if `E2` designates a nested type, the expression `E1.E2` is
+ ill-formed.
+- Otherwise, if `E2` designates 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.
+- Otherwise, if `E2` designates a direct base class relationship (D, B)
+  and the type of `E1` is cv `T`, the expression designates the direct
+  base class subobject of type B of the object designated by `E1`. If
+  `E1` is an lvalue, then `E1.E2` is an lvalue; otherwise, `E1.E2` is an
+  xvalue. The type of `E1.E2` is “cv `B`”.
+  \[*Note 6*: This can only occur in an expression of the form
+  `e1.[:e2:]`. — *end note*]
+  \[*Example 1*:
+  ``` cpp
+  struct B {
+    int b;
+  };
+  struct C : B {
+    int get() const { return b; }
+  };
+  struct D : B, C { };
+  constexpr int f() {
+    D d = {1, {}};
+    // b unambiguously refers to the direct base class of type B,
+    // not the indirect base class of type B
+    B& b = d.[: std::meta::bases_of(^^D, std::meta::access_context::current())[0] :];
+    b.b += 10;
+    return 10 * b.b + d.get();
+  }
+  static_assert(f() == 110);
+  ```
+  — *end example*]
+- Otherwise, the program is ill-formed.
+If `E2` designates a non-static member (possibly after overload
+resolution), the program is ill-formed if the class of which `E2`
+designates a direct member is an ambiguous base [[class.member.lookup]]
+of the designating class [[class.access.base]] of `E2`.
+[*Note 7*: The program is also ill-formed if the naming class is an
 ambiguous base of the class type of the object expression; see
 [[class.access.base]]. — *end note*]
+If `E2` designates a non-static member (possibly after overload
+resolution) and the result of `E1` is an object whose type is not
+similar [[conv.qual]] to the type of `E1`, the behavior is undefined.
+[*Example 2*:
 ``` cpp
 struct A { int i; };
 struct B { int j; };
 struct D : A, B {};
 — *end example*]
 #### Increment and decrement <a id="expr.post.incr">[[expr.post.incr]]</a>
+The value of a postfix `++` expression is the value obtained by applying
+the lvalue-to-rvalue conversion [[conv.lval]] to its operand.
 [*Note 1*: The value obtained is a copy of the original
 value. — *end note*]
 The operand shall be a modifiable lvalue. The type of the operand shall
 be an arithmetic type other than cv `bool`, or a pointer to a complete
 object type. An operand with volatile-qualified type is deprecated; see
 [[depr.volatile.type]]. The value of the operand object is modified
+[[defns.access]] as if it were the operand of the prefix `++` operator
+[[expr.pre.incr]]. The value computation of the `++` expression is
+sequenced before the modification of the operand object. With respect to
+an indeterminately-sequenced function call, the operation of postfix
+`++` is a single evaluation.
 [*Note 2*: Therefore, a function call cannot intervene between the
 lvalue-to-rvalue conversion and the side effect associated with any
 single postfix `++` operator. — *end note*]
 The result is a prvalue. The type of the result is the cv-unqualified
+version of the type of the operand.
 The operand of postfix `--` is decremented analogously to the postfix
 `++` operator.
 [*Note 3*: For prefix increment and decrement, see
 such that `B` is a base class of `D`, the result is a pointer to the
 unique `B` subobject of the `D` object pointed to by `v`, or a null
 pointer value if `v` is a null pointer value. Similarly, if `T` is
 “reference to *cv1* `B`” and `v` has type *cv2* `D` such that `B` is a
 base class of `D`, the result is the unique `B` subobject of the `D`
+object referred to by `v`.[^13]
 In both the pointer and reference cases, the program is ill-formed if
 `B` is an inaccessible or ambiguous base class of `D`.
 [*Example 1*:
 Otherwise, `v` shall be a pointer to or a glvalue of a polymorphic type
 [[class.virtual]].
 If `v` is a null pointer value, the result is a null pointer value.
+If `v` has type “pointer to cv `U`” and `v` does not point to an object
+whose type is similar [[conv.qual]] to `U` and that is within its
+lifetime or within its period of construction or destruction
+[[class.cdtor]], the behavior is undefined. If `v` is a glvalue of type
+`U` and `v` does not refer to an object whose type is similar to `U` and
+that is within its lifetime or within its period of construction or
+destruction, the behavior is undefined.
 If `T` is “pointer to cv `void`”, then the result is a pointer to the
 most derived object pointed to by `v`. Otherwise, a runtime check is
 applied to see if the object pointed or referred to by `v` can be
 converted to the type pointed or referred to by `T`.
 check logically executes as follows:
 - If, in the most derived object pointed (referred) to by `v`, `v`
   points (refers) to a public base class subobject of a `C` object, and
   if only one object of type `C` is derived from the subobject pointed
+  (referred) to by `v`, the result points (refers) to that `C` object.
 - Otherwise, if `v` points (refers) to a public base class subobject of
   the most derived object, and the type of the most derived object has a
   base class, of type `C`, that is unambiguous and public, the result
   points (refers) to the `C` subobject of the most derived object.
 - Otherwise, the runtime check *fails*.
 #### Type identification <a id="expr.typeid">[[expr.typeid]]</a>
 The result of a `typeid` expression is an lvalue of static type `const`
 `std::type_info` [[type.info]] and dynamic type `const` `std::type_info`
+or `const` `name` where `name` is an *implementation-defined* class
 publicly derived from `std::type_info` which preserves the behavior
+described in  [[type.info]].[^14]
 The lifetime of the object referred to by the lvalue extends to the end
 of the program. Whether or not the destructor is called for the
 `std::type_info` object at the end of the program is unspecified.
 If the type of the *expression* or *type-id* operand is a (possibly
 cv-qualified) class type or a reference to (possibly cv-qualified) class
 type, that class shall be completely defined.
+If an *expression* operand of `typeid` is a possibly-parenthesized
+*unary-expression* whose *unary-operator* is `*` and whose operand
+evaluates to a null pointer value [[basic.compound]], the `typeid`
+expression throws an exception [[except.throw]] of a type that would
+match a handler of type `std::bad_typeid` [[bad.typeid]].
+[*Note 1*: In other contexts, evaluating such a *unary-expression*
+results in undefined behavior [[expr.unary.op]]. — *end note*]
 When `typeid` is applied to a glvalue whose type is a polymorphic class
 type [[class.virtual]], the result refers to a `std::type_info` object
 representing the type of the most derived object [[intro.object]] (that
+is, the dynamic type) to which the glvalue refers.
 When `typeid` is applied to an expression other than a glvalue of a
 polymorphic class type, the result refers to a `std::type_info` object
 representing the static type of the expression. Lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
 `std::type_info` object representing the type of the *type-id*. If the
 type of the *type-id* is a reference to a possibly cv-qualified type,
 the result of the `typeid` expression refers to a `std::type_info`
 object representing the cv-unqualified referenced type.
+[*Note 2*: The *type-id* cannot denote a function type with a
 *cv-qualifier-seq* or a *ref-qualifier* [[dcl.fct]]. — *end note*]
 If the type of the expression or *type-id* is a cv-qualified type, the
 result of the `typeid` expression refers to a `std::type_info` object
 representing the cv-unqualified type.
 The type `std::type_info` [[type.info]] is not predefined; if a standard
 library declaration [[typeinfo.syn]], [[std.modules]] of
 `std::type_info` does not precede [[basic.lookup.general]] a `typeid`
 expression, the program is ill-formed.
+[*Note 3*: Subclause [[class.cdtor]] describes the behavior of `typeid`
 applied to an object under construction or destruction. — *end note*]
 #### Static cast <a id="expr.static.cast">[[expr.static.cast]]</a>
 The result of the expression `static_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. If `T` is an lvalue reference
 type or an rvalue reference to function type, the result is an lvalue;
 if `T` is an rvalue reference to object type, the result is an xvalue;
+otherwise, the result is a prvalue.
 An lvalue of type “*cv1* `B`”, where `B` is a class type, can be cast to
+type “reference to *cv2* `D`”, where `D` is a complete class derived
 [[class.derived]] from `B`, if *cv2* is the same cv-qualification as, or
 greater cv-qualification than, *cv1*. If `B` is a virtual base class of
 `D` or a base class of a virtual base class of `D`, or if no valid
 standard conversion from “pointer to `D`” to “pointer to `B`” exists
 [[conv.ptr]], the program is ill-formed. An xvalue of type “*cv1* `B`”
 used as the operand of the `static_cast` for the remainder of this
 subclause. If `T2` is an inaccessible [[class.access]] or ambiguous
 [[class.member.lookup]] base class of `T1`, a program that necessitates
 such a cast is ill-formed.
+Any expression can be explicitly converted to type cv `void`, in which
+case the operand is a discarded-value expression [[expr.prop]].
+[*Note 1*: Such a `static_cast` has no result as it is a prvalue of
+type `void`; see  [[basic.lval]]. — *end note*]
+[*Note 2*: However, if the value is in a temporary object
+[[class.temporary]], the destructor for that object is not executed
+until the usual time, and the value of the object is preserved for the
+purpose of executing the destructor. — *end note*]
+Otherwise, an expression E can be explicitly converted to a type `T` if
+there is an implicit conversion sequence [[over.best.ics]] from E to
+`T`, if overload resolution for a direct-initialization [[dcl.init]] of
+an object or reference of type `T` from E would find at least one viable
 function [[over.match.viable]], or if `T` is an aggregate type
 [[dcl.init.aggr]] having a first element `x` and there is an implicit
 conversion sequence from E to the type of `x`. If `T` is a reference
 type, the effect is the same as performing the declaration and
 initialization
 for some invented temporary variable `t` [[dcl.init]] and then using the
 temporary variable as the result of the conversion. Otherwise, the
 result object is direct-initialized from E.
+[*Note 3*: The conversion is ill-formed when attempting to convert an
 expression of class type to an inaccessible or ambiguous base
 class. — *end note*]
+[*Note 4*: If `T` is “array of unknown bound of `U`”, this
 direct-initialization defines the type of the expression as
 `U[1]`. — *end note*]
+Otherwise, the lvalue-to-rvalue [[conv.lval]], array-to-pointer
+[[conv.array]], and function-to-pointer [[conv.func]] conversions are
+applied to the operand, and the conversions that can be performed using
+`static_cast` are listed below. No other conversion can be performed
+using `static_cast`.
 A value of a scoped enumeration type [[dcl.enum]] can be explicitly
 converted to an integral type; the result is the same as that of
 converting to the enumeration’s underlying type and then to the
 destination type. A value of a scoped enumeration type can also be
 If no valid standard conversion from “pointer to member of `B` of type
 `T`” to “pointer to member of `D` of type `T`” exists [[conv.mem]], the
 program is ill-formed. The null member pointer value [[conv.mem]] is
 converted to the null member pointer value of the destination type. If
+class `B` contains the original member, or is a base class of the class
+containing the original member, the resulting pointer to member points
+to the original member. Otherwise, the behavior is undefined.
 [*Note 6*: Although class `B` need not contain the original member, the
 dynamic type of the object with which indirection through the pointer to
 member is performed must contain the original member; see
 [[expr.mptr.oper]]. — *end note*]
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
 prvalue of type “pointer to *cv2* `T`”, where `T` is an object type and
 *cv2* is the same cv-qualification as, or greater cv-qualification than,
 *cv1*. If the original pointer value represents the address `A` of a
 byte in memory and `A` does not satisfy the alignment requirement of
+`T`, then the resulting pointer value [[basic.compound]] is unspecified.
+Otherwise, if the original pointer value points to an object *a*, and
+there is an object *b* of type similar to `T` that is
+pointer-interconvertible [[basic.compound]] with *a*, the result is a
+pointer to *b*. Otherwise, the pointer value is unchanged by the
+conversion.
+[*Example 2*:
 ``` cpp
 T* p1 = new T;
 const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
 bool b = p1 == p2;  // b will have the value true.
 any type to the type `std::nullptr_t`. — *end note*]
 A value of integral type or enumeration type can be explicitly converted
 to a pointer. A pointer converted to an integer of sufficient size (if
 any such exists on the implementation) and back to the same pointer type
+will have its original value [[basic.compound]]; mappings between
+pointers and integers are otherwise *implementation-defined*.
 A function pointer can be explicitly converted to a function pointer of
 a different type.
 [*Note 4*: The effect of calling a function through a pointer to a
 Except that converting a prvalue of type “pointer to `T1`” to the type
 “pointer to `T2`” (where `T1` and `T2` are function types) and back to
 its original type yields the original pointer value, the result of such
 a pointer conversion is unspecified.
 An object pointer can be explicitly converted to an object pointer of a
+different type.[^15]
 When a prvalue `v` of object pointer type is converted to the object
 pointer type “pointer to cv `T`”, the result is
 `static_cast<cv T*>(static_cast<cv~void*>(v))`.
+[*Note 5*: Converting a pointer of type “pointer to `T1`” that points
 to an object of type `T1` to the type “pointer to `T2`” (where `T2` is
 an object type and the alignment requirements of `T2` are no stricter
 than those of `T1`) and back to its original type yields the original
 pointer value. — *end note*]
 yield the original pointer value.
 The null pointer value [[basic.compound]] is converted to the null
 pointer value of the destination type.
+[*Note 6*: A null pointer constant of type `std::nullptr_t` cannot be
 converted to a pointer type, and a null pointer constant of integral
 type is not necessarily converted to a null pointer
 value. — *end note*]
 A prvalue of type “pointer to member of `X` of type `T1`” can be
 explicitly converted to a prvalue of a different type “pointer to member
 of `Y` of type `T2`” if `T1` and `T2` are both function types or both
+object types.[^16]
 The null member pointer value [[conv.mem]] is converted to the null
 member pointer value of the destination type. The result of this
 conversion is unspecified, except in the following cases:
   `T1`” to the type “pointer to data member of `Y` of type `T2`” (where
   the alignment requirements of `T2` are no stricter than those of `T1`)
   and back to its original type yields the original pointer-to-member
   value.
+If `v` is a glvalue of type `T1`, designating an object or function *x*,
+it can be cast to the type “reference to `T2`” if an expression of type
+“pointer to `T1`” can be explicitly converted to the type “pointer to
+`T2`” using a `reinterpret_cast`. The result is that of
+`*reinterpret_cast<T2 *>(p)` where `p` is a pointer to *x* of type
+“pointer to `T1`”.
+[*Note 7*:
+No temporary is materialized [[conv.rval]] or created, no copy is made,
+and no constructors [[class.ctor]] or conversion functions
+[[class.conv]] are called.[^17]
+— *end note*]
 #### Const cast <a id="expr.const.cast">[[expr.const.cast]]</a>
 The result of the expression `const_cast<T>(v)` is of type `T`. If `T`
 is an lvalue reference to object type, the result is an lvalue; if `T`
 is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue and the lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
 [[conv.func]] standard conversions are performed on the expression `v`.
+The temporary materialization conversion [[conv.rval]] is not performed
+on `v`, other than as specified below. Conversions that can be performed
+explicitly using `const_cast` are listed below. No other conversion
+shall be performed explicitly using `const_cast`.
 [*Note 1*: Subject to the restrictions in this subclause, an expression
 can be cast to its own type using a `const_cast`
 operator. — *end note*]
+For two similar object pointer or pointer to data member types `T1` and
+`T2` [[conv.qual]], a prvalue of type `T1` can be explicitly converted
+to the type `T2` using a `const_cast` if, considering the
+qualification-decompositions of both types, each P¹ᵢ is the same as P²ᵢ
+for all i. If `v` is a null pointer or null member pointer, the result
+is a null pointer or null member pointer, respectively. Otherwise, the
+result points to or past the end of the same object, or points to the
+same member, respectively, as `v`.
 For two object types `T1` and `T2`, if a pointer to `T1` can be
 explicitly converted to the type “pointer to `T2`” using a `const_cast`,
 then the following conversions can also be made:
 - an lvalue of type `T1` can be explicitly converted to an lvalue of
   type `T2` using the cast `const_cast<T2&>`;
 - a glvalue of type `T1` can be explicitly converted to an xvalue of
   type `T2` using the cast `const_cast<T2&&>`; and
+- if `T1` is a class or array type, a prvalue of type `T1` can be
+ explicitly converted to an xvalue of type `T2` using the cast
+  `const_cast<T2&&>`. The temporary materialization conversion is
+  performed on `v`.
+The result refers to the same object as the (possibly converted)
+operand.
+[*Example 1*:
+``` cpp
+typedef int *A[3];                  // array of 3 pointer to int
+typedef const int *const CA[3];     // array of 3 const pointer to const int
+auto &&r2 = const_cast<A&&>(CA{});  // OK, temporary materialization conversion is performed
+```
+— *end example*]
 [*Note 2*:
 Depending on the type of the object, a write operation through the
 pointer, lvalue or pointer to data member resulting from a `const_cast`
+that casts away a const-qualifier[^18]
 can produce undefined behavior [[dcl.type.cv]].
 — *end note*]
     sizeof '...' '(' identifier ')'
     alignof '(' type-id ')'
     noexcept-expression
     new-expression
     delete-expression
+    reflect-expression
 ```
 ``` bnf
 %% Ed. note: character protrusion would misalign operators.
 #### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
 The unary `*` operator performs *indirection*. Its operand shall be a
 prvalue of type “pointer to `T`”, where `T` is an object or function
+type. The operator yields an lvalue of type `T`. If the operand points
+to an object or function, the result denotes that object or function;
+otherwise, the behavior is undefined except as specified in
+[[expr.typeid]].
+[*Note 1*: Indirection through a pointer to an out-of-lifetime object
+is valid [[basic.life]]. — *end note*]
+[*Note 2*:  Indirection through a pointer to an incomplete type (other
 than cv `void`) is valid. The lvalue thus obtained can be used in
 limited ways (to initialize a reference, for example); this lvalue must
 not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
 Each of the following unary operators yields a prvalue.
 The operand of the unary `&` operator shall be an lvalue of some type
+`T`.
+- If the operand is a *qualified-id* or *splice-expression* designating
+ a non-static member `m`, other than an explicit object member
+  function, `m` shall be a direct member of some class `C` that is not
+ an anonymous union. The result has type “pointer to member of class
+  `C` of type `T`” and designates `C::m`. \[*Note 3*: A *qualified-id*
+  that names a member of a namespace-scope anonymous union is considered
+  to be a class member access expression [[expr.prim.id.general]] and
+  cannot be used to form a pointer to member. — *end note*]
 - Otherwise, the result has type “pointer to `T`” and points to the
   designated object [[intro.memory]] or function [[basic.compound]]. If
+  the operand designates an explicit object member function [[dcl.fct]],
+ the operand shall be a *qualified-id* or a *splice-expression*.
+ \[*Note 4*: In particular, taking the address of a variable of type
+  “cv `T`” yields a pointer of type “pointer to cv `T`”. — *end note*]
 [*Example 1*:
 ``` cpp
 struct A { int i; };
 bool b = p2 > p1;   // defined behavior, with value true
 ```
 — *end example*]
+[*Note 5*: A pointer to member formed from a `mutable` non-static data
 member [[dcl.stc]] does not reflect the `mutable` specifier associated
 with the non-static data member. — *end note*]
 A pointer to member is only formed when an explicit `&` is used and its
+operand is a *qualified-id* or *splice-expression* not enclosed in
+parentheses.
+[*Note 6*: That is, the expression `&(qualified-id)`, where the
 *qualified-id* is enclosed in parentheses, does not form an expression
 of type “pointer to member”. Neither does `qualified-id`, because there
 is no implicit conversion from a *qualified-id* for a non-static member
 function to the type “pointer to member function” as there is from an
 lvalue of function type to the type “pointer to function” [[conv.func]].
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
+[*Note 7*: The address of an overload set [[over]] can be taken only in
 a context that uniquely determines which function is referred to (see
 [[over.over]]). Since the context can affect whether the operand is a
 static or non-static member function, the context can also affect
 whether the expression has type “pointer to function” or “pointer to
 member function”. — *end note*]
+The operand of the unary `+` operator shall be a prvalue of arithmetic,
+unscoped enumeration, or pointer type and the result is the value of the
 argument. Integral promotion is performed on integral or enumeration
 operands. The type of the result is the type of the promoted operand.
+The operand of the unary `-` operator shall be a prvalue of arithmetic
+or unscoped enumeration type and the result is the negative of its
+operand. Integral promotion is performed on integral or enumeration
+operands. The negative of an unsigned quantity is computed by
+subtracting its value from 2ⁿ, where n is the number of bits in the
+promoted operand. The type of the result is the type of the promoted
+operand.
+[*Note 8*: The result is the two’s complement of the operand (where
 operand and result are considered as unsigned). — *end note*]
 The operand of the logical negation operator `!` is contextually
 converted to `bool` [[conv]]; its value is `true` if the converted
 operand is `false` and `false` otherwise. The type of the result is
 `bool`.
+The operand of the `~` operator shall be a prvalue of integral or
+unscoped enumeration type. Integral promotions are performed. The type
+of the result is the type of the promoted operand. Given the
+coefficients `xᵢ` of the base-2 representation [[basic.fundamental]] of
+the promoted operand `x`, the coefficient `rᵢ` of the base-2
+representation of the result `r` is 1 if `xᵢ` is 0, and 0 otherwise.
+[*Note 9*: The result is the ones’ complement of the operand (where
 operand and result are considered as unsigned). — *end note*]
 There is an ambiguity in the grammar when `~` is followed by a
+*type-name* or *computed-type-specifier*. The ambiguity is resolved by
 treating `~` as the operator rather than as the start of an
 *unqualified-id* naming a destructor.
+[*Note 10*: Because the grammar does not permit an operator to follow
 the `.`, `->`, or `::` tokens, a `~` followed by a *type-name* or
+*computed-type-specifier* in a member access expression or
+*qualified-id* is unambiguously parsed as a destructor
+name. — *end note*]
 #### Increment and decrement <a id="expr.pre.incr">[[expr.pre.incr]]</a>
+The operand of prefix `++` or `--` shall not be of type cv `bool`. An
+operand with volatile-qualified type is deprecated; see
+[[depr.volatile.type]]. The expression `++x` is otherwise equivalent to
+`x+=1` and the expression `--x` is otherwise equivalent to `x-=1`
+[[expr.assign]].
+[*Note 1*: For postfix increment and decrement, see
 [[expr.post.incr]]. — *end note*]
 #### Await <a id="expr.await">[[expr.await]]</a>
 The `co_await` expression is used to suspend evaluation of a coroutine
 [[dcl.fct.def.coroutine]] while awaiting completion of the computation
+represented by the operand expression. Suspending the evaluation of a
+coroutine transfers control to its caller or resumer.
 ``` bnf
 await-expression:
+    co_await cast-expression
 ```
+An *await-expression* shall appear only as a potentially-evaluated
+expression within the *compound-statement* of a *function-body* or
+*lambda-expression*, in either case outside of a *handler*
+[[except.pre]]. In a *declaration-statement* or in the
 *simple-declaration* (if any) of an *init-statement*, an
 *await-expression* shall appear only in an *initializer* of that
 *declaration-statement* or *simple-declaration*. An *await-expression*
 shall not appear in a default argument [[dcl.fct.default]]. An
 *await-expression* shall not appear in the initializer of a block
+variable with static or thread storage duration. An *await-expression*
+shall not be a potentially-evaluated subexpression of the predicate of a
+contract assertion [[basic.contract]]. A context within a function where
+an *await-expression* can appear is called a *suspension context* of the
+function.
 Evaluation of an *await-expression* involves the following auxiliary
 types, expressions, and objects:
 - *p* is an lvalue naming the promise object [[dcl.fct.def.coroutine]]
 [*Note 1*:
 In particular, the values of `sizeof(bool)`, `sizeof(char16_t)`,
 `sizeof(char32_t)`, and `sizeof(wchar_t)` are
+implementation-defined.[^19]
 — *end note*]
 [*Note 2*: See  [[intro.memory]] for the definition of byte and
 [[term.object.representation]] for the definition of object
 When applied to a reference type, the result is the size of the
 referenced type. When applied to a class, the result is the number of
 bytes in an object of that class including any padding required for
 placing objects of that type in an array. The result of applying
 `sizeof` to a potentially-overlapping subobject is the size of the type,
+not the size of the subobject.[^20]
 When applied to an array, the result is the total number of bytes in the
 array. This implies that the size of an array of n elements is n times
 the size of an element.
 The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are not applied
 to the operand of `sizeof`. If the operand is a prvalue, the temporary
 materialization conversion [[conv.rval]] is applied.
+The *identifier* in a `sizeof...` expression shall name a pack. The
 `sizeof...` operator yields the number of elements in the pack
 [[temp.variadic]]. A `sizeof...` expression is a pack expansion
 [[temp.variadic]].
 [*Example 1*:
 ``` cpp
 template<class... Types>
 struct count {
+  static constexpr std::size_t value = sizeof...(Types);
 };
 ```
 — *end example*]
 The result of `sizeof` and `sizeof...` is a prvalue of type
 `std::size_t`.
 [*Note 3*: A `sizeof` expression is an integral constant expression
+[[expr.const]]. The *typedef-name* `std::size_t` is declared in the
+standard header `<cstddef>`
+[[cstddef.syn]], [[support.types.layout]]. — *end note*]
 #### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 An `alignof` expression yields the alignment requirement of its operand
 type. The operand shall be a *type-id* representing a complete object
 type, or an array thereof, or a reference to one of those types.
 The result is a prvalue of type `std::size_t`.
 [*Note 1*: An `alignof` expression is an integral constant expression
+[[expr.const]]. The *typedef-name* `std::size_t` is declared in the
+standard header `<cstddef>`
+[[cstddef.syn]], [[support.types.layout]]. — *end note*]
 When `alignof` is applied to a reference type, the result is the
 alignment of the referenced type. When `alignof` is applied to an array
 type, the result is the alignment of the element type.
 #### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
 ``` bnf
 noexcept-expression:
   noexcept '(' expression ')'
 ```
+The operand of the `noexcept` operator is an unevaluated operand
+[[term.unevaluated.operand]]. If the operand is a prvalue, the temporary
+materialization conversion [[conv.rval]] is applied.
+The result of the `noexcept` operator is a prvalue of type `bool`. The
+result is `false` if the full-expression of the operand is
+potentially-throwing [[except.spec]], and `true` otherwise.
 [*Note 1*: A *noexcept-expression* is an integral constant expression
 [[expr.const]]. — *end note*]
 #### New <a id="expr.new">[[expr.new]]</a>
+The *new-expression* attempts to create an object of the *type-id* or
+*new-type-id* [[dcl.name]] to which it is applied. The type of that
 object is the *allocated type*. This type shall be a complete object
 type [[term.incomplete.type]], but not an abstract class type
 [[class.abstract]] or array thereof [[intro.object]].
 [*Note 1*: Because references are not objects, references cannot be
 new-initializer:
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
+If a placeholder type [[dcl.spec.auto]] or a placeholder for a deduced
+class type [[dcl.type.class.deduct]] appears in the *type-specifier-seq*
+of a *new-type-id* or *type-id* of a *new-expression*, the allocated
+type is deduced as follows: Let *init* be the *new-initializer*, if any,
+and `T` be the *new-type-id* or *type-id* of the *new-expression*, then
+the allocated type is the type deduced for the variable `x` in the
+invented declaration [[dcl.spec.auto]]:
 ``` cpp
 T x init ;
 ```
 its value shall be greater than zero.
 [*Example 4*: Given the definition `int n = 42`, `new float[n][5]` is
 well-formed (because `n` is the *expression* of a
 *noptr-new-declarator*), but `new float[5][n]` is ill-formed (because
+`n` is not a constant expression). Furthermore, `new float[0]` is
+well-formed (because `0` is the *expression* of a
+*noptr-new-declarator*, where a value of zero results in the allocation
+of an array with no elements), but `new float[n][0]` is ill-formed
+(because `0` is the *constant-expression* of a *noptr-new-declarator*,
+where only values greater than zero are allowed). — *end example*]
 If the *type-id* or *new-type-id* denotes an array type of unknown bound
 [[dcl.array]], the *new-initializer* shall not be omitted; the allocated
 object is an array with `n` elements, where `n` is determined from the
 number of initial elements supplied in the *new-initializer*
 [[dcl.init.aggr]], [[dcl.init.string]].
 If the *expression* in a *noptr-new-declarator* is present, it is
+implicitly converted to `std::size_t`. The value of the *expression* is
+invalid if
 - the expression is of non-class type and its value before converting to
   `std::size_t` is less than zero;
 - the expression is of class type and its value before application of
+  the second standard conversion [[over.ics.user]][^21] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
   the *implementation-defined* limit [[implimits]]; or
 - the *new-initializer* is a *braced-init-list* and the number of array
   elements for which initializers are provided (including the
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
+If the value of the *expression* is invalid after converting to
+`std::size_t`:
 - if the *expression* is a potentially-evaluated core constant
   expression, the program is ill-formed;
 - otherwise, an allocation function is not called; instead
   - if the allocation function that would have been called has a
     `std::bad_array_new_length` [[new.badlength]].
 When the value of the *expression* is zero, the allocation function is
 called to allocate an array with no elements.
+If the allocated type is an array, the *new-initializer* is a
+*braced-init-list*, and the *expression* is potentially-evaluated and
+not a core constant expression, the semantic constraints of
+copy-initializing a hypothetical element of the array from an empty
+initializer list are checked [[dcl.init.list]].
+[*Note 5*: The array can contain more elements than there are elements
+in the *braced-init-list*, requiring initialization of the remainder of
+the array elements from an empty initializer list. — *end note*]
 Objects created by a *new-expression* have dynamic storage duration
 [[basic.stc.dynamic]].
+[*Note 6*:  The lifetime of such an object is not necessarily
 restricted to the scope in which it is created. — *end note*]
 When the allocated type is “array of `N` `T`” (that is, the
 *noptr-new-declarator* syntax is used or the *new-type-id* or *type-id*
 denotes an array type), the *new-expression* yields a prvalue of type
 “pointer to `T`” that points to the initial element (if any) of the
 array. Otherwise, let `T` be the allocated type; the *new-expression* is
 a prvalue of type “pointer to T” that points to the object created.
+[*Note 7*: Both `new int` and `new int[10]` have type `int*` and the
 type of `new int[i][10]` is `int (*)[10]`. — *end note*]
 A *new-expression* may obtain storage for the object by calling an
 allocation function [[basic.stc.dynamic.allocation]]. If the
 *new-expression* terminates by throwing an exception, it may release
 type, the allocation function’s name is `operator new` and the
 deallocation function’s name is `operator delete`. If the allocated type
 is an array type, the allocation function’s name is `operator new[]` and
 the deallocation function’s name is `operator delete[]`.
+[*Note 8*: An implementation is expected to provide default definitions
 for the global allocation functions
 [[basic.stc.dynamic]], [[new.delete.single]], [[new.delete.array]]. A
 C++ program can provide alternative definitions of these functions
 [[replacement.functions]] and/or class-specific versions [[class.free]].
 The set of allocation and deallocation functions that can be called by a
 An implementation is allowed to omit a call to a replaceable global
 allocation function [[new.delete.single]], [[new.delete.array]]. When it
 does so, the storage is instead provided by the implementation or
 provided by extending the allocation of another *new-expression*.
+During an evaluation of a constant expression, a call to a replaceable
+allocation function is always omitted [[expr.const]].
 The implementation may extend the allocation of a *new-expression* `e1`
 to provide storage for a *new-expression* `e2` if the following would be
 true were the allocation not extended:
 value of the *new-expression* shall be null.
 [*Note 11*: When the allocation function returns a value other than
 null, it must be a pointer to a block of storage in which space for the
 object has been reserved. The block of storage is assumed to be
+appropriately aligned [[basic.align]] and of the requested size. The
+address of the created object will not necessarily be the same as that
+of the block if the object is an array. — *end note*]
 A *new-expression* that creates an object of type `T` initializes that
 object as follows:
 - If the *new-initializer* is omitted, the object is default-initialized
 The invocation of the allocation function is sequenced before the
 evaluations of expressions in the *new-initializer*. Initialization of
 the allocated object is sequenced before the value computation of the
 *new-expression*.
+If the *new-expression* creates an array of objects of class type, the
+destructor is potentially invoked [[class.dtor]].
+If any part of the object initialization described above[^22]
 terminates by throwing an exception and a suitable deallocation function
 can be found, the deallocation function is called to free the memory in
 which the object was being constructed, after which the exception
 continues to propagate in the context of the *new-expression*. If no
 otherwise, no deallocation function will be called. If the lookup finds
 a usual deallocation function and that function, considered as a
 placement deallocation function, would have been selected as a match for
 the allocation function, the program is ill-formed. For a non-placement
 allocation function, the normal deallocation function lookup is used to
+find the matching deallocation function [[expr.delete]]. In any case,
+the matching deallocation function (if any) shall be non-deleted and
+accessible from the point where the *new-expression* appears.
 [*Example 7*:
 ``` cpp
 struct S {
 ```
 The first alternative is a *single-object delete expression*, and the
 second is an *array delete expression*. Whenever the `delete` keyword is
 immediately followed by empty square brackets, it shall be interpreted
+as the second alternative.[^23]
+If the operand is of class type, it is contextually implicitly converted
+[[conv]] to a pointer to object type and the converted operand is used
+in place of the original operand for the remainder of this subclause.
+Otherwise, it shall be a prvalue of pointer to object type. The
+*delete-expression* has type `void`.
+In a single-object delete expression, the value of the operand of
+`delete` may be a null pointer value, a pointer value that resulted from
+a previous non-array *new-expression*, or a pointer to a base class
+subobject of an object created by such a *new-expression*. If not, the
+behavior is undefined. In an array delete expression, the value of the
+operand of `delete` may be a null pointer value or a pointer value that
+resulted from a previous array *new-expression* whose allocation
+function was not a non-allocating form [[new.delete.placement]].[^24]
 If not, the behavior is undefined.
 [*Note 1*: This means that the syntax of the *delete-expression* must
 match the type of the object allocated by `new`, not the syntax of the
 object to be deleted and the static type shall have a virtual destructor
 or the behavior is undefined. In an array delete expression, if the
 dynamic type of the object to be deleted is not similar to its static
 type, the behavior is undefined.
 If the object being deleted has incomplete class type at the point of
+deletion, the program is ill-formed.
 If the value of the operand of the *delete-expression* is not a null
 pointer value and the selected deallocation function (see below) is not
+a destroying operator delete, evaluating the *delete-expression* invokes
+the destructor (if any) for the object or the elements of the array
+being deleted. The destructor shall be accessible from the point where
+the *delete-expression* appears. In the case of an array, the elements
+are destroyed in order of decreasing address (that is, in reverse order
+of the completion of their constructor; see  [[class.base.init]]).
 If the value of the operand of the *delete-expression* is not a null
 pointer value, then:
 - If the allocation call for the *new-expression* for the object to be
 [*Note 5*: If only a placement deallocation function is found in a
 class, the program is ill-formed because the lookup set is empty
 [[basic.lookup]]. — *end note*]
+The deallocation function to be called is selected as follows:
 - If any of the deallocation functions is a destroying operator delete,
   all deallocation functions that are not destroying operator deletes
   are eliminated from further consideration.
 - If the type has new-extended alignment, a function with a parameter of
   or a (possibly multidimensional) array thereof, the function with a
   parameter of type `std::size_t` is selected.
 - Otherwise, it is unspecified whether a deallocation function with a
   parameter of type `std::size_t` is selected.
+Unless the deallocation function is selected at the point of definition
+of the dynamic type’s virtual destructor, the selected deallocation
+function shall be accessible from the point where the
+*delete-expression* appears.
 For a single-object delete expression, the deleted object is the object
 A pointed to by the operand if the static type of A does not have a
 virtual destructor, and the most-derived object of A otherwise.
 [*Note 6*: If the deallocation function is not a destroying operator
 function, and either the first argument was not the result of a prior
 call to a replaceable allocation function or the second or third
 argument was not the corresponding argument in said call, the behavior
 is undefined [[new.delete.single]], [[new.delete.array]]. — *end note*]
+#### The reflection operator <a id="expr.reflect">[[expr.reflect]]</a>
+``` bnf
+reflect-expression:
+    '^^' '::'
+    '^^' reflection-name
+    '^^' type-id
+    '^^' id-expression
+```
+``` bnf
+reflection-name:
+    nested-name-specifierₒₚₜ identifier
+    nested-name-specifier template identifier
+```
+The unary `^^` operator, called the *reflection operator*, yields a
+prvalue of type `std::meta::info` [[basic.fundamental]].
+[*Note 1*: This document places no restriction on representing, by
+reflections, constructs not described by this document or using the
+names of such constructs as operands of
+*reflect-expression*s. — *end note*]
+The component names of a *reflection-name* are those of its
+*nested-name-specifier* (if any) and its *identifier*. The terminal name
+of a *reflection-name* of the form *nested-name-specifier* `template`
+*identifier* shall denote a template.
+A *reflect-expression* is parsed as the longest possible sequence of
+tokens that could syntactically form a *reflect-expression*. An
+unparenthesized *reflect-expression* that represents a template shall
+not be followed by `<`.
+[*Example 1*:
+``` cpp
+static_assert(std::meta::is_type(^^int()));     // ^^ applies to the type-id int()
+template<bool> struct X {};
+consteval bool operator<(std::meta::info, X<false>) { return false; }
+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;     // error: int &&&& is not a valid type-id
+  ^^X < xv;                 // error: reflect-expression that represents a template is followed by <
+  (^^X) < xv;               // OK
+  ^^X<true> < xv;           // OK
+}
+```
+— *end example*]
+A *reflect-expression* of the form `^^ ::` represents the global
+namespace.
+If a *reflect-expression* R matches the form `^^ reflection-name`, it is
+interpreted as such; the *identifier* is looked up and the
+representation of R is determined as follows:
+- If lookup finds a declaration that replaced a *using-declarator*
+  during a single search [[basic.lookup.general]], [[namespace.udecl]],
+  R is ill-formed.
+  \[*Example 2*:
+  ``` cpp
+  struct A { struct S {}; };
+  struct B : A { using A::S; };
+  constexpr std::meta::info r1 = ^^B::S;  // error: A::S found through using-declarator
+  struct C : virtual B { struct S {}; };
+  struct D : virtual B, C {};
+  D::S s;                                 // OK, names C::S per [class.member.lookup]
+  constexpr std::meta::info r2 = ^^D::S;  // OK, result C::S not found through using-declarator
+  ```
+  — *end example*]
+- Otherwise, if lookup finds a namespace alias [[namespace.alias]], R
+  represents that namespace alias.
+- Otherwise, if lookup finds a namespace [[basic.namespace]], R
+  represents that namespace.
+- Otherwise, if lookup finds a concept [[temp.concept]], R represents
+  the denoted concept.
+- Otherwise, if lookup finds a template [[temp.names]], the
+  representation of R is determined as follows:
+  - If lookup finds an injected-class-name [[class.pre]], then:
+    - If the *reflection-name* is of the form
+      `nested-name-specifier template identifier`, then R represents the
+      class template named by the injected-class-name.
+    - Otherwise, the injected-class-name shall be unambiguous when
+      considered as a *type-name* and R represents the class template
+      specialization so named.
+  - Otherwise, if lookup finds an overload set, that overload set shall
+    contain only declarations of a unique function template F; R
+    represents F.
+  - Otherwise, if lookup finds a class template, variable template, or
+    alias template, R represents that template. \[*Note 2*: Lookup never
+    finds a partial or explicit specialization. — *end note*]
+- Otherwise, if lookup finds a type alias A, R represents the underlying
+  entity of A if A was introduced by the declaration of a template
+  parameter; otherwise, R represents A.
+- Otherwise, if lookup finds a class or an enumeration, R represents the
+  denoted type.
+- Otherwise, if lookup finds a class member of an anonymous union
+  [[class.union.anon]], R represents that class member.
+- Otherwise, the *reflection-name* shall be an *id-expression* `I` and R
+  is `^^ I` (see below).
+A *reflect-expression* R of the form `^^ type-id` represents an entity
+determined as follows:
+- If the *type-id* designates a placeholder type
+  [[dcl.spec.auto.general]], R is ill-formed.
+- Otherwise, if the *type-id* names a type alias that is a
+  specialization of an alias template [[temp.alias]], R represents that
+  type alias.
+- Otherwise, R represents the type denoted by the *type-id*.
+A *reflect-expression* R of the form `^^ id-expression` represents an
+entity determined as follows:
+- If the *id-expression* denotes
+  - a variable declared by an *init-capture*
+    [[expr.prim.lambda.capture]],
+  - a function-local predefined variable [[dcl.fct.def.general]],
+  - a local parameter introduced by a *requires-expression*
+    [[expr.prim.req]], or
+  - a local entity E [[basic.pre]] for which a lambda scope intervenes
+    between the point at which E was introduced and R,
+  then R is ill-formed.
+- Otherwise, if the *id-expression* denotes an overload set S, overload
+  resolution for the expression `&S` with no target shall select a
+  unique function [[over.over]]; R represents that function.
+- Otherwise, if the *id-expression* denotes a variable, structured
+  binding, enumerator, or non-static data member, R represents that
+  entity.
+- Otherwise, R is ill-formed. \[*Note 3*: This includes
+  *unqualified-id*s that name a constant template parameter and
+  *pack-index-expression*s. — *end note*]
+The *id-expression* of a *reflect-expression* is an unevaluated operand
+[[expr.context]].
+[*Example 3*:
+``` cpp
+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 std::meta::info a = ^^fn<char>;       // OK
+constexpr std::meta::info b = ^^fn<int>;        // error: ambiguous
+constexpr std::meta::info c = ^^std::vector;    // OK
+template<typename T>
+struct S {
+  static constexpr std::meta::info r = ^^T;
+  using type = T;
+};
+static_assert(S<int>::r == ^^int);
+static_assert(^^S<int>::type != ^^int);
+typedef struct X {} Y;
+typedef struct Z {} Z;
+constexpr std::meta::info e = ^^Y;              // OK, represents the type alias Y
+constexpr std::meta::info f = ^^Z;              // OK, represents the type alias Z, not the type[basic.lookup.general]
+```
+— *end example*]
 ### Explicit type conversion (cast notation) <a id="expr.cast">[[expr.cast]]</a>
 The result of the expression `(T)` *cast-expression* is of type `T`. The
 result is an lvalue if `T` is an lvalue reference type or an rvalue
   of a derived class type, respectively.
 If a conversion can be interpreted in more than one of the ways listed
 above, the interpretation that appears first in the list is used, even
 if a cast resulting from that interpretation is ill-formed. If a
+`static_cast` followed by a `const_cast` is used and the conversion can
+be interpreted in more than one way as such, the conversion is
+ill-formed.
 [*Example 1*:
 ``` cpp
 struct A { };
 struct I2 : A { };
 struct D : I1, I2 { };
 A* foo( D* p ) {
   return (A*)( p );             // ill-formed static_cast interpretation
 }
+int*** ptr = 0;
+auto t = (int const*const*const*)ptr;   // OK, const_cast interpretation
+struct S {
+  operator const int*();
+  operator volatile int*();
+};
+int *p = (int*)S();     // error: two possible interpretations using static_cast followed by const_cast
 ```
 — *end example*]
 The operand of a cast using the cast notation can be a prvalue of type
 incomplete, it is unspecified whether the `static_cast` or the
 `reinterpret_cast` interpretation is used, even if there is an
 inheritance relationship between the two classes.
 [*Note 2*: For example, if the classes were defined later in the
+translation unit, a multi-pass compiler could validly interpret a cast
+between pointers to the classes as if the class types were complete at
+the point of the cast. — *end note*]
 ### Pointer-to-member operators <a id="expr.mptr.oper">[[expr.mptr.oper]]</a>
 The pointer-to-member operators `->*` and `.*` group left-to-right.
     cast-expression
     pm-expression '.*' cast-expression
     pm-expression '->*' cast-expression
 ```
+The binary operator `.*` binds its second operand, which shall be a
+prvalue of type “pointer to member of `T`” to its first operand, which
+shall be a glvalue of class `T` or of a class of which `T` is an
+unambiguous and accessible base class. The result is an object or a
+function of the type specified by the second operand.
+The binary operator `->*` binds its second operand, which shall be a
+prvalue of type “pointer to member of `T`” to its first operand, which
+shall be of type “pointer to `U`” where `U` is either `T` or a class of
+which `T` is an unambiguous and accessible base class. The expression
+`E1->*E2` is converted into the equivalent form `(*(E1)).*E2`.
 Abbreviating *pm-expression*`.*`*cast-expression* as `E1.*E2`, `E1` is
 called the *object expression*. If the result of `E1` is an object whose
 type is not similar to the type of `E1`, or whose most derived object
 does not contain the member to which `E2` refers, the behavior is
 The binary `*` operator indicates multiplication.
 The binary `/` operator yields the quotient, and the binary `%` operator
 yields the remainder from the division of the first expression by the
+second. If the second operand of `/` or `%` is zero, the behavior is
+undefined. For integral operands, the `/` operator yields the algebraic
+quotient with any fractional part discarded;[^25]
 if the quotient `a/b` is representable in the type of the result,
 `(a/b)*b + a%b` is equal to `a`; otherwise, the behavior of both `a/b`
 and `a%b` is undefined.
 ### Additive operators <a id="expr.add">[[expr.add]]</a>
+The additive operators `+` and `-` group left-to-right. Each operand
+shall be a prvalue. If both operands have arithmetic or unscoped
+enumeration type, the usual arithmetic conversions [[expr.arith.conv]]
+are performed. Otherwise, if one operand has arithmetic or unscoped
+enumeration type, integral promotion is applied [[conv.prom]] to that
+operand. A converted or promoted operand is used in place of the
+corresponding original operand for the remainder of this section.
 ``` bnf
 additive-expression:
     multiplicative-expression
     additive-expression '+' multiplicative-expression
     additive-expression '-' multiplicative-expression
 ```
+For addition, either both operands shall have arithmetic type, or one
+operand shall be a pointer to a completely-defined object type and the
+other shall have integral type.
 For subtraction, one of the following shall hold:
+- both operands have arithmetic type; or
 - both operands are pointers to cv-qualified or cv-unqualified versions
   of the same completely-defined object type; or
 - the left operand is a pointer to a completely-defined object type and
+  the right operand has integral type.
 The result of the binary `+` operator is the sum of the operands. The
 result of the binary `-` operator is the difference resulting from the
 subtraction of the second operand from the first.
 When an expression `J` that has integral type is added to or subtracted
 from an expression `P` of pointer type, the result has the type of `P`.
 - If `P` evaluates to a null pointer value and `J` evaluates to 0, the
   result is a null pointer value.
+- Otherwise, if `P` points to a (possibly-hypothetical) array element i
+ of an array object `x` with n elements [[dcl.array]],[^26] the
+ expressions `P + J` and `J + P` (where `J` has the value j) point to
+ the (possibly-hypothetical) array element i + j of `x` if
+ 0 ≤ i + j ≤ n and the expression `P - J` points to the
+ (possibly-hypothetical) array element i - j of `x` if 0 ≤ i - j ≤ n.
 - Otherwise, the behavior is undefined.
 [*Note 1*: Adding a value other than 0 or 1 to a pointer to a base
 class subobject, a member subobject, or a complete object results in
 undefined behavior. — *end note*]
 When two pointer expressions `P` and `Q` are subtracted, the type of the
 result is an *implementation-defined* signed integral type; this type
+shall be the same type that is named by `std::ptrdiff_t` in the
 `<cstddef>` header [[support.types.layout]].
 - If `P` and `Q` both evaluate to null pointer values, the result is 0.
 - Otherwise, if `P` and `Q` point to, respectively, array elements i and
   j of the same array object `x`, the expression `P - Q` has the value
+  i - j. \[*Note 2*: If the value i - j is not in the range of
+  representable values of type `std::ptrdiff_t`, the behavior is
+ undefined [[expr.pre]]. — *end note*]
+- Otherwise, the behavior is undefined.
 For addition or subtraction, if the expressions `P` or `Q` have type
 “pointer to cv `T`”, where `T` and the array element type are not
 similar [[conv.qual]], the behavior is undefined.
     additive-expression
     shift-expression '<<' additive-expression
     shift-expression '>>' additive-expression
 ```
+The operands shall be prvalues of integral or unscoped enumeration type
+and integral promotions are performed. The type of the result is that of
+the promoted left operand. The behavior is undefined if the right
+operand is negative, or greater than or equal to the width of the
+promoted left operand.
 The value of `E1 << E2` is the unique value congruent to `E1` × 2^`E2`
 modulo 2ᴺ, where N is the width of the type of the result.
 [*Note 1*: `E1` is left-shifted `E2` bit positions; vacated bits are
 zero-filled. — *end note*]
+The value of `E1 >> E2` is `E1` / 2^`E2`, rounded towards negative
+infinity.
 [*Note 2*: `E1` is right-shifted `E2` bit positions. Right-shift on
 signed integral types is an arithmetic right shift, which performs
 sign-extension. — *end note*]
     relational-expression '>' compare-expression
     relational-expression '<=' compare-expression
     relational-expression '>=' compare-expression
 ```
+The lvalue-to-rvalue [[conv.lval]] and function-to-pointer [[conv.func]]
+standard conversions are performed on the operands. If one of the
+operands is a pointer, the array-to-pointer conversion [[conv.array]] is
+performed on the other operand.
 The converted operands shall have arithmetic, enumeration, or pointer
 type. The operators `<` (less than), `>` (greater than), `<=` (less than
 or equal to), and `>=` (greater than or equal to) all yield `false` or
 `true`. The type of the result is `bool`.
 The usual arithmetic conversions [[expr.arith.conv]] are performed on
+operands of arithmetic or enumeration type. If both converted operands
+are pointers, pointer conversions [[conv.ptr]], function pointer
+conversions [[conv.fctptr]], and qualification conversions [[conv.qual]]
+are performed to bring them to their composite pointer type
+[[expr.type]]. After conversions, the operands shall have the same type.
+The result of comparing unequal pointers to objects[^27]
 is defined in terms of a partial order consistent with the following
 rules:
 - If two pointers point to different elements of the same array, or to
 `p>q`, `q<=p`, and `q<p` all yield `true` and `p<=q`, `p<q`, `q>=p`, and
 `q>p` all yield `false`. Otherwise, the result of each of the operators
 is unspecified.
 [*Note 1*: A relational operator applied to unequal function pointers
+yields an unspecified result. A pointer value of type “pointer to
+cv `void`” can point to an object [[basic.compound]]. — *end note*]
 If both operands (after conversions) are of arithmetic or enumeration
 type, each of the operators shall yield `true` if the specified
 relationship is true and `false` if it is false.
     equality-expression '==' relational-expression
     equality-expression '!=' relational-expression
 ```
 The `==` (equal to) and the `!=` (not equal to) operators group
+left-to-right. The lvalue-to-rvalue [[conv.lval]] and
+function-to-pointer [[conv.func]] standard conversions are performed on
+the operands. If one of the operands is a pointer or a null pointer
+constant [[conv.ptr]], the array-to-pointer conversion [[conv.array]] is
+performed on the other operand.
+The converted operands shall have scalar type. 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.
+If at least one of the converted operands is a pointer, pointer
+conversions [[conv.ptr]], function pointer conversions [[conv.fctptr]],
+and qualification conversions [[conv.qual]] are performed on both
+operands to bring them to their composite pointer type [[expr.type]].
+Comparing pointers is defined as follows:
 - If one pointer represents the address of a complete object, and
   another pointer represents the address one past the last element of a
+  different complete object,[^28] the result of the comparison is
   unspecified.
 - Otherwise, if the pointers are both null, both point to the same
   function, or both represent the same address [[basic.compound]], they
   compare equal.
 - Otherwise, the pointers compare unequal.
   — *end example*]
 Two operands of type `std::nullptr_t` or one operand of type
 `std::nullptr_t` and the other a null pointer constant compare equal.
+If both operands are of type `std::meta::info`, they compare equal if
+both operands
+- are null reflection values,
+- represent values that are template-argument-equivalent [[temp.type]],
+- represent the same object,
+- represent the same entity,
+- represent the same annotation [[dcl.attr.annotation]],
+- represent the same direct base class relationship, or
+- represent equal data member descriptions [[class.mem.general]],
+and they compare unequal otherwise.
 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.
   but an implicit conversion sequence can only be formed if the
   reference would bind directly.
 - If `E2` is a prvalue or if neither of the conversion sequences above
   can be formed and at least one of the operands has (possibly
   cv-qualified) class type:
+  - if `T1` and `T2` are the same class type (ignoring
+    cv-qualification):
+    - if `T2` is at least as cv-qualified as `T1`, the target type is
       `T2`,
+    - otherwise, no conversion sequence is formed for this operand;
   - otherwise, if `T2` is a base class of `T1`, the target type is *cv1*
+    `T2`, where *cv1* denotes the cv-qualifiers of `T1`;
   - otherwise, the target type is the type that `E2` would have after
     applying the lvalue-to-rvalue [[conv.lval]], array-to-pointer
     [[conv.array]], and function-to-pointer [[conv.func]] standard
     conversions.
 Using this process, it is determined whether an implicit conversion
 sequence can be formed from the second operand to the target type
+determined for the third operand, and vice versa, with the following
+outcome:
+- If both sequences can be formed, or one can be formed but it is the
+  ambiguous conversion sequence, the program is ill-formed.
+- If no conversion sequence can be formed, the operands are left
+  unchanged and further checking is performed as described below.
+- Otherwise, if exactly one conversion sequence can be formed, that
+  conversion is applied to the chosen operand and the converted operand
+  is used in place of the original operand for the remainder of this
+  subclause. \[*Note 3*: The conversion might be ill-formed even if an
+  implicit conversion sequence could be formed. — *end note*]
 If the second and third operands are glvalues of the same value category
 and have the same type, the result is of that type and value category
 and it is a bit-field if the second or the third operand is a bit-field,
 or if both are bit-fields.
 the overload resolution fails, the program is ill-formed. Otherwise, the
 conversions thus determined are applied, and the converted operands are
 used in place of the original operands for the remainder of this
 subclause.
+Array-to-pointer [[conv.array]] and function-to-pointer [[conv.func]]
+standard conversions are performed on the second and third operands.
+After those conversions, one of the following shall hold:
 - The second and third operands have the same type; the result is of
+  that type and the result is copy-initialized using the selected
   operand.
 - The second and third operands have arithmetic or enumeration type; the
   usual arithmetic conversions [[expr.arith.conv]] are performed to
   bring them to a common type, and the result is of that type.
 - One or both of the second and third operands have pointer type;
+ lvalue-to-rvalue [[conv.lval]], pointer [[conv.ptr]], function pointer
   [[conv.fctptr]], and qualification conversions [[conv.qual]] are
   performed to bring them to their composite pointer type [[expr.type]].
   The result is of the composite pointer type.
 - One or both of the second and third operands have pointer-to-member
+  type; lvalue-to-rvalue [[conv.lval]], pointer to member [[conv.mem]],
+ function pointer [[conv.fctptr]], and qualification conversions
   [[conv.qual]] are performed to bring them to their composite pointer
   type [[expr.type]]. The result is of the composite pointer type.
 - Both the second and third operands have type `std::nullptr_t` or one
   has that type and the other is a null pointer constant. The result is
   of type `std::nullptr_t`.
 ### Yielding a value <a id="expr.yield">[[expr.yield]]</a>
 ``` bnf
 yield-expression:
+  co_yield assignment-expression
+  co_yield braced-init-list
 ```
 A *yield-expression* shall appear only within a suspension context of a
 function [[expr.await]]. Let *e* be the operand of the
 *yield-expression* and *p* be an lvalue naming the promise object of the
     throw assignment-expressionₒₚₜ
 ```
 A *throw-expression* is of type `void`.
+A *throw-expression* with an operand throws an exception
+[[except.throw]]. The array-to-pointer [[conv.array]] and
+function-to-pointer [[conv.func]] standard conversions are performed on
+the operand. The type of the exception object is determined by removing
+any top-level *cv-qualifier*s from the type of the (possibly converted)
+operand. The exception object is copy-initialized [[dcl.init.general]]
+from the (possibly converted) operand.
 A *throw-expression* with no operand rethrows the currently handled
+exception [[except.handle]]. If no exception is presently being handled,
+the function `std::terminate` is invoked [[except.terminate]].
+Otherwise, the exception is reactivated with the existing exception
+object; no new exception object is created. The exception is no longer
+considered to be caught.
 [*Example 1*:
 An exception handler that cannot completely handle the exception itself
 can be written like this:
 }
 ```
 — *end example*]
+### Assignment and compound assignment operators <a id="expr.assign">[[expr.assign]]</a>
 The assignment operator (`=`) and the compound assignment operators all
 group right-to-left. All require a modifiable lvalue as their left
 operand; their result is an lvalue of the type of the left operand,
 referring to the left operand. The result in all cases is a bit-field if
 ``` bnf
 assignment-operator: one of
     '= *= /= %= += -= >>= <<= &= ^= |='
 ```
+In simple assignment (`=`), let `V` be the result of the right operand;
+the object referred to by the left operand is modified [[defns.access]]
+by replacing its value with `V` or, if the object is of integer type,
+with the value congruent [[basic.fundamental]] to `V`.
 If the right operand is an expression, it is implicitly converted
 [[conv]] to the cv-unqualified type of the left operand.
 When the left operand of an assignment operator is a bit-field that
 [*Note 3*: This restriction applies to the relationship between the
 left and right sides of the assignment operation; it is not a statement
 about how the target of the assignment can be aliased in general. See
 [[basic.lval]]. — *end note*]
+A *braced-init-list* B may appear on the right-hand side of
+- an assignment to a scalar of type `T`, in which case B shall have at
+  most a single element. The meaning of `x = B` is `x = t`, where `t` is
+ an invented temporary variable declared and initialized as `T t = B`.
+- an assignment to an object of class type, in which case B is passed as
+  the argument to the assignment operator function selected by overload
+ resolution [[over.assign]], [[over.match]].
 [*Example 1*:
 ``` cpp
 complex<double> z;
 Certain contexts require expressions that satisfy additional
 requirements as detailed in this subclause; other contexts have
 different semantics depending on whether or not an expression satisfies
 these requirements. Expressions that satisfy these requirements,
 assuming that copy elision [[class.copy.elision]] is not performed, are
+called constant expressions.
 [*Note 1*: Constant expressions can be evaluated during
 translation. — *end note*]
 ``` bnf
 constant-expression:
     conditional-expression
 ```
+The *constituent values* of an object o are
+- if o has scalar type, the value of o;
+- otherwise, the constituent values of any direct subobjects of o other
+  than inactive union members.
+The *constituent references* of an object o are
+- any direct members of o that have reference type, and
+- the constituent references of any direct subobjects of o other than
+  inactive union members.
+The constituent values and constituent references of a variable `x` are
+defined as follows:
+- If `x` declares an object, the constituent values and references of
+  that object are constituent values and references of `x`.
+- If `x` declares a reference, that reference is a constituent reference
+  of `x`.
+For any constituent reference `r` of a variable `x`, if `r` is bound to
+a temporary object or subobject thereof whose lifetime is extended to
+that of `r`, the constituent values and references of that temporary
+object are also constituent values and references of `x`, recursively.
+An object o is *constexpr-referenceable* from a point P if
+- o has static storage duration, or
+- o has automatic storage duration, and, letting `v` denote
+  - the variable corresponding to o’s complete object or
+  - the variable to whose lifetime that of o is extended,
+  the smallest scope enclosing `v` and the smallest scope enclosing P
+  that are neither
+  - block scopes nor
+  - function parameter scopes associated with a
+    *requirement-parameter-list*
+  are the same function parameter scope.
+[*Example 1*:
+``` cpp
+struct A {
+  int m;
+  const int& r;
+};
+void f() {
+  static int sx;
+  thread_local int tx;                  // tx is never constexpr-referenceable
+  int ax;
+  A aa = {1, 2};
+  static A sa = {3, 4};
+  // The objects sx, ax, and aa.m, sa.m, and the temporaries to which aa.r and sa.r are bound, are constexpr-referenceable.
+  auto lambda = [] {
+    int ay;
+    // The objects sx, sa.m, and ay (but not ax or aa), and the
+    // temporary to which sa.r is bound, are constexpr-referenceable.
+  };
+}
+```
+— *end example*]
+An object or reference `x` is *constexpr-representable* at a point P if,
+for each constituent value of `x` that points to or past an object o,
+and for each constituent reference of `x` that refers to an object o, o
+is constexpr-referenceable from P.
+A variable `v` is *constant-initializable* if
 - the full-expression of its initialization is a constant expression
+  when interpreted as a *constant-expression* with all contract
+ assertions using the ignore evaluation semantic
+ [[basic.contract.eval]], \[*Note 2*: Within this evaluation,
+ `std::is_constant_evaluated()` [[meta.const.eval]] returns
+ `true`. — *end note*] \[*Note 3*: The initialization, when evaluated,
+ can still evaluate contract assertions with other evaluation
+  semantics, resulting in a diagnostic or ill-formed program if a
+  contract violation occurs. — *end note*]
+- immediately after the initializing declaration of `v`, the object or
+  reference `x` declared by `v` is constexpr-representable, and
+- if `x` has static or thread storage duration, `x` is
+  constexpr-representable at the nearest point whose immediate scope is
+  a namespace scope that follows the initializing declaration of `v`.
+A constant-initializable variable is *constant-initialized* if either it
+has an initializer or its type is const-default-constructible
+[[dcl.init.general]].
+[*Example 2*:
+``` cpp
+void f() {
+  int ax = 0;                   // ax is constant-initialized
+  thread_local int tx = 0;      // tx is constant-initialized
+  static int sx;                // sx is not constant-initialized
+  static int& rss = sx;         // rss is constant-initialized
+  static int& rst = tx;         // rst is not constant-initialized
+  static int& rsa = ax;         // rsa is not constant-initialized
+  thread_local int& rts = sx;   // rts is constant-initialized
+  thread_local int& rtt = tx;   // rtt is not constant-initialized
+  thread_local int& rta = ax;   // rta is not constant-initialized
+  int& ras = sx;                // ras is constant-initialized
+  int& rat = tx;                // rat is not constant-initialized
+  int& raa = ax;                // raa is constant-initialized
+}
+```
+— *end example*]
 A variable is *potentially-constant* if it is constexpr or it has
 reference or non-volatile const-qualified integral or enumeration type.
 A constant-initialized potentially-constant variable V is *usable in
 - V is constexpr,
 - V is not initialized to a TU-local value, or
 - P is in the same translation unit as D.
+An object or reference is *potentially usable in constant expressions*
+at point P if it is
+- the object or reference declared by a variable that is usable in
+  constant expressions at P,
 - a temporary object of non-volatile const-qualified literal type whose
   lifetime is extended [[class.temporary]] to that of a variable that is
+  usable in constant expressions at P,
+- a template parameter object [[temp.param]],
+- a string literal object [[lex.string]],
+- a non-mutable subobject of any of the above, or
+- a reference member of any of the above.
+An object or reference is *usable in constant expressions* at point P if
+it is an object or reference that is potentially usable in constant
+expressions at P and is constexpr-representable at P.
+[*Example 3*:
+``` cpp
+struct A {
+  int* const & r;
+};
+void f(int x) {
+  constexpr A a = {&x};
+  static_assert(a.r == &x);             // OK
+  [&] {
+    static_assert(a.r != nullptr);      // error: a.r is not usable in constant expressions at this point
+  }();
+}
+```
+— *end example*]
 An expression E is a *core constant expression* unless the evaluation of
 E, following the rules of the abstract machine [[intro.execution]],
 would evaluate one of the following:
 - `this` [[expr.prim.this]], except
   - in a constexpr function [[dcl.constexpr]] that is being evaluated as
     part of E or
   - when appearing as the *postfix-expression* of an implicit or
     explicit class member access expression [[expr.ref]];
+- a control flow that passes through a declaration of a block variable
+  [[basic.scope.block]] with static [[basic.stc.static]] or thread
+ [[basic.stc.thread]] storage duration, unless that variable is usable
+ in constant expressions;
+  \[*Example 4*:
   ``` cpp
   constexpr char test() {
     static const int x = 5;
     static constexpr char c[] = "Hello World";
     return *(c + x);
   }
   static_assert(' ' == test());
   ```
   — *end example*]
+- an invocation of a non-constexpr function;[^29]
 - an invocation of an undefined constexpr function;
 - an invocation of an instantiated constexpr function that is not
   constexpr-suitable;
 - an invocation of a virtual function [[class.virtual]] for an object
   whose dynamic type is constexpr-unknown;
 - an expression that would exceed the implementation-defined limits (see
   [[implimits]]);
+- an operation that would have undefined or erroneous behavior as
+ specified in [[intro]] through [[\lastcorechapter]];[^30]
 - an lvalue-to-rvalue conversion [[conv.lval]] unless it is applied to
+  - a glvalue of type cv `std::nullptr_t`,
   - a non-volatile glvalue that refers to an object that is usable in
     constant expressions, or
   - a non-volatile glvalue of literal type that refers to a non-volatile
     object whose lifetime began within the evaluation of E;
 - an lvalue-to-rvalue conversion that is applied to a glvalue that
   evaluation of E;
 - in a *lambda-expression*, a reference to `this` or to a variable with
   automatic storage duration defined outside that *lambda-expression*,
   where the reference would be an odr-use
   [[term.odr.use]], [[expr.prim.lambda]];
+  \[*Example 5*:
   ``` cpp
   void g() {
     const int n = 0;
     [=] {
       constexpr int i = n;        // OK, n is not odr-used here
     };
   }
   ```
   — *end example*]
+  \[*Note 4*:
   If the odr-use occurs in an invocation of a function call operator of
   a closure type, it no longer refers to `this` or to an enclosing
+ variable with automatic storage duration due to the transformation
   [[expr.prim.lambda.capture]] of the *id-expression* into an access of
   the corresponding data member.
+  \[*Example 6*:
   ``` cpp
   auto monad = [](auto v) { return [=] { return v; }; };
   auto bind = [](auto m) {
     return [=](auto fvm) { return fvm(m()); };
   };
   static_assert(bind(monad(2))(monad)() == monad(2)());
   ```
   — *end example*]
   — *end note*]
+- a conversion from a prvalue `P` of type “pointer to cv `void`” to a
+  type “*cv1* pointer to `T`”, where `T` is not *cv2* `void`, unless `P`
+  is a null pointer value or points to an object whose type is similar
+  to `T`;
 - a `reinterpret_cast` [[expr.reinterpret.cast]];
 - a modification of an object
+  [[expr.assign]], [[expr.post.incr]], [[expr.pre.incr]] unless it is
   applied to a non-volatile lvalue of literal type that refers to a
   non-volatile object whose lifetime began within the evaluation of E;
 - an invocation of a destructor [[class.dtor]] or a function call whose
   *postfix-expression* names a pseudo-destructor [[expr.call]], in
   either case for an object whose lifetime did not begin within the
   evaluation of E;
+- a *new-expression* [[expr.new]], unless either
+ - the selected allocation function is a replaceable global allocation
+    function [[new.delete.single]], [[new.delete.array]] and the
+    allocated storage is deallocated within the evaluation of E, or
+  - the selected allocation function is a non-allocating form
+    [[new.delete.placement]] with an allocated type `T`, where
+    - the placement argument to the *new-expression* points to an object
+      whose type is similar to `T` [[conv.qual]] or, if `T` is an array
+      type, to the first element of an object of a type similar to `T`,
+      and
+    - the placement argument points to storage whose duration began
+      within the evaluation of E;
 - a *delete-expression* [[expr.delete]], unless it deallocates a region
   of storage allocated within the evaluation of E;
 - a call to an instance of `std::allocator<T>::allocate`
   [[allocator.members]], unless the allocated storage is deallocated
   within the evaluation of E;
 - a call to an instance of `std::allocator<T>::deallocate`
   [[allocator.members]], unless it deallocates a region of storage
   allocated within the evaluation of E;
+- a construction of an exception object, unless the exception object and
+  all of its implicit copies created by invocations of
+  `std::current_exception` or `std::rethrow_exception` [[propagation]]
+  are destroyed within the evaluation of E;
 - an *await-expression* [[expr.await]];
 - a *yield-expression* [[expr.yield]];
 - a three-way comparison [[expr.spaceship]], relational [[expr.rel]], or
   equality [[expr.eq]] operator where the result is unspecified;
 - a `dynamic_cast` [[expr.dynamic.cast]] or `typeid` [[expr.typeid]]
   expression on a glvalue that refers to an object whose dynamic type is
+  constexpr-unknown;
+- a `dynamic_cast` [[expr.dynamic.cast]] expression, `typeid`
+  [[expr.typeid]] expression, or `new-expression` [[expr.new]] that
+  would throw an exception where no definition of the exception type is
+  reachable;
+- an expression that would produce an injected declaration (see below),
+  unless E is the corresponding expression of a
+  *consteval-block-declaration* [[dcl.pre]];
 - an *asm-declaration* [[dcl.asm]];
 - an invocation of the `va_arg` macro [[cstdarg.syn]];
 - a non-constant library call [[defns.nonconst.libcall]]; or
+- a `goto` statement [[stmt.goto]]. \[*Note 5*: A `goto` statement
+  introduced by equivalence [[stmt]] is not in scope. For example, a
+  `while` statement [[stmt.while]] can be executed during constant
+  evaluation. — *end note*]
+It is *implementation-defined* whether E is a core constant expression
+if E satisfies the constraints of a core constant expression, but
+evaluation of E has runtime-undefined behavior.
 It is unspecified whether E is a core constant expression if E satisfies
 the constraints of a core constant expression, but evaluation of E would
 evaluate
 - an operation that has undefined behavior as specified in [[library]]
+  through [[exec]] or
+- an invocation of the `va_start` macro [[cstdarg.syn]].
+[*Example 7*:
 ``` cpp
 int x;                              // not constant
 struct A {
   constexpr A(bool b) : m(b?42:x) { }
 — *end example*]
 For the purposes of determining whether an expression E is a core
 constant expression, the evaluation of the body of a member function of
 `std::allocator<T>` as defined in [[allocator.members]], where `T` is a
+literal type, is ignored.
 For the purposes of determining whether E is a core constant expression,
 the evaluation of a call to a trivial copy/move constructor or copy/move
 assignment operator of a union is considered to copy/move the active
 member of the union, if any.
+[*Note 6*: The copy/move of the active member is
 trivial. — *end note*]
+For the purposes of determining whether E is a core constant expression,
+the evaluation of an *id-expression* that names a structured binding `v`
+[[dcl.struct.bind]] has the following semantics:
+- If `v` is an lvalue referring to the object bound to an invented
+  reference `r`, the behavior is as if `r` were nominated.
+- Otherwise, if `v` names an array element or class member, the behavior
+  is that of evaluating `e[i]` or `e.m`, respectively, where e is the
+  name of the variable initialized from the initializer of the
+  structured binding declaration, and i is the index of the element
+  referred to by `v` or m is the name of the member referred to by `v`,
+  respectively.
+[*Example 8*:
+``` cpp
+#include <tuple>
+struct S {
+  mutable int m;
+  constexpr S(int m): m(m) {}
+  virtual int g() const;
+};
+void f(std::tuple<S&> t) {
+  auto [r] = t;
+  static_assert(r.g() >= 0);            // error: dynamic type is constexpr-unknown
+  constexpr auto [m] = S(1);
+  static_assert(m == 1);                // error: lvalue-to-rvalue conversion on mutable
+                                        // subobject e.m, where e is a constexpr object of type S
+  using A = int[2];
+  constexpr auto [v0, v1] = A{2, 3};
+  static_assert(v0 + v1 == 5);          // OK, equivalent to e[0] + e[1] where e is a constexpr array
+}
+```
+— *end example*]
 During the evaluation of an expression E as a core constant expression,
+all *id-expression*s, *splice-expression*s, and uses of `*this` that
+refer to an object or reference whose lifetime did not begin with the
+evaluation of E are treated as referring to a specific instance of that
+object or reference whose lifetime and that of all subobjects (including
+all union members) includes the entire constant evaluation. For such an
+object that is not usable in constant expressions, the dynamic type of
+the object is *constexpr-unknown*. For such a reference that is not
+usable in constant expressions, the reference is treated as binding to
+an unspecified object of the referenced type whose lifetime and that of
+all subobjects includes the entire constant evaluation and whose dynamic
+type is constexpr-unknown.
+[*Example 9*:
 ``` cpp
 template <typename T, size_t N>
 constexpr size_t array_size(T (&)[N]) {
   return N;
 constexpr auto& gallagher = typeid(trident);    // error: constexpr-unknown dynamic type
 ```
 — *end example*]
+An object `a` is said to have *constant destruction* if
 - it is not of class type nor (possibly multidimensional) array thereof,
   or
 - it is of class type or (possibly multidimensional) array thereof, that
+  class type has a constexpr destructor [[dcl.constexpr]], and for a
+ hypothetical expression E whose only effect is to destroy `a`, E would
+ be a core constant expression if the lifetime of `a` and its
+ non-mutable subobjects (but not its mutable subobjects) were
+ considered to start within E.
 An *integral constant expression* is an expression of integral or
 unscoped enumeration type, implicitly converted to a prvalue, where the
 converted expression is a core constant expression.
+[*Note 7*: Such expressions can be used as bit-field lengths
 [[class.bit]], as enumerator initializers if the underlying type is not
 fixed [[dcl.enum]], and as alignments [[dcl.align]]. — *end note*]
 If an expression of literal class type is used in a context where an
 integral constant expression is required, then that expression is
 contextually implicitly converted [[conv]] to an integral or unscoped
 enumeration type and the selected conversion function shall be
 `constexpr`.
+[*Example 10*:
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
   constexpr operator int() const { return val; }
 - function-to-pointer conversions [[conv.func]],
 - qualification conversions [[conv.qual]],
 - integral promotions [[conv.prom]],
 - integral conversions [[conv.integral]] other than narrowing
   conversions [[dcl.init.list]],
+- floating-point promotions [[conv.fpprom]],
+- floating-point conversions [[conv.double]] where the source value can
+  be represented exactly in the destination type,
 - null pointer conversions [[conv.ptr]] from `std::nullptr_t`,
 - null member pointer conversions [[conv.mem]] from `std::nullptr_t`,
   and
 - function pointer conversions [[conv.fctptr]],
 and where the reference binding (if any) binds directly.
+[*Note 8*: Such expressions can be used in `new` expressions
 [[expr.new]], as case expressions [[stmt.switch]], as enumerator
 initializers if the underlying type is fixed [[dcl.enum]], as array
+bounds [[dcl.array]], as constant template arguments [[temp.arg]], and
+as the constant expression of a *splice-specifier*
+[[basic.splice]]. — *end note*]
 A *contextually converted constant expression of type `bool`* is an
 expression, contextually converted to `bool` [[conv]], where the
 converted expression is a constant expression and the conversion
 sequence contains only the conversions above.
+A *constant expression* is either
+- a glvalue core constant expression E for which
+ - E refers to a non-immediate function,
+ - E designates an object `o`, and if the complete object of `o` is of
+    consteval-only type then so is E,
+    \[*Example 11*:
+    ``` cpp
+    struct Base { };
+    struct Derived : Base { std::meta::info r; };
+    consteval const Base& fn(const Derived& derived) { return derived; }
+    constexpr Derived obj{.r=^^::};     // OK
+    constexpr const Derived& d = obj;   // OK
+    constexpr const Base& b = fn(obj);  // error: not a constant expression because Derived
+                                        // is a consteval-only type but Base is not.
+    ```
+    — *end example*]
+  or
+- a prvalue core constant expression whose result object [[basic.lval]]
+  satisfies the following constraints:
+  - each constituent reference refers to an object or a non-immediate
+    function,
+  - no constituent value of scalar type is an indeterminate or erroneous
+    value [[basic.indet]],
+  - no constituent value of pointer type is a pointer to an immediate
+    function or an invalid pointer value [[basic.compound]],
+  - no constituent value of pointer-to-member type designates an
+    immediate function, and
+  - unless the value is of consteval-only type,
+    - no constituent value of pointer-to-member type points to a direct
+      member of a consteval-only class type,
+    - no constituent value of pointer type points to or past an object
+      whose complete object is of consteval-only type, and
+    - no constituent reference refers to an object whose complete object
+      is of consteval-only type.
+[*Note 9*: A glvalue core constant expression that either refers to or
 points to an unspecified object is not a constant
 expression. — *end note*]
+[*Example 12*:
 ``` cpp
 consteval int f() { return 42; }
 consteval auto g() { return f; }
 consteval int h(int (*p)() = g()) { return p(); }
 constexpr int r = h();                          // OK
 constexpr auto e = g();                         // error: a pointer to an immediate function is
                                                 // not a permitted result of a constant expression
+struct S {
+  int x;
+  constexpr S() {}
+};
+int i() {
+  constexpr S s;                                // error: s.x has erroneous value
+}
 ```
 — *end example*]
 *Recommended practice:* Implementations should provide consistent
 results of floating-point evaluations, irrespective of whether the
 evaluation is performed during translation or during program execution.
+[*Note 10*:
 Since this document imposes no restrictions on the accuracy of
 floating-point operations, it is unspecified whether the evaluation of a
 floating-point expression during translation yields the same result as
 the evaluation of the same expression (or the same operations on the
 same values) during program execution.
+[*Example 13*:
 ``` cpp
 bool f() {
     char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Must be evaluated during translation
     int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // May be evaluated at runtime
 function and is not in an immediate function context. An aggregate
 initialization is an immediate invocation if it evaluates a default
 member initializer that has a subexpression that is an
 immediate-escalating expression.
+A potentially-evaluated expression or conversion is
+*immediate-escalating* if it is neither initially in an immediate
+function context nor a subexpression of an immediate invocation, and
+- it is an *id-expression* or *splice-expression* that designates an
+  immediate function,
+- it is an immediate invocation that is not a constant expression, or
+- it is of consteval-only type [[basic.types.general]].
 An *immediate-escalating* function is
 - the call operator of a lambda that is not declared with the
   `consteval` specifier,
   defined with the `constexpr` specifier.
 An immediate-escalating expression shall appear only in an
 immediate-escalating function.
+An *immediate function* is a function that is either
 - declared with the `consteval` specifier, or
+- an immediate-escalating function `F` whose function body contains
+ either
+  - an immediate-escalating expression or
+  - a definition of a non-constexpr variable with consteval-only type
+  whose innermost enclosing non-block scope is `F`’s function parameter
+  scope.
+[*Example 14*:
 ``` cpp
 consteval int id(int i) { return i; }
 constexpr char id(char c) { return c; }
 int x = 0;
 template<class T>
 constexpr T h(T t = id(x)) {    // h<int> is not an immediate function
+                                // id(x) is not evaluated when parsing the default argument[dcl.fct.default,temp.inst]
     return t;
 }
 template<class T>
+constexpr T hh() {              // hh<int> is an immediate function because of the invocation
+  return h<T>();                // of the immediate function id in the default argument of h<int>
 }
 int i = hh<int>();              // error: hh<int>() is an immediate-escalating expression
                                 // outside of an immediate-escalating function
 template<class T>
 constexpr int k(int) {          // k<int> is not an immediate function because A(42) is a
   return A(42).y;               // constant expression and thus not immediate-escalating
 }
+constexpr int l(int c) pre(c >= 2) {
+  return (c % 2 == 0) ? c / 0 : c;
+}
+const int i0 = l(0);    // dynamic initialization; contract violation or undefined behavior
+const int i1 = l(1);    // static initialization; value of 1 or contract violation at compile time
+const int i2 = l(2);    // dynamic initialization; undefined behavior
+const int i3 = l(3);    // static initialization; value of 3
 ```
 — *end example*]
 An expression or conversion is *manifestly constant-evaluated* if it is:
 - the condition of a constexpr if statement [[stmt.if]], or
 - an immediate invocation, or
 - the result of substitution into an atomic constraint expression to
   determine whether it is satisfied [[temp.constr.atomic]], or
 - the initializer of a variable that is usable in constant expressions
+  or has constant initialization [[basic.start.static]].[^31]
+  \[*Example 15*:
   ``` cpp
   template<bool> struct X {};
   X<std::is_constant_evaluated()> x;                      // type X<true>
   int y;
   const int a = std::is_constant_evaluated() ? y : 1;     // dynamic initialization to 1
   int q = p + f();                                        // m is 17 for this call; initialized to 56
   ```
   — *end example*]
+[*Note 11*: Except for a *static_assert-message*, a manifestly
+constant-evaluated expression is evaluated even in an unevaluated
+operand [[term.unevaluated.operand]]. — *end note*]
+The evaluation of an expression can introduce one or more *injected
+declarations*. The evaluation is said to *produce* the declarations.
+[*Note 12*: An invocation of the library function template
+`std::meta::define_aggregate` produces an injected declaration
+[[meta.reflection.define.aggregate]]. — *end note*]
+Each such declaration has
+- an associated *synthesized point*, which follows the last
+  non-synthesized program point in the translation unit containing that
+  declaration, and
+- an associated *characteristic sequence* of values.
+[*Note 13*: Special rules concerning reachability apply to synthesized
+points [[module.reach]]. — *end note*]
+[*Note 14*: The program is ill-formed if injected declarations with
+different characteristic sequences define the same entity in different
+translation units [[basic.def.odr]]. — *end note*]
+A member of an entity defined by an injected declaration shall not have
+a name reserved to the implementation [[lex.name]]; no diagnostic is
+required.
+Let C be a *consteval-block-declaration*, the evaluation of whose
+corresponding expression produces an injected declaration for an entity
+E. The program is ill-formed if either
+- C is enclosed by a scope associated with E or
+- letting P be a point whose immediate scope is that to which E belongs,
+  there is a function parameter scope or class scope that encloses
+  exactly one of C or P.
+[*Example 16*:
+``` cpp
+struct S0 {
+  consteval {
+    std::meta::define_aggregate(^^S0, {});  // error: scope associated with S0 encloses the consteval block
+  }
+};
+struct S1;
+consteval { std::meta::define_aggregate(^^S1, {}); }    // OK
+template <std::meta::info R> consteval void tfn1() {
+  std::meta::define_aggregate(R, {});
+}
+struct S2;
+consteval { tfn1<^^S2>(); }                             // OK
+template <std::meta::info R> consteval void tfn2() {
+  consteval { std::meta::define_aggregate(R, {}); }
+}
+struct S3;
+consteval { tfn2<^^S3>(); }
+  // error: function parameter scope of tfn2<^^ S3> intervenes between the declaration of S3
+  // and the consteval block that produces the injected declaration
+template <typename> struct TCls {
+  struct S4;
+  static void sfn() requires ([] {
+    consteval { std::meta::define_aggregate(^^S4, {}); }
+    return true;
+  }()) { }
+};
+consteval { TCls<void>::sfn(); }    // error: TCls<void>::S4 is not enclosed by requires-clause lambda
+struct S5;
+struct Cls {
+  consteval { std::meta::define_aggregate(^^S5, {}); }  // error: S5 is not enclosed by class Cls
+};
+struct S6;
+consteval {                                 // #1
+  struct S7;                                // local class
+  std::meta::define_aggregate(^^S7, {});    // error: consteval block #1 does not enclose itself,
+                                            // but encloses S7
+  struct S8;                                // local class
+  consteval {                               // #2
+    std::meta::define_aggregate(^^S6, {});  // error: consteval block #1 encloses
+                                            // consteval block #2 but not S6
+    std::meta::define_aggregate(^^S8, {});  // OK, consteval block #1 encloses both #2 and S8
+  }
+}
+```
+— *end example*]
+The *evaluation context* is a set of program points that determines the
+behavior of certain functions used for reflection [[meta.reflection]].
+During the evaluation V of an expression E as a core constant
+expression, the evaluation context of an evaluation X
+[[intro.execution]] consists of the following points:
+- The program point EVAL-PT(L), where L is the point at which E appears,
+  and where EVAL-PT(P), for a point P, is a point R determined as
+  follows:
+  - If a potentially-evaluated subexpression [[intro.execution]] of a
+    default member initializer I appears at P, and a (possibly
+    aggregate) initialization during V is using I, then R is EVAL-PT(Q)
+    where Q is the point at which that initialization appears.
+  - Otherwise, if a potentially-evaluated subexpression of a default
+    argument [[dcl.fct.default]] appears at P, and an invocation of a
+    function [[expr.call]] during V is using that default argument, then
+    R is EVAL-PT(Q) where Q is the point at which that invocation
+    appears.
+  - Otherwise, R is P.
+- Each synthesized point corresponding to an injected declaration
+  produced by any evaluation sequenced before X [[intro.execution]].
 An expression or conversion is *potentially constant evaluated* if it
 is:
 - a manifestly constant-evaluated expression,
 - a potentially-evaluated expression [[basic.def.odr]],
+- an immediate subexpression of a *braced-init-list*,[^32]
 - an expression of the form `&` *cast-expression* that occurs within a
+  templated entity,[^33] or
 - a potentially-evaluated subexpression [[intro.execution]] of one of
   the above.
 A function or variable is *needed for constant evaluation* if it is:
   that is potentially constant evaluated, or
 - a potentially-constant variable named by a potentially constant
   evaluated expression.
 <!-- Link reference definitions -->
+[\lastcorechapter]: #\lastcorechapter
 [allocator.members]: mem.md#allocator.members
 [bad.alloc]: support.md#bad.alloc
 [bad.cast]: support.md#bad.cast
 [bad.typeid]: support.md#bad.typeid
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
+[basic.contract]: basic.md#basic.contract
+[basic.contract.eval]: basic.md#basic.contract.eval
+[basic.contract.general]: basic.md#basic.contract.general
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.indet]: basic.md#basic.indet
 [basic.life]: basic.md#basic.life
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.general]: basic.md#basic.lookup.general
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: #basic.lval
+[basic.namespace]: dcl.md#basic.namespace
 [basic.pre]: basic.md#basic.pre
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.class]: basic.md#basic.scope.class
+[basic.scope.contract]: basic.md#basic.scope.contract
 [basic.scope.lambda]: basic.md#basic.scope.lambda
+[basic.splice]: basic.md#basic.splice
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.static]: basic.md#basic.start.static
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
+[basic.types.general]: basic.md#basic.types.general
 [class]: class.md#class
 [class.abstract]: class.md#class.abstract
 [class.access]: class.md#class.access
 [class.access.base]: class.md#class.access.base
+[class.access.general]: class.md#class.access.general
 [class.base.init]: class.md#class.base.init
 [class.bit]: class.md#class.bit
 [class.cdtor]: class.md#class.cdtor
 [class.conv]: class.md#class.conv
 [class.conv.fct]: class.md#class.conv.fct
 [class.derived]: class.md#class.derived
 [class.dtor]: class.md#class.dtor
 [class.free]: class.md#class.free
 [class.friend]: class.md#class.friend
 [class.mem]: class.md#class.mem
+[class.mem.general]: class.md#class.mem.general
 [class.member.lookup]: basic.md#class.member.lookup
 [class.mfct.non.static]: class.md#class.mfct.non.static
 [class.mi]: class.md#class.mi
+[class.pre]: class.md#class.pre
 [class.prop]: class.md#class.prop
 [class.spaceship]: class.md#class.spaceship
 [class.static.mfct]: class.md#class.static.mfct
 [class.temporary]: basic.md#class.temporary
 [class.union]: class.md#class.union
 [conv.prom]: #conv.prom
 [conv.ptr]: #conv.ptr
 [conv.qual]: #conv.qual
 [conv.rank]: basic.md#conv.rank
 [conv.rval]: #conv.rval
 [cstdarg.syn]: support.md#cstdarg.syn
 [cstddef.syn]: support.md#cstddef.syn
+[dcl]: dcl.md#dcl
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
 [dcl.asm]: dcl.md#dcl.asm
+[dcl.attr.annotation]: dcl.md#dcl.attr.annotation
 [dcl.constexpr]: dcl.md#dcl.constexpr
+[dcl.contract.func]: dcl.md#dcl.contract.func
+[dcl.contract.res]: dcl.md#dcl.contract.res
 [dcl.decl]: dcl.md#dcl.decl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
+[dcl.init.general]: dcl.md#dcl.init.general
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.init.string]: dcl.md#dcl.init.string
 [dcl.link]: dcl.md#dcl.link
 [dcl.mptr]: dcl.md#dcl.mptr
 [dcl.name]: dcl.md#dcl.name
+[dcl.pre]: dcl.md#dcl.pre
 [dcl.ptr]: dcl.md#dcl.ptr
 [dcl.ref]: dcl.md#dcl.ref
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
+[dcl.spec.auto.general]: dcl.md#dcl.spec.auto.general
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.struct.bind]: dcl.md#dcl.struct.bind
 [dcl.type]: dcl.md#dcl.type
 [dcl.type.auto.deduct]: dcl.md#dcl.type.auto.deduct
+[dcl.type.class.deduct]: dcl.md#dcl.type.class.deduct
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [dcl.type.decltype]: dcl.md#dcl.type.decltype
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [defns.access]: intro.md#defns.access
 [defns.nonconst.libcall]: intro.md#defns.nonconst.libcall
 [depr.capture.this]: future.md#depr.capture.this
 [depr.volatile.type]: future.md#depr.volatile.type
 [except]: except.md#except
+[except.ctor]: except.md#except.ctor
 [except.handle]: except.md#except.handle
 [except.pre]: except.md#except.pre
 [except.spec]: except.md#except.spec
 [except.terminate]: except.md#except.terminate
 [except.throw]: except.md#except.throw
+[exec]: exec.md#exec
 [expr]: #expr
 [expr.add]: #expr.add
 [expr.alignof]: #expr.alignof
 [expr.arith.conv]: #expr.arith.conv
+[expr.assign]: #expr.assign
 [expr.await]: #expr.await
 [expr.bit.and]: #expr.bit.and
 [expr.call]: #expr.call
 [expr.cast]: #expr.cast
 [expr.comma]: #expr.comma
 [expr.post.incr]: #expr.post.incr
 [expr.pre]: #expr.pre
 [expr.pre.incr]: #expr.pre.incr
 [expr.prim]: #expr.prim
 [expr.prim.fold]: #expr.prim.fold
+[expr.prim.grammar]: #expr.prim.grammar
 [expr.prim.id]: #expr.prim.id
 [expr.prim.id.dtor]: #expr.prim.id.dtor
 [expr.prim.id.general]: #expr.prim.id.general
 [expr.prim.id.qual]: #expr.prim.id.qual
 [expr.prim.id.unqual]: #expr.prim.id.unqual
 [expr.prim.lambda]: #expr.prim.lambda
 [expr.prim.lambda.capture]: #expr.prim.lambda.capture
 [expr.prim.lambda.closure]: #expr.prim.lambda.closure
 [expr.prim.lambda.general]: #expr.prim.lambda.general
 [expr.prim.literal]: #expr.prim.literal
+[expr.prim.pack.index]: #expr.prim.pack.index
 [expr.prim.paren]: #expr.prim.paren
 [expr.prim.req]: #expr.prim.req
 [expr.prim.req.compound]: #expr.prim.req.compound
 [expr.prim.req.general]: #expr.prim.req.general
 [expr.prim.req.nested]: #expr.prim.req.nested
 [expr.prim.req.simple]: #expr.prim.req.simple
 [expr.prim.req.type]: #expr.prim.req.type
+[expr.prim.splice]: #expr.prim.splice
 [expr.prim.this]: #expr.prim.this
 [expr.prop]: #expr.prop
 [expr.ref]: #expr.ref
+[expr.reflect]: #expr.reflect
 [expr.reinterpret.cast]: #expr.reinterpret.cast
 [expr.rel]: #expr.rel
 [expr.shift]: #expr.shift
 [expr.sizeof]: #expr.sizeof
 [expr.spaceship]: #expr.spaceship
 [intro.memory]: basic.md#intro.memory
 [intro.object]: basic.md#intro.object
 [lex.ext]: lex.md#lex.ext
 [lex.icon]: lex.md#lex.icon
 [lex.literal]: lex.md#lex.literal
+[lex.name]: lex.md#lex.name
 [lex.string]: lex.md#lex.string
 [library]: library.md#library
 [meta.const.eval]: meta.md#meta.const.eval
+[meta.reflection]: meta.md#meta.reflection
+[meta.reflection.define.aggregate]: meta.md#meta.reflection.define.aggregate
+[module.reach]: module.md#module.reach
+[namespace.alias]: dcl.md#namespace.alias
 [namespace.udecl]: dcl.md#namespace.udecl
 [new.badlength]: support.md#new.badlength
 [new.delete.array]: support.md#new.delete.array
 [new.delete.placement]: support.md#new.delete.placement
 [new.delete.single]: support.md#new.delete.single
 [over]: over.md#over
+[over.assign]: over.md#over.assign
 [over.best.ics]: over.md#over.best.ics
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
 [over.call.func]: over.md#over.call.func
 [over.ics.user]: over.md#over.ics.user
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.class.deduct]: over.md#over.match.class.deduct
+[over.match.funcs]: over.md#over.match.funcs
 [over.match.oper]: over.md#over.match.oper
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [over.sub]: over.md#over.sub
+[propagation]: support.md#propagation
 [replacement.functions]: library.md#replacement.functions
 [special]: class.md#special
 [std.modules]: library.md#std.modules
+[stmt]: stmt.md#stmt
+[stmt.contract.assert]: stmt.md#stmt.contract.assert
 [stmt.goto]: stmt.md#stmt.goto
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [stmt.switch]: stmt.md#stmt.switch
+[stmt.while]: stmt.md#stmt.while
 [support.runtime]: support.md#support.runtime
 [support.types.layout]: support.md#support.types.layout
+[temp.alias]: temp.md#temp.alias
 [temp.arg]: temp.md#temp.arg
 [temp.concept]: temp.md#temp.concept
 [temp.constr.atomic]: temp.md#temp.constr.atomic
 [temp.constr.constr]: temp.md#temp.constr.constr
 [temp.constr.decl]: temp.md#temp.constr.decl
+[temp.deduct.general]: temp.md#temp.deduct.general
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
+[temp.dep.type]: temp.md#temp.dep.type
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.mem]: temp.md#temp.mem
 [temp.names]: temp.md#temp.names
 [temp.over.link]: temp.md#temp.over.link
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
 [temp.spec.partial]: temp.md#temp.spec.partial
+[temp.type]: temp.md#temp.type
 [temp.variadic]: temp.md#temp.variadic
 [term.incomplete.type]: basic.md#term.incomplete.type
 [term.object.representation]: basic.md#term.object.representation
 [term.odr.use]: basic.md#term.odr.use
+[term.structural.type]: temp.md#term.structural.type
 [term.unevaluated.operand]: #term.unevaluated.operand
 [type.info]: support.md#type.info
 [typeinfo.syn]: support.md#typeinfo.syn
 [^1]: The precedence of operators is not directly specified, but it can
     be derived from the syntax.
 [^2]: Overloaded operators are never assumed to be associative or
     commutative.
 [^3]: The cast and assignment operators must still perform their
     specific conversions as described in  [[expr.type.conv]],
+    [[expr.cast]], [[expr.static.cast]] and  [[expr.assign]].
 [^4]: The intent of this list is to specify those circumstances in which
     an object can or cannot be aliased.
 [^5]: For historical reasons, this conversion is called the
     “lvalue-to-rvalue” conversion, even though that name does not
     accurately reflect the taxonomy of expressions described in
     [[basic.lval]].
 [^6]: In C++ class and array prvalues can have cv-qualified types. This
+    differs from C, in which non-lvalues never have cv-qualified types.
 [^7]: This conversion never applies to non-static member functions
     because an lvalue that refers to a non-static member function cannot
     be obtained.
 [^9]: As a consequence, operands of type `bool`, `char8_t`, `char16_t`,
     `char32_t`, `wchar_t`, or of enumeration type are converted to some
     integral type.
+[^10]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
+[^11]: Note that `(*(E1))` is an lvalue.
 [^12]: If the class member access expression is evaluated, the
     subexpression evaluation happens even if the result is unnecessary
     to determine the value of the entire postfix expression, for example
     if the *id-expression* denotes a static member.
+[^13]: The most derived object [[intro.object]] pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
+[^14]: The recommended name for such a class is `extended_type_info`.
+[^15]: The types can have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
+[^16]: `T1` and `T2` can have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
+[^17]: This is sometimes referred to as a type pun when the result
     refers to the same object as the source glvalue.
+[^18]: `const_cast` is not limited to conversions that cast away a
     const-qualifier.
+[^19]: `sizeof``(``bool``)` is not required to be `1`.
+[^20]: The actual size of a potentially-overlapping subobject can be
     less than the result of applying `sizeof` to the subobject, due to
     virtual base classes and less strict padding requirements on
     potentially-overlapping subobjects.
+[^21]: If the conversion function returns a signed integer type, the
     second standard conversion converts to the unsigned type
     `std::size_t` and thus thwarts any attempt to detect a negative
     value afterwards.
+[^22]: This can include evaluating a *new-initializer* and/or calling a
     constructor.
+[^23]: A *lambda-expression* with a *lambda-introducer* that consists of
     empty square brackets can follow the `delete` keyword if the
     *lambda-expression* is enclosed in parentheses.
+[^24]: For nonzero-length arrays, this is the same as a pointer to the
     first element of the array created by that *new-expression*.
     Zero-length arrays do not have a first element.
+[^25]: This is often called truncation towards zero.
+[^26]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose and a pointer past the last element of an array of n
     elements is considered to be equivalent to a pointer to a
     hypothetical array element n for this purpose.
+[^27]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose and a pointer past the last element of an array of n
     elements is considered to be equivalent to a pointer to a
     hypothetical array element n for this purpose.
+[^28]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose.
+[^29]: Overload resolution [[over.match]] is applied as usual.
+[^30]: This includes, for example, signed integer overflow [[expr.pre]],
     certain pointer arithmetic [[expr.add]], division by zero
     [[expr.mul]], or certain shift operations [[expr.shift]].
+[^31]: Testing this condition can involve a trial evaluation of its
+    initializer, with evaluations of contract assertions using the
+    ignore evaluation semantic [[basic.contract.eval]], as described
+    above.
+[^32]: In some cases, constant evaluation is needed to determine whether
     a narrowing conversion is performed [[dcl.init.list]].
+[^33]: In some cases, constant evaluation is needed to determine whether
     such an expression is value-dependent [[temp.dep.constexpr]].

Diff to HTML by rtfpessoa