[expr] - C++20 → C++23

Files changed (1) hide show

tmp/tmpxj9_dich/{from.md → to.md} +1407 -884

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

@@ -1,13 +1,19 @@
 # Expressions <a id="expr">[[expr]]</a>
 ## Preamble <a id="expr.pre">[[expr.pre]]</a>
-[*Note 1*:  [[expr]] defines the syntax, order of evaluation, and
-meaning of expressions.[^1] An expression is a sequence of operators and
-operands that specifies a computation. An expression can result in a
-value and can cause side effects. — *end note*]
 [*Note 2*: Operators can be overloaded, that is, given meaning when
 applied to expressions of class type [[class]] or enumeration type
 [[dcl.enum]]. Uses of overloaded operators are transformed into function
 calls as described in  [[over.oper]]. Overloaded operators obey the
@@ -37,13 +43,15 @@ its type, the behavior is undefined.
 zero divisor, and all floating-point exceptions varies among machines,
 and is sometimes adjustable by a library function. — *end note*]
 [*Note 4*:
-The implementation may regroup operators according to the usual
 mathematical rules only where the operators really are associative or
-commutative.[^2] For example, in the following fragment
 ``` cpp
 int a, b;
 ...
 a = a + 32760 + b + 5;
@@ -103,18 +111,16 @@ 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, bit-field, or function.
 - A *prvalue* is an expression whose evaluation initializes an object or
- a bit-field, 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 or bit-field 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
@@ -138,15 +144,15 @@ values. — *end note*]
 [*Note 3*:
 An expression is an xvalue if it is:
 - 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]],
 - a class member access expression designating a non-static data member
   of non-reference type in which the object expression is an xvalue
   [[expr.ref]], or
 - a `.*` pointer-to-member expression in which the first operand is an
@@ -216,26 +222,26 @@ glvalue for that operand, the temporary materialization conversion
 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.simple]], a prvalue shall always
 have complete type or the `void` type; if it has a class type or
-(possibly multi-dimensional) 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 may 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]
@@ -247,17 +253,18 @@ of the following types 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 10*: Unlike in C, C++ has no accesses 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
@@ -282,26 +289,27 @@ pointer-to-member type or `std::nullptr_t`, is:
 - 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 cv-combined type
-  [[conv.qual]] of `T1` and `T2` or the cv-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
   member of `C1` of type function”, respectively;
 - if `T1` is “pointer to member of `C1` of type *cv1* `U`” and `T2` is
   “pointer to member of `C2` of type *cv2* `U`”, for some non-function
   type `U`, where `C1` is reference-related to `C2` or `C2` is
-  reference-related to `C1` [[dcl.init.ref]], the cv-combined type of
-  `T2` and `T1` or the cv-combined type of `T1` and `T2`, respectively;
-- if `T1` and `T2` are similar types [[conv.qual]], the cv-combined type
-  of `T1` and `T2`;
 - otherwise, a program that necessitates the determination of a
   composite pointer type is ill-formed.
 [*Example 1*:
@@ -318,16 +326,15 @@ 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.simple]], [[temp.pre]], [[temp.concept]]). An unevaluated
-operand is not evaluated.
-[*Note 1*: In an unevaluated operand, a non-static class member may 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
 unevaluated operand is considered a full-expression
 [[intro.execution]]. — *end note*]
@@ -350,21 +357,24 @@ volatile-qualified type and it is one of the following:
   these expressions.
 [*Note 2*: Using an overloaded operator causes a function call; the
 above covers only operators with built-in meaning. — *end note*]
-If the (possibly converted) expression is a prvalue, the temporary
-materialization conversion [[conv.rval]] is applied.
-[*Note 3*: If the expression is an lvalue of class type, it must have a
-volatile copy constructor to initialize the temporary object that is the
-result object of the lvalue-to-rvalue conversion. — *end note*]
-The glvalue expression is evaluated and its value is discarded.
 ## Standard conversions <a id="conv">[[conv]]</a>
 Standard conversions are implicit conversions with built-in meaning.
 [[conv]] enumerates the full set of such conversions. A *standard
 conversion sequence* is a sequence of standard conversions in the
 following order:
@@ -443,14 +453,16 @@ the operand of the unary `&` operator. Specific exceptions are given in
 the descriptions of those operators and contexts. — *end note*]
 ### Lvalue-to-rvalue conversion <a id="conv.lval">[[conv.lval]]</a>
 A glvalue [[basic.lval]] of a non-function, non-array type `T` can be
-converted to a prvalue.[^5] If `T` is an incomplete type, a program that
-necessitates this conversion is ill-formed. If `T` is a non-class type,
-the type of the prvalue is the cv-unqualified version of `T`. Otherwise,
-the type of the prvalue is `T`. [^6]
 When an lvalue-to-rvalue conversion is applied to an expression E, and
 either
 - E is not potentially evaluated, or
@@ -485,13 +497,12 @@ 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]],
- [[basic.stc.dynamic.safety]]), 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*]
@@ -529,46 +540,46 @@ int k = X().n;      // OK, X() prvalue is converted to xvalue
 — *end example*]
 ### Qualification conversions <a id="conv.qual">[[conv.qual]]</a>
-A *cv-decomposition* of a type `T` is a sequence of cvᵢ and Pᵢ such that
-`T` is
 where each cvᵢ is a set of cv-qualifiers [[basic.type.qualifier]], and
 each Pᵢ is “pointer to” [[dcl.ptr]], “pointer to member of class Cᵢ of
 type” [[dcl.mptr]], “array of Nᵢ”, or “array of unknown bound of”
 [[dcl.array]]. If Pᵢ designates an array, the cv-qualifiers cvᵢ₊₁ on the
 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 cv-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
-cv-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 cv-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.
-The *cv-combined type* of two types `T1` and `T2` is the type `T3`
-similar to `T1` whose cv-decomposition is such that:
-- for every i > 0, cv³ᵢ is the union of cv¹ᵢ and cv²ᵢ;
 - if either P¹ᵢ or P²ᵢ is “array of unknown bound of”, P³ᵢ is “array of
-  unknown bound of”, otherwise it is P¹ᵢ;
 - if the resulting cv³ᵢ is different from cv¹ᵢ or cv²ᵢ, or the resulting
   P³ᵢ is different from P¹ᵢ or P²ᵢ, then `const` is added to every cv³ₖ
-  for 0 < k < i.
-where cvʲᵢ and Pʲᵢ are the components of the cv-decomposition of `T`j. A
-prvalue of type `T1` can be converted to type `T2` if the cv-combined
-type of `T1` and `T2` is `T2`.
 [*Note 1*:
 If a program could assign a pointer of type `T**` to a pointer of type
 `const` `T**` (that is, if line \#1 below were allowed), a program could
@@ -586,12 +597,12 @@ int main() {
 ```
 — *end note*]
 [*Note 2*: Given similar types `T1` and `T2`, this construction ensures
-that both can be converted to the cv-combined type of `T1` and
-`T2`. — *end note*]
 [*Note 3*: A prvalue of type “pointer to *cv1* `T`” can be converted to
 a prvalue of type “pointer to *cv2* `T`” if “*cv2* `T`” is more
 cv-qualified than “*cv1* `T`”. A prvalue of type “pointer to member of
 `X` of type *cv1* `T`” can be converted to a prvalue of type “pointer to
@@ -602,24 +613,24 @@ 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`, `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 `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 `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`,
@@ -640,12 +651,12 @@ 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 an enumerated 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*.
@@ -675,16 +686,19 @@ The conversions allowed as integral promotions are excluded from the set
 of integral conversions.
 ### Floating-point conversions <a id="conv.double">[[conv.double]]</a>
 A prvalue of floating-point type can be converted to a prvalue of
-another floating-point type. If the source value can be exactly
-represented in the destination type, the result of the conversion is
-that exact representation. If the source value is between two adjacent
-destination values, the result of the conversion is an
-*implementation-defined* choice of either of those values. Otherwise,
-the behavior is undefined.
 The conversions allowed as floating-point promotions are excluded from
 the set of floating-point conversions.
 ### Floating-integral conversions <a id="conv.fpint">[[conv.fpint]]</a>
@@ -807,36 +821,40 @@ 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.
-- If either operand is of type `long double`, the other shall be
- converted to `long double`.
-- Otherwise, if either operand is `double`, the other shall be converted
-  to `double`.
-- Otherwise, if either operand is `float`, the other shall be converted
-  to `float`.
-- Otherwise, the integral promotions [[conv.prom]] shall be performed on
-  both operands.[^9] Then the following rules shall be applied to the
-  promoted operands:
   - If both operands have the same type, no further conversion is
     needed.
-  - Otherwise, if both operands have signed integer types or both have
- unsigned integer types, the operand with the type of lesser integer
- conversion rank shall be converted to the type of the operand with
-    greater rank.
-  - Otherwise, if the operand that has unsigned integer type has rank
- greater than or equal to the rank of the type of the other operand,
- the operand with signed integer type shall be converted to the type
-    of the operand with unsigned integer type.
-  - Otherwise, if the type of the operand with signed integer type can
- represent all of the values of the type of the operand with unsigned
- integer type, the operand with unsigned integer type shall be
-    converted to the type of the operand with signed integer type.
- - Otherwise, both operands shall be converted to the unsigned integer
-    type corresponding to the type of the operand with signed integer
- type.
 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]].
@@ -853,35 +871,43 @@ primary-expression:
     requires-expression
 ```
 ### Literals <a id="expr.prim.literal">[[expr.prim.literal]]</a>
-A *literal* is a primary expression. The type of a *literal* is
-determined based on its form as specified in [[lex.literal]]. A
-*string-literal* is an lvalue, a *user-defined-literal* has the same
-value category as the corresponding operator call expression described
-in [[lex.ext]], and any other *literal* is a prvalue.
 ### This <a id="expr.prim.this">[[expr.prim.this]]</a>
-The keyword `this` names a pointer to the object for which a non-static
-member function [[class.this]] is invoked or a non-static data member’s
-initializer [[class.mem]] is evaluated.
 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`” between the optional *cv-qualifier-seq* and the
-end of the *function-definition*, *member-declarator*, or *declarator*.
-It shall not appear before the optional *cv-qualifier-seq* and it shall
-not appear within the declaration of a static member function (although
-its type and value category are defined within a static member function
-as they are within a non-static member function).
-[*Note 1*: This is because declaration matching does not occur until
 the complete declarator is known. — *end note*]
-[*Note 2*:
 In a *trailing-return-type*, the class being defined is not required to
 be complete for purposes of class member access [[expr.ref]]. Class
 members declared later are not visible.
@@ -900,21 +926,21 @@ template auto A::f(int t) -> decltype(t + g());
 — *end note*]
 Otherwise, if a *member-declarator* declares a non-static data member
 [[class.mem]] of a class `X`, the expression `this` is a prvalue of type
-“pointer to `X`” within the optional default member initializer
-[[class.mem]]. It shall not appear elsewhere in the *member-declarator*.
 The expression `this` shall not appear in any other context.
 [*Example 2*:
 ``` cpp
 class Outer {
   int a[sizeof(*this)];                 // error: not inside a member function
-  unsigned int sz = sizeof(*this);      // OK: in default member initializer
   void f() {
     int b[sizeof(*this)];               // OK
     struct Inner {
@@ -927,16 +953,19 @@ class Outer {
 — *end example*]
 ### Parentheses <a id="expr.prim.paren">[[expr.prim.paren]]</a>
 A parenthesized expression `(E)` is a primary expression whose type,
-value, and value category are identical to those of E. The parenthesized
-expression can be used in exactly the same contexts as those where E can
-be used, and with the same meaning, except as otherwise indicated.
 ### Names <a id="expr.prim.id">[[expr.prim.id]]</a>
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
 ```
@@ -944,63 +973,71 @@ id-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*]
-An *id-expression* that denotes a non-static data member or non-static
-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 1*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
   ```
   — *end example*]
-A potentially-evaluated *id-expression* that denotes an immediate
-function [[dcl.constexpr]] shall appear only
-- as a subexpression of an immediate invocation, or
-- in an immediate function context [[expr.const]].
 For an *id-expression* that denotes an overload set, overload resolution
-is performed to select a unique function ([[over.match]],
-[[over.over]]).
-[*Note 2*:
 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 2*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
-}
 void g() {
   A<int>::f(0);                         // error: cannot call f
   void (*p1)(int) = A<int>::f;          // error: cannot take the address of f
   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 [[expr.prop]].
 — *end example*]
 — *end note*]
@@ -1027,56 +1064,109 @@ the copy of the parameter [[dcl.fct.def.coroutine]].
 *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*]
-The result is the entity denoted by the identifier. If the entity is a
-local entity and naming it from outside of an unevaluated operand within
-the declarative region where the *unqualified-id* appears would result
-in some intervening *lambda-expression* capturing it by copy
-[[expr.prim.lambda.capture]], 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 closure object
-of the innermost such intervening *lambda-expression*.
-[*Note 2*: If that *lambda-expression* is not declared `mutable`, the
   type of such an identifier will typically be `const`
   qualified. — *end note*]
-The type of the expression is the type of the result.
-[*Note 3*: 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 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 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;
-  [=] {
     decltype(x) y1;             // y1 has type float
-    decltype((x)) y2 = y1;      // y2 has type float const& because this lambda
-                                // is not mutable and x is an lvalue
     decltype(r) r1 = y1;        // r1 has type float&
     decltype((r)) r2 = y2;      // r2 has type float const&
   };
 }
 ```
 — *end example*]
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
     nested-name-specifier templateₒₚₜ unqualified-id
@@ -1090,56 +1180,66 @@ nested-name-specifier:
     decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
-The type denoted by a *decltype-specifier* in a *nested-name-specifier*
-shall be a class or enumeration type.
-A *nested-name-specifier* that denotes a class, optionally followed by
-the keyword `template` [[temp.names]], and then followed by the name of
-a member of either that class [[class.mem]] or one of its base classes
-[[class.derived]], is a *qualified-id*;  [[class.qual]] describes name
-lookup for class members that appear in *qualified-id*s. The result is
-the member. The type of the result is the type of the member. The result
-is an lvalue if the member is a static member function or a data member
 and a prvalue otherwise.
-[*Note 1*: A class member can be referred to using a *qualified-id* at
-any point in its potential scope [[basic.scope.class]]. — *end note*]
-Where *type-name* `::~` *type-name* is used, the two *type-name*s shall
-refer to the same type (ignoring cv-qualifications); this notation
-denotes the destructor of the type so named [[expr.prim.id.dtor]]. The
-*unqualified-id* in a *qualified-id* shall not be of the form
-`~`*decltype-specifier*.
-The *nested-name-specifier* `::` names the global namespace. A
-*nested-name-specifier* that names a namespace [[basic.namespace]],
-optionally followed by the keyword `template` [[temp.names]], and then
-followed by the name of a member of that namespace (or the name of a
-member of a namespace made visible by a *using-directive*), is a
-*qualified-id*;  [[namespace.qual]] describes name lookup for namespace
-members that appear in *qualified-id*s. The result is the member. The
-type of the result is the type of the member. The result is an lvalue if
-the member is a function, a variable, or a structured binding
-[[dcl.struct.bind]] and a prvalue otherwise.
-A *nested-name-specifier* that denotes an enumeration [[dcl.enum]],
-followed by the name of an enumerator of that enumeration, is a
-*qualified-id* that refers to the enumerator. The result is the
-enumerator. The type of the result is the type of the enumeration. The
-result is a prvalue.
-In a *qualified-id*, if the *unqualified-id* is a
-*conversion-function-id*, its *conversion-type-id* is first looked up in
-the class denoted by the *nested-name-specifier* of the *qualified-id*
-and the name, if found, is used. Otherwise, it is looked up in the
-context in which the entire *qualified-id* occurs. In each of these
-lookups, only names that denote types or templates whose specializations
-are types are considered.
 #### 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*.
@@ -1147,12 +1247,12 @@ destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 If the *id-expression* names a pseudo-destructor, `T` shall be a scalar
 type and the *id-expression* shall appear as the right operand of a
 class member access [[expr.ref]] that forms the *postfix-expression* of
 a function call [[expr.call]].
-[*Note 1*: Such a call ends the lifetime of the object ([[expr.call]],
-[[basic.life]]). — *end note*]
 [*Example 1*:
 ``` cpp
 struct C { };
@@ -1169,25 +1269,45 @@ void f() {
 — *end example*]
 ### Lambda expressions <a id="expr.prim.lambda">[[expr.prim.lambda]]</a>
 ``` bnf
 lambda-expression:
-    lambda-introducer lambda-declaratorₒₚₜ compound-statement
-    lambda-introducer '<' template-parameter-list '>' requires-clauseₒₚₜ lambda-declaratorₒₚₜ compound-statement
 ```
 ``` bnf
 lambda-introducer:
     '[' lambda-captureₒₚₜ ']'
 ```
 ``` bnf
 lambda-declarator:
- '(' parameter-declaration-clause ')' decl-specifier-seqₒₚₜ
- noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ requires-clauseₒₚₜ
 ```
 A *lambda-expression* provides a concise way to create a simple function
 object.
@@ -1207,29 +1327,46 @@ A *lambda-expression* is a prvalue whose result object is called the
 *closure object*.
 [*Note 1*: A closure object behaves like a function object
 [[function.objects]]. — *end note*]
-In the *decl-specifier-seq* of the *lambda-declarator*, each
-*decl-specifier* shall be one of `mutable`, `constexpr`, or `consteval`.
-[*Note 2*: The trailing *requires-clause* is described in
 [[dcl.decl]]. — *end note*]
-If a *lambda-expression* does not include a *lambda-declarator*, it is
-as if the *lambda-declarator* were `()`. The lambda return type is
-`auto`, which is replaced by the type specified by the
-*trailing-return-type* if provided and/or deduced from `return`
-statements as described in  [[dcl.spec.auto]].
 [*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;
-auto x3 = []()->auto&& { return j; }; // OK: return type is int&
 ```
 — *end example*]
 A lambda is a *generic lambda* if the *lambda-expression* has any
@@ -1237,12 +1374,12 @@ 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>
@@ -1281,56 +1418,90 @@ and whose *template-parameter-list* consists of the specified
 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
-might be an abbreviated function template [[dcl.fct]]. — *end note*]
 [*Example 1*:
 ``` cpp
 auto glambda = [](auto a, auto&& b) { return a < b; };
 bool b = glambda(3, 3.14);                                      // OK
 auto vglambda = [](auto printer) {
-  return [=](auto&& ... ts) {                                   // OK: ts is a function parameter pack
     printer(std::forward<decltype(ts)>(ts)...);
     return [=]() {
       printer(ts ...);
     };
   };
 };
 auto p = vglambda( [](auto v1, auto v2, auto v3)
                    { std::cout << v1 << v2 << v3; } );
-auto q = p(1, 'a', 3.14);                                       // OK: outputs 1a3.14
-q();                                                            // OK: outputs 1a3.14
 ```
 — *end example*]
-The function call operator or operator template is declared `const` (
-[[class.mfct.non-static]]) if and only if the *lambda-expression*’s
-*parameter-declaration-clause* is not followed by `mutable`. 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. The function call operator or any
-given operator template specialization is a constexpr function if either
-the corresponding *lambda-expression*'s *parameter-declaration-clause*
-is followed by `constexpr` or `consteval`, or it satisfies the
-requirements for a constexpr function [[dcl.constexpr]]. It is an
 immediate function [[dcl.constexpr]] if the corresponding
 *lambda-expression*'s *parameter-declaration-clause* is followed by
 `consteval`.
-[*Note 3*: Names referenced in the *lambda-declarator* are looked up in
-the context in which the *lambda-expression* appears. — *end note*]
-[*Example 2*:
 ``` cpp
 auto ID = [](auto a) { return a; };
 static_assert(ID(3) == 3);                      // OK
@@ -1341,11 +1512,11 @@ struct NonLiteral {
 static_assert(ID(NonLiteral{3}).n == 3);        // error
 ```
 — *end example*]
-[*Example 3*:
 ``` cpp
 auto monoid = [](auto v) { return [=] { return v; }; };
 auto add = [](auto m1) constexpr {
   auto ret = m1();
@@ -1370,18 +1541,18 @@ static_assert(add(one)(one)() == two());        // error: two() is not a constan
 static_assert(add(one)(one)() == monoid(2)());  // OK
 ```
 — *end example*]
-[*Note 4*:
-The function call operator or operator template may be constrained
 [[temp.constr.decl]] by a *type-constraint* [[temp.param]], a
 *requires-clause* [[temp.pre]], or a trailing *requires-clause*
 [[dcl.decl]].
-[*Example 4*:
 ``` cpp
 template <typename T> concept C1 = ...;
 template <std::size_t N> concept C2 = ...;
 template <typename A, typename B> concept C3 = ...;
@@ -1402,27 +1573,29 @@ 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. 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 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
@@ -1454,11 +1627,11 @@ struct Closure {
 };
 ```
 — *end note*]
-[*Example 5*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
@@ -1470,45 +1643,49 @@ void h(char (*)(int))   { }     // #4
 auto glambda = [](auto a) { return a; };
 f1(glambda);                    // OK
 f2(glambda);                    // error: ID is not convertible
 g(glambda);                     // error: ambiguous
-h(glambda);                     // OK: calls #3 since it is convertible from ID
 int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; };        // OK
 ```
 — *end example*]
-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 6*: 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 6*:
 ``` 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)
 ```
 — *end example*]
 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 7*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
@@ -1520,18 +1697,14 @@ static_assert(Fwd(NC,3) == 3);  // error
 ```
 — *end example*]
 The *lambda-expression*’s *compound-statement* yields the
-*function-body* [[dcl.fct.def]] of the function call operator, but for
-purposes of name lookup [[basic.lookup]], determining the type and value
-of `this` [[class.this]] and transforming *id-expression*s referring to
-non-static class members into class member access expressions using
-`(*this)` ([[class.mfct.non-static]]), the *compound-statement* is
-considered in the context of the *lambda-expression*.
-[*Example 8*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
@@ -1556,12 +1729,12 @@ 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, and might therefore be defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].
 A member of a closure type shall not be explicitly instantiated
@@ -1607,13 +1780,12 @@ simple-capture:
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
-The body of a *lambda-expression* may refer to variables with automatic
-storage duration and the `*this` object (if any) 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
@@ -1646,35 +1818,37 @@ 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* is looked up using the usual
-rules for unqualified name lookup [[basic.lookup.unqual]]; each such
-lookup shall find a local entity. 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*.
-If an *identifier* in a *simple-capture* appears as the *declarator-id*
-of a parameter of the *lambda-declarator*'s
-*parameter-declaration-clause*, the program is ill-formed.
 [*Example 2*:
 ``` cpp
 void f() {
   int x = 0;
-  auto g = [x](int x) { return 0; };    // error: parameter and simple-capture have the same name
 }
 ```
 — *end example*]
-An *init-capture* without ellipsis behaves as if it declares and
-explicitly captures a variable of the form “`auto` *init-capture* `;`”
-whose declarative region is the *lambda-expression*’s
-*compound-statement*, except that:
 - if the capture is by copy (see below), the non-static data member
   declared for the capture and the variable are treated as two different
   ways of referring to the same object, which has the lifetime of the
   non-static data member, and no additional copy and destruction is
@@ -1693,11 +1867,14 @@ int x = 4;
 auto y = [&r = x, x = x+1]()->int {
             r += 2;
             return x+2;
          }();                               // Updates ::x to 6, and initializes y to 7.
-auto z = [a = 42](int a) { return 1; };     // error: parameter and local variable have the same name
 ```
 — *end example*]
 For the purposes of lambda capture, an expression potentially references
@@ -1711,13 +1888,13 @@ local entities as follows:
   *id-expression*. — *end note*]
 - A `this` expression potentially references `*this`.
 - A *lambda-expression* potentially references the local entities named
   by its *simple-capture*s.
-If an expression potentially references a local entity within a
-declarative region in which it is odr-usable, and the expression would
-be potentially evaluated if the effect of any enclosing `typeid`
 expressions [[expr.typeid]] were ignored, the entity is said to be
 *implicitly captured* by each intervening *lambda-expression* with an
 associated *capture-default* that does not explicitly capture it. The
 implicit capture of `*this` is deprecated when the *capture-default* is
 `=`; see [[depr.capture.this]].
@@ -1728,38 +1905,38 @@ implicit capture of `*this` is deprecated when the *capture-default* is
 void f(int, const int (&)[2] = {});         // #1
 void f(const int&, const int (&)[1]);       // #2
 void test() {
   const int x = 17;
   auto g = [](auto a) {
-    f(x);                       // OK: calls #1, does not capture x
   };
   auto g1 = [=](auto a) {
-    f(x);                       // OK: calls #1, captures x
   };
   auto g2 = [=](auto a) {
     int selector[sizeof(a) == 1 ? 1 : 2]{};
-    f(x, selector);             // OK: captures x, might call #1 or #2
   };
   auto g3 = [=](auto a) {
     typeid(a + x);              // captures x regardless of whether a + x is an unevaluated operand
   };
 }
 ```
-Within `g1`, an implementation might optimize away the capture of `x` as
 it is not odr-used.
 — *end example*]
 [*Note 4*:
 The set of captured entities is determined syntactically, and entities
-might be implicitly captured even if the expression denoting a local
-entity is within a discarded statement [[stmt.if]].
 [*Example 5*:
 ``` cpp
 template<bool B>
@@ -1775,12 +1952,12 @@ void f(int n) {
 — *end example*]
 — *end note*]
 An entity is *captured* if it is captured explicitly or implicitly. An
-entity captured by a *lambda-expression* is odr-used [[basic.def.odr]]
-in the scope containing the *lambda-expression*.
 [*Note 5*: As a consequence, if a *lambda-expression* explicitly
 captures an entity that is not odr-usable, the program is ill-formed
 [[basic.def.odr]]. — *end note*]
@@ -1790,26 +1967,26 @@ captures an entity that is not odr-usable, the program is ill-formed
 void f1(int i) {
   int const N = 20;
   auto m1 = [=]{
     int const M = 30;
     auto m2 = [i]{
-      int x[N][M];              // OK: N and M are not odr-used
-      x[0][0] = i;              // OK: i is explicitly captured by m2 and implicitly captured by m1
     };
   };
   struct s1 {
     int f;
     void work(int n) {
       int m = n*n;
       int j = 40;
       auto m3 = [this,m] {
         auto m4 = [&,j] {       // error: j not odr-usable due to intervening lambda m3
           int x = n;            // error: n is odr-used but not odr-usable due to intervening lambda m3
-          x += m;               // OK: m implicitly captured by m4 and explicitly captured by m3
           x += i;               // error: i is odr-used but not odr-usable
                                 // due to intervening function and class scopes
-          x += f;               // OK: this captured implicitly by m4 and explicitly by m3
         };
       };
     }
   };
 }
@@ -1872,11 +2049,11 @@ the entity is a reference to an object, an lvalue reference to the
 referenced function type if the entity is a reference to a function, or
 the type of the corresponding captured entity otherwise. A member of an
 anonymous union shall not be captured by copy.
 Every *id-expression* within the *compound-statement* of a
-*lambda-expression* that is an odr-use [[basic.def.odr]] of an entity
 captured by copy is transformed into an access to the corresponding
 unnamed data member of the closure type.
 [*Note 7*: An *id-expression* that is not an odr-use refers to the
 original entity, never to a member of the closure type. However, such an
@@ -1892,12 +2069,12 @@ 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
   };
 }
 ```
@@ -1945,13 +2122,15 @@ auto h(int &r) {
 If a *lambda-expression* `m2` captures an entity and that entity is
 captured by an immediately enclosing *lambda-expression* `m1`, then
 `m2`’s capture is transformed as follows:
-- if `m1` captures the entity by copy, `m2` captures the corresponding
-  non-static data member of `m1`’s closure type;
-- if `m1` captures the entity by reference, `m2` captures the same
   entity captured by `m1`.
 [*Example 11*:
 The nested *lambda-expression*s and invocations below will output
@@ -1992,12 +2171,11 @@ captured by reference, invoking the function call operator of the
 corresponding *lambda-expression* after the lifetime of the entity has
 ended is likely to result in undefined behavior. — *end note*]
 A *simple-capture* containing an ellipsis is a pack expansion
 [[temp.variadic]]. An *init-capture* containing an ellipsis is a pack
-expansion that introduces an *init-capture* pack [[temp.variadic]] whose
-declarative region is the *lambda-expression*’s *compound-statement*.
 [*Example 12*:
 ``` cpp
 template<class... Args>
@@ -2064,10 +2242,12 @@ bool f(Args ...args) {
 — *end example*]
 ### Requires expressions <a id="expr.prim.req">[[expr.prim.req]]</a>
 A *requires-expression* provides a concise way to express requirements
 on template arguments that can be checked by name lookup
 [[basic.lookup]] or by checking properties of types and expressions.
 ``` bnf
@@ -2075,22 +2255,22 @@ requires-expression:
     requires requirement-parameter-listₒₚₜ requirement-body
 ```
 ``` bnf
 requirement-parameter-list:
-    '(' parameter-declaration-clauseₒₚₜ ')'
 ```
 ``` bnf
 requirement-body:
     '{' requirement-seq '}'
 ```
 ``` bnf
 requirement-seq:
     requirement
-    requirement-seq requirement
 ```
 ``` bnf
 requirement:
     simple-requirement
@@ -2099,11 +2279,11 @@ 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 [[expr.prop]].
 [*Example 1*:
 A common use of *requires-expression*s is to define requirements in
 concepts such as the one below:
@@ -2131,13 +2311,11 @@ 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. Each name
-introduced by a local parameter is in scope from the point of its
-declaration until the closing brace of the *requirement-body*. 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.
@@ -2150,14 +2328,10 @@ concept C = requires(T t, ...) {    // error: terminates with an ellipsis
 };
 ```
 — *end example*]
-The *requirement-body* contains a sequence of *requirement*s. These
-*requirement*s may refer to local parameters, template parameters, and
-any other declarations visible from the enclosing context.
 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
@@ -2196,11 +2370,12 @@ simple-requirement:
 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 [[expr.prop]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename T> concept C =
@@ -2235,19 +2410,20 @@ 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 class template specialization
   typename Ref<T>;      // required alias template substitution, fails if T is void
 };
 ```
 — *end example*]
 A *type-requirement* that names a class template specialization does not
-require that type to be complete [[basic.types]].
 #### Compound requirements <a id="expr.prim.req.compound">[[expr.prim.req.compound]]</a>
 ``` bnf
 compound-requirement:
@@ -2270,10 +2446,11 @@ properties proceed in the following order:
 - If the *return-type-requirement* is present, then:
   - Substitution of template arguments (if any) into the
     *return-type-requirement* is performed.
   - The immediately-declared constraint [[temp.param]] of the
     *type-constraint* for `decltype((E))` shall be satisfied.
   \[*Example 1*:
   Given concepts `C` and `D`,
   ``` cpp
   requires {
     { E1 } -> C;
@@ -2352,43 +2529,31 @@ template<typename T> concept D = requires (T t) {
 `D<T>` is satisfied if `sizeof(decltype (+t)) == 1`
 [[temp.constr.atomic]].
 — *end example*]
-A local parameter shall only appear as an unevaluated operand
-[[expr.prop]] within the *constraint-expression*.
-[*Example 2*:
-``` cpp
-template<typename T> concept C = requires (T a) {
-  requires sizeof(a) == 4;      // OK
-  requires a == 0;              // error: evaluation of a constraint variable
-};
-```
-— *end example*]
 ## Compound expressions <a id="expr.compound">[[expr.compound]]</a>
 ### Postfix expressions <a id="expr.post">[[expr.post]]</a>
 Postfix expressions group left-to-right.
 ``` bnf
 postfix-expression:
     primary-expression
-    postfix-expression '[' expr-or-braced-init-list ']'
     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 ')'
     const_cast '<' type-id '>' '(' expression ')'
     typeid '(' expression ')'
@@ -2399,38 +2564,43 @@ postfix-expression:
 expression-list:
     initializer-list
 ```
 [*Note 1*: The `>` token following the *type-id* in a `dynamic_cast`,
-`static_cast`, `reinterpret_cast`, or `const_cast` may be the product of
-replacing a `>{>}` token by two consecutive `>` tokens
 [[temp.names]]. — *end note*]
 #### Subscripting <a id="expr.sub">[[expr.sub]]</a>
-A postfix expression followed by an expression in square brackets is a
-postfix 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. The
-expression `E1` is sequenced before the expression `E2`.
-[*Note 1*: A comma expression [[expr.comma]] appearing as the
-*expr-or-braced-init-list* of a subscripting expression is deprecated;
-see [[depr.comma.subscript]]. — *end note*]
-[*Note 2*: Despite its asymmetric appearance, subscripting is a
 commutative operation except for sequencing. See  [[expr.unary]] and
 [[expr.add]] for details of `*` and `+` and  [[dcl.array]] for details
 of array types. — *end note*]
-A *braced-init-list* shall not be used with the built-in subscript
-operator.
 #### Function call <a id="expr.call">[[expr.call]]</a>
 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.
@@ -2444,72 +2614,69 @@ 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.
-For a call to a non-static member function, the postfix expression shall
-be an implicit ([[class.mfct.non-static]], [[class.static]]) or
-explicit class member access [[expr.ref]] whose *id-expression* is a
-function member name, or a pointer-to-member expression
-[[expr.mptr.oper]] selecting a function member; the call is as a member
-of the class object referred to by the object expression. In the case of
-an implicit class member access, the implied object is the one pointed
-to by `this`.
-[*Note 2*: A member function call of the form `f()` is interpreted as
-`(*this).f()` (see  [[class.mfct.non-static]]). — *end note*]
 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
 *virtual function call*.
-[*Note 3*: 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 4*: 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
 `virtual` keyword), even if the type of the function actually called is
-different. This return type shall be an object type, a reference type or
-cv `void`. 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 is
-different from the function type of the called function’s definition
-results in undefined behavior.
-When a function is called, each parameter [[dcl.fct]] is initialized (
-[[dcl.init]], [[class.copy.ctor]]) with its corresponding argument. 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 a non-static member function, the `this` parameter of
-the function [[class.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]],
 [[class.access.base]], and  [[expr.ref]]. — *end note*]
@@ -2527,14 +2694,14 @@ 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 scope of the calling function; in
-particular, if the function called has a *function-try-block*
-[[except.pre]] with a handler that could 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
@@ -2590,14 +2757,14 @@ statically chosen function.
 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
 default arguments [[dcl.fct.default]]) or more arguments (by using the
 ellipsis, `...`, or a function parameter pack [[dcl.fct]]) than the
 number of parameters in the function definition [[dcl.fct.def]].
@@ -2647,73 +2814,93 @@ A *simple-type-specifier* [[dcl.type.simple]] or *typename-specifier*
 by a *braced-init-list* (the initializer) constructs a value of the
 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.
 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 the specified type 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` [[temp.names]], 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.
 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 an lvalue of type “function of ()
 returning `void`”.
-[*Note 1*: This value can only be used for a notional function call
 [[expr.prim.id.dtor]]. — *end note*]
 Otherwise, the object expression shall be of class type. The class type
 shall be complete unless the class member access appears in the
 definition of that class.
-[*Note 2*: If the class is incomplete, lookup in the complete class
-type is required to refer to the same declaration
-[[basic.scope.class]]. — *end note*]
-The *id-expression* shall name a member of the class or of one of its
-base classes.
-[*Note 3*: Because the name of a class is inserted in its class scope
-[[class]], the name of a class is also considered a nested member of
-that class. — *end note*]
-[*Note 4*:  [[basic.lookup.classref]] 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; the type of `E1.E2` is `T`. 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*
@@ -2726,33 +2913,53 @@ rules applies.
   *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 a (possibly overloaded) member function, 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. The type of `E1.E2` is `T`.
-If `E2` is a non-static data member or a non-static member function, 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*]
 #### 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
@@ -2775,11 +2982,11 @@ 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 `\dcr` is decremented analogously to the postfix
 `++` operator.
 [*Note 3*: For prefix increment and decrement, see
 [[expr.pre.incr]]. — *end note*]
@@ -2805,13 +3012,14 @@ 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*:
 ``` cpp
 struct B { };
@@ -2831,11 +3039,11 @@ 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`.
-If `C` is 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
@@ -2889,40 +3097,44 @@ destruction. — *end note*]
 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.
 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
 [[conv.func]] conversions are not applied to the expression. If the
 expression is a prvalue, the temporary materialization conversion
 [[conv.rval]] is applied. The expression is an unevaluated operand
-[[expr.prop]].
 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. If the type of
-the *type-id* is a class type or a reference to a class type, the class
-shall be completely-defined.
 [*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
@@ -2942,12 +3154,14 @@ typeid(D)  == typeid(d2);       // yields true
 typeid(D)  == typeid(const D&); // yields true
 ```
 — *end example*]
-If the header `<typeinfo>` is not imported or included prior to a use of
-`typeid`, 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>
@@ -2983,19 +3197,19 @@ B &br = d;
 static_cast<D&>(br);            // produces lvalue denoting the original d object
 ```
 — *end example*]
-An lvalue of type “*cv1* `T1`” can be cast to type “rvalue reference to
-*cv2* `T2`” if “*cv2* `T2`” is reference-compatible with “*cv1* `T1`”
-[[dcl.init.ref]]. If the value is not a bit-field, the result refers to
-the object or the specified base class subobject thereof; otherwise, the
-lvalue-to-rvalue conversion [[conv.lval]] is applied to the bit-field
-and the resulting prvalue is used as the *expression* 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
@@ -3024,13 +3238,16 @@ direct-initialization defines the type of the expression as
 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 it becomes a discarded-value expression [[expr.prop]].
-[*Note 3*: 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
@@ -3068,39 +3285,48 @@ explicitly converted to a floating-point type; the result is the same as
 that of converting from the original value to the floating-point type.
 A value of integral or enumeration type can be explicitly converted to a
 complete enumeration type. If the enumeration type has a fixed
 underlying type, the value is first converted to that type by integral
-conversion, if necessary, and then to the enumeration type. If the
-enumeration type does not have a fixed underlying type, the value is
-unchanged if the original value is within the range of the enumeration
-values [[dcl.enum]], and otherwise, the behavior is undefined. A value
-of floating-point type can also be explicitly converted to an
-enumeration type. The resulting value is the same as converting the
-original value to the underlying type of the enumeration [[conv.fpint]],
-and subsequently to the enumeration type.
 A prvalue of type “pointer to *cv1* `B`”, where `B` is a class type, can
 be converted to a prvalue of type “pointer 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. The
 null pointer value [[basic.compound]] is converted to the null pointer
 value of the destination type. If the prvalue of type “pointer to *cv1*
-`B`” points to a `B` that is actually a subobject of an object of type
-`D`, the resulting pointer points to the enclosing object of type `D`.
-Otherwise, the behavior is undefined.
 A prvalue of type “pointer to member of `D` of type *cv1* `T`” can be
 converted to a prvalue of type “pointer to member of `B` of type *cv2*
 `T`”, where `D` is a complete class type and `B` is a base class
 [[class.derived]] of `D`, if *cv2* is the same cv-qualification as, or
 greater cv-qualification than, *cv1*.
-[*Note 4*: Function types (including those used in
 pointer-to-member-function types) are never cv-qualified
 [[dcl.fct]]. — *end note*]
 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
@@ -3109,11 +3335,11 @@ 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 5*: 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
@@ -3121,14 +3347,13 @@ 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 `T` (ignoring cv-qualification) 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;
@@ -3178,39 +3403,37 @@ 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*.
-[*Note 4*: Except as described in [[basic.stc.dynamic.safety]], the
-result of such a conversion will not be a safely-derived pointer
-value. — *end note*]
 A function pointer can be explicitly converted to a function pointer of
 a different type.
-[*Note 5*: The effect of calling a function through a pointer to a
 function type [[dcl.fct]] that is not the same as the type used in the
 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 6*: 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 7*: Converting a prvalue of type “pointer to `T1`” to the type
-“pointer to `T2`” (where `T1` and `T2` are object types and where 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*]
 Converting a function pointer to an object pointer type or vice versa is
 conditionally-supported. The meaning of such a conversion is
 *implementation-defined*, except that if an implementation supports
 conversions in both directions, converting a prvalue of one type to the
@@ -3218,21 +3441,23 @@ 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 8*: 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:
 - Converting a prvalue of type “pointer to member function” to a
   different pointer-to-member-function type and back to its original
   type yields the original pointer-to-member value.
 - Converting a prvalue of type “pointer to data member of `X` of type
@@ -3260,17 +3485,17 @@ otherwise, the result is a prvalue and the lvalue-to-rvalue
 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
-may 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 cv-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
@@ -3303,46 +3528,56 @@ 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] may produce
-undefined behavior [[dcl.type.cv]]. — *end note*]
 A conversion from a type `T1` to a type `T2` *casts away constness* if
-`T1` and `T2` are different, there is a cv-decomposition [[conv.qual]]
-of `T1` yielding *n* such that `T2` has a cv-decomposition of the form
 and there is no qualification conversion that converts `T1` to
 Casting from an lvalue of type `T1` to an lvalue of type `T2` using an
 lvalue reference cast or casting from an expression of type `T1` to an
 xvalue of type `T2` using an rvalue reference cast casts away constness
 if a cast from a prvalue of type “pointer to `T1`” to the type “pointer
 to `T2`” casts away constness.
 [*Note 3*: Some conversions which involve only changes in
-cv-qualification cannot be done using `const_cast.` For instance,
 conversions between pointers to functions are not covered because such
 conversions lead to values whose use causes undefined behavior. For the
 same reasons, conversions between pointers to member functions, and in
 particular, the conversion from a pointer to a const member function to
 a pointer to a non-const member function, are not
 covered. — *end note*]
 ### Unary expressions <a id="expr.unary">[[expr.unary]]</a>
 Expressions with unary operators group right-to-left.
 ``` bnf
 unary-expression:
     postfix-expression
     unary-operator cast-expression
     '++' cast-expression
-    '-{-}' cast-expression
     await-expression
     sizeof unary-expression
     sizeof '(' type-id ')'
     sizeof '...' '(' identifier ')'
     alignof '(' type-id ')'
@@ -3350,41 +3585,43 @@ unary-expression:
     new-expression
     delete-expression
 ```
 ``` bnf
 unary-operator: one of
     '* & + - ! ~'
 ```
 #### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
-The unary `*` operator performs *indirection*: the expression to which
-it is applied shall be a pointer to an object type, or a pointer to a
-function type and the result is an lvalue referring to the object or
-function to which the expression points. If the type of the expression
-is “pointer to `T`”, the type of the result is “`T`”.
 [*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*]
-The result of each of the following unary operators is a prvalue.
-The result of the unary `&` operator is a pointer to its operand.
 - If the operand is a *qualified-id* naming a non-static or variant
-  member `m` of some class `C` with type `T`, the result has type
-  “pointer to member of class `C` of type `T`” and is a prvalue
- designating `C::m`.
-- Otherwise, if the operand is an lvalue of type `T`, the resulting
- expression is a prvalue of type “pointer to `T`” whose result is a
- pointer to the designated object [[intro.memory]] or function.
-  \[*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*]
-- Otherwise, the program is ill-formed.
 [*Example 1*:
 ``` cpp
 struct A { int i; };
@@ -3417,44 +3654,53 @@ 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 overloaded function [[over]] can be taken
-only in a context that uniquely determines which version of the
-overloaded function is referred to (see  [[over.over]]). Since the
-context might determine 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 negation 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.
 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 `~` shall have integral or unscoped enumeration type; the
-result is the ones’ complement of its operand. Integral promotions are
-performed. The type of the result is the type of the promoted operand.
 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 unary complement operator rather than as the start
-of an *unqualified-id* naming a destructor.
-[*Note 6*: 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>
@@ -3468,12 +3714,12 @@ 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 `\dcr` is modified [[defns.access]] by subtracting
-`1`. The requirements on the operand of prefix `\dcr` 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*]
@@ -3489,30 +3735,30 @@ await-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 a *for-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-scope
 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]]
   of the enclosing coroutine and `P` is the type of that object.
-- *a* is the *cast-expression* if the *await-expression* was implicitly
- produced by a *yield-expression* [[expr.yield]], an initial suspend
- point, or a final suspend point [[dcl.fct.def.coroutine]]. Otherwise,
-  the *unqualified-id* `await_transform` is looked up within the scope
- of `P` by class member access lookup [[basic.lookup.classref]], and if
- this lookup finds at least one declaration, then *a* is
   *p*`.await_transform(`*cast-expression*`)`; otherwise, *a* is the
   *cast-expression*.
 - *o* is determined by enumerating the applicable `operator co_await`
   functions for an argument *a* [[over.match.oper]], and choosing the
   best one through overload resolution [[over.match]]. If overload
@@ -3540,25 +3786,31 @@ and the *await-ready* expression, then:
 - If the result of *await-ready* is `false`, the coroutine is considered
   suspended. Then:
   - If the type of *await-suspend* is `std::coroutine_handle<Z>`,
     *await-suspend*`.resume()` is evaluated. \[*Note 1*: This resumes
     the coroutine referred to by the result of *await-suspend*. Any
-    number of coroutines may be successively resumed in this fashion,
     eventually returning control flow to the current coroutine caller or
     resumer [[dcl.fct.def.coroutine]]. — *end note*]
   - Otherwise, if the type of *await-suspend* is `bool`, *await-suspend*
     is evaluated, and the coroutine is resumed if the result is `false`.
   - Otherwise, *await-suspend* is evaluated.
   If the evaluation of *await-suspend* exits via an exception, the
   exception is caught, the coroutine is resumed, and the exception is
-  immediately re-thrown [[except.throw]]. Otherwise, control flow
- returns to the current coroutine caller or resumer
- [[dcl.fct.def.coroutine]] without exiting any scopes [[stmt.jump]].
 - If the result of *await-ready* is `true`, or when the coroutine is
-  resumed, the *await-resume* expression is evaluated, and its result is
-  the result of the *await-expression*.
 [*Example 1*:
 ``` cpp
 template <typename T>
@@ -3585,11 +3837,11 @@ auto operator co_await(std::chrono::duration<Rep, Period> d) {
 using namespace std::chrono;
 my_future<int> h();
 my_future<void> g() {
-  std::cout << "just about go to sleep...\n";
   co_await 10ms;
   std::cout << "resumed\n";
   co_await h();
 }
@@ -3602,33 +3854,40 @@ int a[] = { co_await h() };     // error: await-expression outside of function s
 #### Sizeof <a id="expr.sizeof">[[expr.sizeof]]</a>
 The `sizeof` operator yields the number of bytes occupied by a
 non-potentially-overlapping object of the type of its operand. The
 operand is either an expression, which is an unevaluated operand
-[[expr.prop]], or a parenthesized *type-id*. The `sizeof` operator shall
-not be applied to an expression that has function or incomplete type, to
-the parenthesized name of such types, or to a glvalue that designates a
-bit-field. The result of `sizeof` applied to any of the narrow character
-types is `1`. The result of `sizeof` applied to any other fundamental
-type [[basic.fundamental]] is *implementation-defined*.
-[*Note 1*: In particular, `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
-[[basic.types]] for the definition of object
 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.
@@ -3652,11 +3911,11 @@ struct count {
 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
@@ -3664,21 +3923,21 @@ 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 [[expr.prop]], can throw an
-exception [[except.throw]].
 ``` bnf
 noexcept-expression:
   noexcept '(' expression ')'
 ```
@@ -3694,17 +3953,17 @@ 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, but not an abstract class type or array thereof (
-[[intro.object]], [[basic.types]], [[class.abstract]]).
 [*Note 1*: Because references are not objects, references cannot be
 created by *new-expression*s. — *end note*]
-[*Note 2*: The *type-id* may be a cv-qualified type, in which case the
 object created by the *new-expression* has a cv-qualified
 type. — *end note*]
 ``` bnf
 new-expression:
@@ -3810,27 +4069,10 @@ returning `int`).
 — *end example*]
 — *end note*]
-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 object is not an array, the result of the
-*new-expression* is a pointer to the object created.
-When the allocated object is an array (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 pointer to the
-initial element (if any) of the array.
-[*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*]
 The *attribute-specifier-seq* in a *noptr-new-declarator* appertains to
 the associated array type.
 Every *constant-expression* in a *noptr-new-declarator* shall be a
 converted constant expression [[expr.const]] of type `std::size_t` and
@@ -3842,12 +4084,12 @@ well-formed (because `n` is the *expression* of a
 `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
@@ -3862,12 +4104,12 @@ implicitly converted to `std::size_t`. The *expression* is erroneous if:
   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 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
     non-throwing exception specification [[except.spec]], the value of
     the *new-expression* is the null pointer value of the required
     result type;
@@ -3876,10 +4118,26 @@ 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.
 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
 storage by calling a deallocation function
 [[basic.stc.dynamic.deallocation]]. If the allocated type is a non-array
@@ -3887,28 +4145,28 @@ 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 may be called by a *new-expression* may
-include functions that do not perform allocation or deallocation; for
-example, see [[new.delete.placement]]. — *end note*]
-If the *new-expression* begins with a unary `::` operator, the
-allocation function’s name is looked up in the global scope. Otherwise,
-if the allocated type is a class type `T` or array thereof, the
-allocation function’s name is looked up in the scope of `T`. If this
-lookup fails to find the name, or if the allocated type is not a class
-type, the allocation function’s name is looked up in the 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.
@@ -4039,12 +4297,12 @@ from one invocation of `new` to another.
 — *end example*]
 [*Note 10*: Unless an allocation function has a non-throwing exception
 specification [[except.spec]], it indicates failure to allocate storage
-by throwing a `std::bad_alloc` exception (
-[[basic.stc.dynamic.allocation]], [[except]], [[bad.alloc]]); it returns
 a non-null pointer otherwise. If the allocation function has a
 non-throwing exception specification, it returns null to indicate
 failure to allocate storage and a non-null pointer
 otherwise. — *end note*]
@@ -4075,34 +4333,33 @@ 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 [[class.free]], 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 unambiguous
-matching deallocation function can be found, propagating the exception
-does not cause the object’s memory to be freed.
 [*Note 13*: This is appropriate when the called allocation function
 does not allocate memory; otherwise, it is likely to result in a memory
 leak. — *end note*]
-If the *new-expression* begins with a unary `::` operator, the
-deallocation function’s name is looked up in the global scope.
-Otherwise, if the allocated type is a class type `T` or an array
-thereof, the deallocation function’s name is looked up in the scope of
-`T`. If this lookup fails to find the name, or if the allocated type is
-not a class type or array thereof, the deallocation function’s name is
-looked up in the global scope.
 A declaration of a placement deallocation function matches the
 declaration of a placement allocation function if it has the same number
 of parameters and, after parameter transformations [[dcl.fct]], all
 parameter types except the first are identical. If the lookup finds a
@@ -4153,26 +4410,32 @@ 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*’s result 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
-to a non-array object created by a previous *new-expression*, or a
-pointer to a subobject [[intro.object]] representing a base class of
-such an object [[class.derived]]. 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*.[^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
 *new-expression*. — *end note*]
@@ -4180,17 +4443,17 @@ match the type of the object allocated by `new`, not the syntax of the
 *delete-expression*; it is not necessary to cast away the constness
 [[expr.const.cast]] of the pointer expression before it is used as the
 operand of the *delete-expression*. — *end note*]
 In a single-object delete expression, if the static type of the object
-to be deleted is different from its dynamic type and the selected
-deallocation function (see below) is not a destroying operator 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 differs from 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
@@ -4231,61 +4494,78 @@ exception. — *end note*]
 If the value of the operand of the *delete-expression* is a null pointer
 value, it is unspecified whether a deallocation function will be called
 as described above.
-[*Note 4*: An implementation provides default definitions of the global
-deallocation functions `operator delete` for non-arrays
-[[new.delete.single]] and `operator delete[]` for arrays
-[[new.delete.array]]. A C++ program can provide alternative definitions
-of these functions [[replacement.functions]], and/or class-specific
-versions [[class.free]]. — *end note*]
-When the keyword `delete` in a *delete-expression* is preceded by the
-unary `::` operator, the deallocation function’s name is looked up in
-global scope. Otherwise, the lookup considers class-specific
-deallocation functions [[class.free]]. If no class-specific deallocation
-function is found, the deallocation function’s name is looked up in
-global scope.
-If deallocation function lookup finds more than one usual deallocation
-function, 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
   type `std::align_val_t` is preferred; otherwise a function without
   such a parameter is preferred. If any preferred functions are found,
   all non-preferred functions are eliminated from further consideration.
 - If exactly one function remains, that function is selected and the
   selection process terminates.
-- If the deallocation functions have class scope, the one without a
-  parameter of type `std::size_t` is selected.
 - If the type is complete and if, for an array delete expression only,
   the operand is a pointer to a class type with a non-trivial destructor
-  or a (possibly multi-dimensional) 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
-denoted by the operand if its static type does not have a virtual
-destructor, and its most-derived object otherwise.
-[*Note 5*: If the deallocation function is not a destroying operator
 delete and the deleted object is not the most derived object in the
 former case, the behavior is undefined, as stated above. — *end note*]
 For an array delete expression, the deleted object is the array object.
 When a *delete-expression* is executed, the selected deallocation
 function shall be called with the address of the deleted object in a
 single-object delete expression, or the address of the deleted object
 suitably adjusted for the array allocation overhead [[expr.new]] in an
 array delete expression, as its first argument.
-[*Note 6*: Any cv-qualifiers in the type of the deleted object are
 ignored when forming this argument. — *end note*]
 If a destroying operator delete is used, an unspecified value is passed
 as the argument corresponding to the parameter of type
 `std::destroying_delete_t`. If a deallocation function with a parameter
@@ -4294,19 +4574,18 @@ deleted object is passed as the corresponding argument. If a
 deallocation function with a parameter of type `std::size_t` is used,
 the size of the deleted object in a single-object delete expression, or
 of the array plus allocation overhead in an array delete expression, is
 passed as the corresponding argument.
-[*Note 7*: If this results in a call to a replaceable deallocation
 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
@@ -4410,13 +4689,14 @@ 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 dynamic type of `E1` does not
-contain the member to which `E2` refers, the behavior is undefined.
-Otherwise, the expression `E1` is sequenced before the expression `E2`.
 The restrictions on cv-qualification, and the manner in which the
 cv-qualifiers of the operands are combined to produce the cv-qualifiers
 of the result, are the same as the rules for `E1.E2` given in
 [[expr.ref]].
@@ -4488,13 +4768,15 @@ 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
@@ -4535,30 +4817,41 @@ from an expression `P` of pointer type, the result has the type of `P`.
   (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.
 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 1*: 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.
-[*Note 2*: In particular, a pointer to a base class cannot be used for
-pointer arithmetic when the array contains objects of a derived class
-type. — *end note*]
 ### Shift operators <a id="expr.shift">[[expr.shift]]</a>
 The shift operators `<<` and `>>` group left-to-right.
@@ -4627,37 +4920,41 @@ Then:
 If both operands have the same enumeration type `E`, the operator yields
 the result of converting the operands to the underlying type of `E` and
 applying `<=>` to the converted operands.
-If at least one of the operands is of pointer type and the other operand
-is of pointer or array type, array-to-pointer conversions
 [[conv.array]], pointer conversions [[conv.ptr]], and qualification
 conversions [[conv.qual]] are performed on both operands to bring them
 to their composite pointer type [[expr.type]]. After the conversions,
 the operands shall have the same type.
 [*Note 1*: If both of the operands are arrays, array-to-pointer
 conversions [[conv.array]] are not applied. — *end note*]
-If the composite pointer type is an object pointer type, `p <=> q` is of
-type `std::strong_ordering`. If two pointer operands `p` and `q` compare
-equal [[expr.eq]], `p <=> q` yields `std::strong_ordering::equal`; if
-`p` and `q` compare unequal, `p <=> q` yields
   `std::strong_ordering::less` if `q` compares greater than `p` and
   `std::strong_ordering::greater` if `p` compares greater than `q`
-[[expr.rel]]. Otherwise, the result is unspecified.
 Otherwise, the program is ill-formed.
 The three comparison category types [[cmp.categories]] (the types
 `std::strong_ordering`, `std::weak_ordering`, and
-`std::partial_ordering`) are not predefined; if the header `<compare>`
-is not imported or included prior to a use of such a class type – even
-an implicit use in which the type is not named (e.g., via the `auto`
 specifier [[dcl.spec.auto]] in a defaulted three-way comparison
-[[class.spaceship]] or use of the built-in operator) – the program is
 ill-formed.
 ### Relational operators <a id="expr.rel">[[expr.rel]]</a>
 The relational operators group left-to-right.
@@ -4689,30 +4986,36 @@ 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
   subobjects thereof, the pointer to the element with the higher
   subscript is required to compare greater.
 - If two pointers point to different non-static data members of the same
   object, or to subobjects of such members, recursively, the pointer to
-  the later declared member is required to compare greater provided the
- two members have the same access control [[class.access]], neither
- member is a subobject of zero size, and their class is not a union.
 - Otherwise, neither pointer is required to compare greater than the
   other.
 If two operands `p` and `q` compare equal [[expr.eq]], `p<=q` and `p>=q`
 both yield `true` and `p<q` and `p>q` both yield `false`. Otherwise, if
-a pointer `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.
 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.
@@ -4850,11 +5153,11 @@ exclusive-or-expression:
 The `^` operator groups left-to-right. The operands shall be of integral
 or unscoped enumeration type. The usual arithmetic conversions
 [[expr.arith.conv]] are performed. Given the coefficients `xᵢ` and `yᵢ`
 of the base-2 representation [[basic.fundamental]] of the converted
 operands `x` and `y`, the coefficient `rᵢ` of the base-2 representation
-of the result `r` is 1 if either (but not both) of `xᵢ` and `yᵢ` are 1,
 and 0 otherwise.
 [*Note 1*: The result is the bitwise exclusive function of the
 operands. — *end note*]
@@ -4869,11 +5172,11 @@ inclusive-or-expression:
 The `|` operator groups left-to-right. The operands shall be of integral
 or unscoped enumeration type. The usual arithmetic conversions
 [[expr.arith.conv]] are performed. Given the coefficients `xᵢ` and `yᵢ`
 of the base-2 representation [[basic.fundamental]] of the converted
 operands `x` and `y`, the coefficient `rᵢ` of the base-2 representation
-of the result `r` is 1 if at least one of `xᵢ` and `yᵢ` are 1, and 0
 otherwise.
 [*Note 1*: The result is the bitwise inclusive function of the
 operands. — *end note*]
@@ -4958,14 +5261,15 @@ that determination. — *end note*]
 Attempts are made to form an implicit conversion sequence from an
 operand expression `E1` of type `T1` to a target type related to the
 type `T2` of the operand expression `E2` as follows:
 - If `E2` is an lvalue, the target type is “lvalue reference to `T2`”,
- subject to the constraint that in the conversion the reference must
-  bind directly [[dcl.init.ref]] to a glvalue.
 - If `E2` is an xvalue, the target type is “rvalue reference to `T2`”,
- subject to the constraint that the reference must 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
@@ -4997,11 +5301,11 @@ and it is a bit-field if the second or the third operand is a bit-field,
 or if both are bit-fields.
 Otherwise, the result is a prvalue. If the second and third operands do
 not have the same type, and either has (possibly cv-qualified) class
 type, overload resolution is used to determine the conversions (if any)
-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.
@@ -5041,11 +5345,11 @@ yield-expression:
 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
 enclosing coroutine [[dcl.fct.def.coroutine]], then the
 *yield-expression* is equivalent to the expression
-`co_await `*p*`.yield_value(`*e*`)`.
 [*Example 1*:
 ``` cpp
 template <typename T>
@@ -5062,14 +5366,14 @@ struct my_generator {
   iterator begin();
   iterator end();
 };
 my_generator<pair<int,int>> g1() {
-  for (int i = i; i < 10; ++i) co_yield {i,i};
 }
 my_generator<pair<int,int>> g2() {
-  for (int i = i; i < 10; ++i) co_yield make_pair(i,i);
 }
 auto f(int x = co_yield 5);     // error: yield-expression outside of function suspension context
 int a[] = { co_yield 1 };       // error: yield-expression outside of function suspension context
@@ -5102,12 +5406,12 @@ 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*:
-Code that must be executed because of an exception, but cannot
-completely handle the exception itself, can be written like this:
 ``` cpp
 try {
   // ...
 } catch (...) {     // catch all exceptions
@@ -5124,17 +5428,18 @@ If no exception is presently being handled, evaluating a
 ### 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 referring to the left operand. The
-result in all cases is a bit-field if the left operand is a bit-field.
-In all cases, the assignment is sequenced after the value computation of
-the right and left operands, and before the value computation of the
-assignment expression. The right operand is sequenced before the left
-operand. With respect to an indeterminately-sequenced function call, the
-operation of a compound assignment is a single evaluation.
 [*Note 1*: Therefore, a function call cannot intervene between the
 lvalue-to-rvalue conversion and the side effect associated with any
 single compound assignment operator. — *end note*]
@@ -5160,42 +5465,44 @@ If the right operand is an expression, it is implicitly converted
 When the left operand of an assignment operator is a bit-field that
 cannot represent the value of the expression, the resulting value of the
 bit-field is *implementation-defined*.
-A simple assignment whose left operand is of a volatile-qualified type
-is deprecated [[depr.volatile.type]] unless the (possibly parenthesized)
-assignment is a discarded-value expression or an unevaluated operand.
 The behavior of an expression of the form `E1 op= E2` is equivalent to
-`E1 = E1 op E2` except that `E1` is evaluated only once. Such
-expressions are deprecated if `E1` has volatile-qualified type; see
-[[depr.volatile.type]]. For `+=` and `-=`, `E1` shall either have
-arithmetic type or be a pointer to a possibly cv-qualified
-completely-defined object type. In all other cases, `E1` shall have
-arithmetic type.
 If the value being stored in an object is read via another object that
 overlaps in any way the storage of the first object, then the overlap
 shall be exact and the two objects shall have the same type, otherwise
 the behavior is undefined.
-[*Note 2*: 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 may 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;
@@ -5224,31 +5531,29 @@ left expression is sequenced before the right expression
 [[intro.execution]]. The type and value of the result are the type and
 value of the right operand; the result is of the same value category as
 its right operand, and is a bit-field if its right operand is a
 bit-field.
-In contexts where comma is given a special meaning,
-[*Example 1*: in lists of arguments to functions [[expr.call]] and
-lists of initializers [[dcl.init]] — *end example*]
-the comma operator as described in this subclause can appear only in
-parentheses.
-[*Example 2*:
 ``` cpp
 f(a, (t=3, t+2), c);
 ```
 has three arguments, the second of which has the value `5`.
 — *end example*]
-[*Note 1*: A comma expression appearing as the
-*expr-or-braced-init-list* of a subscripting expression [[expr.sub]] is
-deprecated; see [[depr.comma.subscript]]. — *end note*]
 ## Constant expressions <a id="expr.const">[[expr.const]]</a>
 Certain contexts require expressions that satisfy additional
 requirements as detailed in this subclause; other contexts have
@@ -5271,23 +5576,23 @@ A variable or temporary object `o` is *constant-initialized* if
   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 may 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 const-qualified integral or enumeration type.
-A constant-initialized potentially-constant variable is *usable in
-constant expressions* at a point P if its initializing declaration D is
 reachable from P and
-- it is constexpr,
-- it 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
@@ -5300,52 +5605,57 @@ An object or reference is *usable in constant expressions* if it is
 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;
-- an invocation of a non-constexpr function \[*Note 3*: Overload
- resolution [[over.match]] is applied as usual. — *end note*] ;
 - an invocation of an undefined constexpr function;
-- an invocation of an instantiated constexpr function that fails to
- satisfy the requirements for a constexpr function;
 - an invocation of a virtual function [[class.virtual]] for an object
- unless
-  - the object is usable in constant expressions or
-  - its lifetime began within the evaluation of E;
 - an expression that would exceed the implementation-defined limits (see
   [[implimits]]);
 - an operation that would have undefined behavior as specified in
-  [[intro]] through [[cpp]] of this document \[*Note 4*: including, for
-  example, signed integer overflow [[expr.prop]], certain pointer
-  arithmetic [[expr.add]], division by zero [[expr.mul]], or certain
-  shift operations [[expr.shift]] — *end note*] ;
 - 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 [[conv.lval]] that is applied to a
- glvalue that refers to a non-active member of a union or a subobject
-  thereof;
 - an lvalue-to-rvalue conversion that is applied to an object with an
   indeterminate value [[basic.indet]];
 - an invocation of an implicitly-defined copy/move constructor or
   copy/move assignment operator for a union whose active member (if any)
   is mutable, unless the lifetime of the union object began within the
   evaluation of E;
-- an *id-expression* that refers to a variable or data member of
-  reference type unless the reference has a preceding initialization and
-  either
-  - it is usable in constant expressions or
-  - its lifetime began within the 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 ([[basic.def.odr]],
-  [[expr.prim.lambda]]);
-  \[*Example 1*:
   ``` cpp
   void g() {
     const int n = 0;
     [=] {
       constexpr int i = n;        // OK, n is not odr-used here
@@ -5353,17 +5663,17 @@ would evaluate one of the following:
     };
   }
   ```
   — *end example*]
-  \[*Note 5*:
   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 2*:
   ``` cpp
   auto monad = [](auto v) { return [=] { return v; }; };
   auto bind = [](auto m) {
     return [=](auto fvm) { return fvm(m()); };
   };
@@ -5374,17 +5684,21 @@ would evaluate one of the following:
   — *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;
 - 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
@@ -5394,41 +5708,53 @@ would evaluate one of the following:
   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]] or a dynamic cast
- [[expr.dynamic.cast]] or `typeid` [[expr.typeid]] expression that
- would throw an exception;
-- an *asm-declaration* [[dcl.asm]]; or
-- an invocation of the `va_arg` macro [[cstdarg.syn]].
-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]] of this document, or an
-invocation of the `va_start` macro [[cstdarg.syn]], it is unspecified
-whether E is a core constant expression.
-[*Example 3*:
 ``` cpp
 int x;                              // not constant
 struct A {
   constexpr A(bool b) : m(b?42:x) { }
   int m;
 };
-constexpr int v = A(true).m;        // OK: constructor call initializes m with the value 42
 constexpr int w = A(false).m;       // error: initializer for m is x, which is non-constant
 constexpr int f1(int k) {
   constexpr int x = k;              // error: x is not initialized by a constant expression
                                     // because lifetime of k began outside the initializer of x
   return x;
 }
 constexpr int f2(int k) {
-  int x = k;                        // OK: not required to be a constant expression
                                     // because x is not constexpr
   return x;
 }
 constexpr int incr(int &n) {
@@ -5438,67 +5764,132 @@ constexpr int g(int k) {
   constexpr int x = incr(k);        // error: incr(k) is not a core constant expression
                                     // because lifetime of k began outside the expression incr(k)
   return x;
 }
 constexpr int h(int k) {
-  int x = incr(k);                  // OK: incr(k) is not required to be a core constant expression
   return x;
 }
-constexpr int y = h(1);             // OK: initializes y with the value 2
                                     // h(1) is a core constant expression because
                                     // the lifetime of k begins inside h(1)
 ```
 — *end example*]
 For the purposes of determining whether an expression E is a core
-constant expression, the evaluation of a call to a member function of
 `std::allocator<T>` as defined in [[allocator.members]], where `T` is a
-literal type, does not disqualify E from being a core constant
-expression, even if the actual evaluation of such a call would otherwise
-fail the requirements for a core constant expression. Similarly, the
-evaluation of a call to `std::destroy_at`, `std::ranges::destroy_at`,
-`std::construct_at`, or `std::ranges::construct_at` does not disqualify
-E from being a core constant expression unless:
-- for a call to `std::construct_at` or `std::ranges::construct_at`, the
-  first argument, of type `T*`, does not point to storage allocated with
-  `std::allocator<T>` or to an object whose lifetime began within the
-  evaluation of E, or the evaluation of the underlying constructor call
-  disqualifies E from being a core constant expression, or
-- for a call to `std::destroy_at` or `std::ranges::destroy_at`, the
-  first argument, of type `T*`, does not point to storage allocated with
-  `std::allocator<T>` or to an object whose lifetime began within the
-  evaluation of E, or the evaluation of the underlying destructor call
-  disqualifies E from being a core constant expression.
 An object `a` is said to have *constant destruction* if:
-- it is not of class type nor (possibly multi-dimensional) array
- thereof, or
-- it is of class type or (possibly multi-dimensional) 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 may 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 4*:
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
   constexpr operator int() const { return val; }
@@ -5530,11 +5921,11 @@ constant expression and the implicit conversion sequence contains only
   and
 - function pointer conversions [[conv.fctptr]],
 and where the reference binding (if any) binds directly.
-[*Note 7*: Such expressions may 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*]
@@ -5549,10 +5940,12 @@ 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 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
@@ -5563,11 +5956,15 @@ whose value satisfies the following constraints:
 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.
-[*Example 5*:
 ``` cpp
 consteval int f() { return 42; }
 consteval auto g() { return f; }
 consteval int h(int (*p)() = g()) { return p(); }
@@ -5576,19 +5973,23 @@ constexpr auto e = g();                         // error: a pointer to an immedi
                                                 // not a permitted result of a constant expression
 ```
 — *end example*]
-[*Note 8*:
 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.[^32]
-[*Example 6*:
 ``` 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
@@ -5601,27 +6002,121 @@ It is unspecified whether the value of `f()` will be `true` or `false`.
 — *end example*]
 — *end note*]
 An expression or conversion is in an *immediate function context* if it
-is potentially evaluated and its innermost non-block scope is a function
-parameter scope of an immediate function. An expression or conversion is
-an *immediate invocation* if it is a potentially-evaluated explicit or
-implicit invocation of an immediate function and is not in an immediate
-function context. An immediate invocation shall be a constant
-expression.
 An expression or conversion is *manifestly constant-evaluated* if it is:
 - a *constant-expression*, or
 - 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.[^33]
-  \[*Example 7*:
   ``` 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
@@ -5630,44 +6125,44 @@ An expression or conversion is *manifestly constant-evaluated* if it is:
   const int b = std::is_constant_evaluated() ? 2 : y;     // static initialization to 2
   int c = y + (std::is_constant_evaluated() ? 2 : y);     // dynamic initialization to y+y
   constexpr int f() {
     const int n = std::is_constant_evaluated() ? 13 : 17; // n is 13
-    int m = std::is_constant_evaluated() ? 13 : 17;       // m might be 13 or 17 (see below)
     char arr[n] = {}; // char[13]
     return m + sizeof(arr);
   }
   int p = f();                                            // m is 13; initialized to 26
   int q = p + f();                                        // m is 17 for this call; initialized to 56
   ```
   — *end example*]
-[*Note 9*: A manifestly constant-evaluated expression is evaluated even
-in an 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*, [^34]
 - an expression of the form `&` *cast-expression* that occurs within a
-  templated entity, [^35] or
-- a subexpression of one of the above that is not a subexpression of a
- nested unevaluated operand.
 A function or variable is *needed for constant evaluation* if it is:
 - a constexpr function that is named by an expression [[basic.def.odr]]
   that is potentially constant evaluated, or
-- a variable whose name appears as a potentially constant evaluated
- expression that is either a constexpr variable or is of non-volatile
-  const-qualified integral type or of reference type.
 <!-- Link reference definitions -->
-[allocator.members]: utilities.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
@@ -5675,23 +6170,26 @@ A function or variable is *needed for constant evaluation* if it is:
 [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.classref]: basic.md#basic.lookup.classref
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: #basic.lval
-[basic.namespace]: dcl.md#basic.namespace
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.class]: basic.md#basic.scope.class
 [basic.start.main]: basic.md#basic.start.main
 [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.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [basic.type.qualifier]: basic.md#basic.type.qualifier
-[basic.types]: basic.md#basic.types
 [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
@@ -5706,31 +6204,32 @@ 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]: class.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.qual]: basic.md#class.qual
 [class.spaceship]: class.md#class.spaceship
-[class.static]: class.md#class.static
 [class.temporary]: basic.md#class.temporary
-[class.this]: class.md#class.this
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [cmp.categories]: support.md#cmp.categories
 [conv]: #conv
 [conv.array]: #conv.array
 [conv.bool]: #conv.bool
 [conv.double]: #conv.double
 [conv.fctptr]: #conv.fctptr
 [conv.fpint]: #conv.fpint
 [conv.fpprom]: #conv.fpprom
 [conv.func]: #conv.func
 [conv.integral]: #conv.integral
 [conv.lval]: #conv.lval
 [conv.mem]: #conv.mem
 [conv.prom]: #conv.prom
 [conv.ptr]: #conv.ptr
@@ -5741,10 +6240,11 @@ A function or variable is *needed for constant evaluation* if it is:
 [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.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
@@ -5764,17 +6264,20 @@ A function or variable is *needed for constant evaluation* if it is:
 [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.cv]: dcl.md#dcl.type.cv
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [defns.access]: intro.md#defns.access
 [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.comma.subscript]: future.md#depr.comma.subscript
 [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
@@ -5803,26 +6306,30 @@ A function or variable is *needed for constant evaluation* if it is:
 [expr.mptr.oper]: #expr.mptr.oper
 [expr.mul]: #expr.mul
 [expr.new]: #expr.new
 [expr.or]: #expr.or
 [expr.post]: #expr.post
 [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.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.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.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
@@ -5837,10 +6344,11 @@ A function or variable is *needed for constant evaluation* if it is:
 [expr.throw]: #expr.throw
 [expr.type]: #expr.type
 [expr.type.conv]: #expr.type.conv
 [expr.typeid]: #expr.typeid
 [expr.unary]: #expr.unary
 [expr.unary.noexcept]: #expr.unary.noexcept
 [expr.unary.op]: #expr.unary.op
 [expr.xor]: #expr.xor
 [expr.yield]: #expr.yield
 [function.objects]: utilities.md#function.objects
@@ -5852,35 +6360,41 @@ A function or variable is *needed for constant evaluation* if it is:
 [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]: utilities.md#meta.const.eval
-[namespace.qual]: basic.md#namespace.qual
 [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.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
 [replacement.functions]: library.md#replacement.functions
 [special]: class.md#special
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.return]: stmt.md#stmt.return
 [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
@@ -5888,17 +6402,25 @@ A function or variable is *needed for constant evaluation* if it is:
 [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.names]: temp.md#temp.names
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
 [temp.variadic]: temp.md#temp.variadic
 [thread]: thread.md#thread
 [type.info]: support.md#type.info
 [^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
@@ -5907,11 +6429,11 @@ A function or variable is *needed for constant evaluation* if it is:
 [^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 may or may not 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]].
@@ -5925,23 +6447,23 @@ A function or variable is *needed for constant evaluation* if it is:
     be obtained.
 [^8]: The rule for conversion of pointers to members (from pointer to
     member of base to pointer to member of derived) appears inverted
     compared to the rule for pointers to objects (from pointer to
-    derived to pointer to base) ([[conv.ptr]], [[class.derived]]). This
     inversion is necessary to ensure type safety. Note that a pointer to
     member is not an object pointer or a function pointer and the rules
     for conversions of such pointers do not apply to pointers to
     members. In particular, a pointer to member cannot be converted to a
     `void*`.
 [^9]: As a consequence, operands of type `bool`, `char8_t`, `char16_t`,
-    `char32_t`, `wchar_t`, or an enumerated 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
@@ -5958,38 +6480,37 @@ A function or variable is *needed for constant evaluation* if it is:
 [^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 may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^18]: `T1` and `T2` may 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 may 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 may 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.
@@ -6017,17 +6538,19 @@ A function or variable is *needed for constant evaluation* if it is:
 [^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]: Nonetheless, implementations should provide consistent results,
-    irrespective of whether the evaluation was performed during
-    translation and/or during program execution.
-[^33]: Testing this condition may involve a trial evaluation of its
     initializer as described above.
-[^34]: Constant evaluation may be necessary to determine whether a
-    narrowing conversion is performed [[dcl.init.list]].
-[^35]: Constant evaluation may be necessary to determine whether such an
-    expression is value-dependent [[temp.dep.constexpr]].

 # Expressions <a id="expr">[[expr]]</a>
 ## Preamble <a id="expr.pre">[[expr.pre]]</a>
+[*Note 1*:
+[[expr]] defines the syntax, order of evaluation, and meaning of
+expressions.[^1]
+An expression is a sequence of operators and operands that specifies a
+computation. An expression can result in a value and can cause side
+effects.
+— *end note*]
 [*Note 2*: Operators can be overloaded, that is, given meaning when
 applied to expressions of class type [[class]] or enumeration type
 [[dcl.enum]]. Uses of overloaded operators are transformed into function
 calls as described in  [[over.oper]]. Overloaded operators obey the
 zero divisor, and all floating-point exceptions varies among machines,
 and is sometimes adjustable by a library function. — *end note*]
 [*Note 4*:
+The implementation can regroup operators according to the usual
 mathematical rules only where the operators really are associative or
+commutative.[^2]
+For example, in the following fragment
 ``` cpp
 int a, b;
 ...
 a = a + 32760 + b + 5;
 <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
 [*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]],
 - a class member access expression designating a non-static data member
   of non-reference type in which the object expression is an xvalue
   [[expr.ref]], or
 - a `.*` pointer-to-member expression in which the first operand is an
 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]
 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
 - 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
   member of `C1` of type function”, respectively;
 - if `T1` is “pointer to member of `C1` of type *cv1* `U`” and `T2` is
   “pointer to member of `C2` of type *cv2* `U`”, for some non-function
   type `U`, where `C1` is reference-related to `C2` or `C2` is
+  reference-related to `C1` [[dcl.init.ref]], the qualification-combined
+ type of `T2` and `T1` or the qualification-combined type of `T1` and
+ `T2`, respectively;
+- if `T1` and `T2` are similar types [[conv.qual]], the
+  qualification-combined type of `T1` and `T2`;
 - otherwise, a program that necessitates the determination of a
   composite pointer type is ill-formed.
 [*Example 1*:
 — *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
 unevaluated operand is considered a full-expression
 [[intro.execution]]. — *end note*]
   these expressions.
 [*Note 2*: Using an overloaded operator causes a function call; the
 above covers only operators with built-in meaning. — *end note*]
+The temporary materialization conversion [[conv.rval]] is applied if the
+(possibly converted) expression is a prvalue of object type.
+[*Note 3*: If the original expression is an lvalue of class type, it
+must have a volatile copy constructor to initialize the temporary object
+that is the result object of the temporary materialization
+conversion. — *end note*]
+The expression is evaluated and its result (if any) is discarded.
 ## Standard conversions <a id="conv">[[conv]]</a>
+### General <a id="conv.general">[[conv.general]]</a>
 Standard conversions are implicit conversions with built-in meaning.
 [[conv]] enumerates the full set of such conversions. A *standard
 conversion sequence* is a sequence of standard conversions in the
 following order:
 the descriptions of those operators and contexts. — *end note*]
 ### Lvalue-to-rvalue conversion <a id="conv.lval">[[conv.lval]]</a>
 A glvalue [[basic.lval]] of a non-function, non-array type `T` can be
+converted to a prvalue.[^5]
+If `T` is an incomplete type, a program that necessitates this
+conversion is ill-formed. If `T` is a non-class type, the type of the
+prvalue is the cv-unqualified version of `T`. Otherwise, the type of the
+prvalue is `T`.[^6]
 When an lvalue-to-rvalue conversion is applied to an expression E, and
 either
 - E is not potentially evaluated, or
   `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*]
 — *end example*]
 ### Qualification conversions <a id="conv.qual">[[conv.qual]]</a>
+A *qualification-decomposition* of a type `T` is a sequence of cvᵢ and
+Pᵢ such that `T` is
 where each cvᵢ is a set of cv-qualifiers [[basic.type.qualifier]], and
 each Pᵢ is “pointer to” [[dcl.ptr]], “pointer to member of class Cᵢ of
 type” [[dcl.mptr]], “array of Nᵢ”, or “array of unknown bound of”
 [[dcl.array]]. If Pᵢ designates an array, the cv-qualifiers cvᵢ₊₁ on the
 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.
+The *qualification-combined type* of two types `T1` and `T2` is the type
+`T3` similar to `T1` whose qualification-decomposition is such that:
+- for every i > 0, cv³ᵢ is the union of cv¹ᵢ and cv²ᵢ,
 - if either P¹ᵢ or P²ᵢ is “array of unknown bound of”, P³ᵢ is “array of
+  unknown bound of”, otherwise it is P¹ᵢ, and
 - if the resulting cv³ᵢ is different from cv¹ᵢ or cv²ᵢ, or the resulting
   P³ᵢ is different from P¹ᵢ or P²ᵢ, then `const` is added to every cv³ₖ
+  for 0 < k < i,
+where cvʲᵢ and Pʲᵢ are the components of the qualification-decomposition
+of `T`j. A prvalue of type `T1` can be converted to type `T2` if the
+qualification-combined type of `T1` and `T2` is `T2`.
 [*Note 1*:
 If a program could assign a pointer of type `T**` to a pointer of type
 `const` `T**` (that is, if line \#1 below were allowed), a program could
 ```
 — *end note*]
 [*Note 2*: Given similar types `T1` and `T2`, this construction ensures
+that both can be converted to the qualification-combined type of `T1`
+and `T2`. — *end note*]
 [*Note 3*: A prvalue of type “pointer to *cv1* `T`” can be converted to
 a prvalue of type “pointer to *cv2* `T`” if “*cv2* `T`” is more
 cv-qualified than “*cv1* `T`”. A prvalue of type “pointer to member of
 `X` of type *cv1* `T`” can be converted to a prvalue of type “pointer to
 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`,
 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*.
 of integral conversions.
 ### Floating-point conversions <a id="conv.double">[[conv.double]]</a>
 A prvalue of floating-point type can be converted to a prvalue of
+another floating-point type with a greater or equal conversion rank
+[[conv.rank]]. A prvalue of standard floating-point type can be
+converted to a prvalue of another standard floating-point type.
+If the source value can be exactly represented in the destination type,
+the result of the conversion is that exact representation. If the source
+value is between two adjacent destination values, the result of the
+conversion is an *implementation-defined* choice of either of those
+values. Otherwise, the behavior is undefined.
 The conversions allowed as floating-point promotions are excluded from
 the set of floating-point conversions.
 ### Floating-integral conversions <a id="conv.fpint">[[conv.fpint]]</a>
 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
+ operand of the type with the lesser floating-point conversion rank
+ is converted to the type of the other operand.
+  - Otherwise, if the floating-point conversion ranks of the types of
+    the operands are equal, then the operand with the lesser
+ floating-point conversion subrank [[conv.rank]] is converted to the
+    type of the other operand.
+  - Otherwise, the expression is ill-formed.
+- Otherwise, each operand is converted to a common type `C`. The
+  integral promotion rules [[conv.prom]] are used to determine a type
+  `T1` and type `T2` for each operand.[^9]
+  Then the following rules are applied to determine `C`:
+  - If `T1` and `T2` are the same type, `C` is that type.
+  - Otherwise, if `T1` and `T2` are both signed integer types or are
+    both unsigned integer types, `C` is the type with greater rank.
+  - Otherwise, let `U` be the unsigned integer type and `S` be the
+    signed integer type.
+    - If `U` has rank greater than or equal to the rank of `S`, `C` is
+      `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]].
     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
+[[lex.literal]]. A *string-literal* is an lvalue designating a
+corresponding string literal object [[lex.string]], a
+*user-defined-literal* has the same value category as the corresponding
+operator call expression described in [[lex.ext]], and any other
+*literal* is a prvalue.
 ### This <a id="expr.prim.this">[[expr.prim.this]]</a>
+The keyword `this` names a pointer to the object for which an implicit
+object member function [[class.mfct.non.static]] is invoked or a
+non-static data member’s initializer [[class.mem]] is evaluated.
+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*:
 In a *trailing-return-type*, the class being defined is not required to
 be complete for purposes of class member access [[expr.ref]]. Class
 members declared later are not visible.
 — *end note*]
 Otherwise, if a *member-declarator* declares a non-static data member
 [[class.mem]] of a class `X`, the expression `this` is a prvalue of type
+“pointer to `X`” wherever `X` is the current class within the optional
+default member initializer [[class.mem]].
 The expression `this` shall not appear in any other context.
 [*Example 2*:
 ``` cpp
 class Outer {
   int a[sizeof(*this)];                 // error: not inside a member function
+  unsigned int sz = sizeof(*this);      // OK, in default member initializer
   void f() {
     int b[sizeof(*this)];               // OK
     struct Inner {
 — *end example*]
 ### Parentheses <a id="expr.prim.paren">[[expr.prim.paren]]</a>
 A parenthesized expression `(E)` is a primary expression whose type,
+result, and value category are identical to those of E. The
+parenthesized expression can be used in exactly the same contexts as
+those where E can be used, and with the same meaning, except as
+otherwise indicated.
 ### Names <a id="expr.prim.id">[[expr.prim.id]]</a>
+#### General <a id="expr.prim.id.general">[[expr.prim.id.general]]</a>
 ``` 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;
+};
 void g() {
   A<int>::f(0);                         // error: cannot call f
   void (*p1)(int) = A<int>::f;          // error: cannot take the address of f
   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*]
 *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.
+[*Note 2*: Other constructs that contain names to look up can have
+several component names
+[[expr.prim.id.qual]], [[dcl.type.simple]], [[dcl.type.elab]], [[dcl.mptr]], [[namespace.udecl]], [[temp.param]], [[temp.names]], [[temp.res]]. — *end note*]
+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;
+  [=]() -> decltype((x)) {      // lambda returns float const& because this lambda is not mutable and
+                                // x is an lvalue
     decltype(x) y1;             // y1 has type float
+    decltype((x)) y2 = y1;      // y2 has type float const&
     decltype(r) r1 = y1;        // r1 has type float&
     decltype((r)) r2 = y2;      // r2 has type float const&
+    return y2;
+  };
+  [=](decltype((x)) y) {
+    decltype((x)) z = x;        // OK, y has type float&, z has type float const&
+  };
+  [=] {
+    [](decltype((x)) y) {};     // OK, lambda takes a parameter of type float const&
+    [x=1](decltype((x)) y) {
+      decltype((x)) z = x;      // OK, y has type int&, z has type int const&
+    };
   };
 }
 ```
 — *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:
     nested-name-specifier templateₒₚₜ unqualified-id
     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*.
 If the *id-expression* names a pseudo-destructor, `T` shall be a scalar
 type and the *id-expression* shall appear as the right operand of a
 class member access [[expr.ref]] that forms the *postfix-expression* of
 a function call [[expr.call]].
+[*Note 1*: Such a call ends the lifetime of the object
+[[expr.call]], [[basic.life]]. — *end note*]
 [*Example 1*:
 ``` cpp
 struct C { };
 — *end example*]
 ### Lambda expressions <a id="expr.prim.lambda">[[expr.prim.lambda]]</a>
+#### General <a id="expr.prim.lambda.general">[[expr.prim.lambda.general]]</a>
 ``` bnf
 lambda-expression:
+    lambda-introducer attribute-specifier-seqₒₚₜ lambda-declarator compound-statement
+    lambda-introducer '<' template-parameter-list '>' requires-clauseₒₚₜ attribute-specifier-seqₒₚₜ
+       lambda-declarator compound-statement
 ```
 ``` bnf
 lambda-introducer:
     '[' lambda-captureₒₚₜ ']'
 ```
 ``` 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
+    constexpr
+    mutable
+    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.
 *closure object*.
 [*Note 1*: A closure object behaves like a function object
 [[function.objects]]. — *end note*]
+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
+*lambda-specifier-seq* shall be `mutable` or `static`. The
+*lambda-specifier-seq* shall not contain both `mutable` and `static`. If
+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;
+auto x3 = [&]()->auto&& { return j; }; // OK, return type is int&
 ```
 — *end example*]
 A lambda is a *generic lambda* if the *lambda-expression* has any
 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>
 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
+be an abbreviated function template [[dcl.fct]]. — *end note*]
 [*Example 1*:
 ``` cpp
 auto glambda = [](auto a, auto&& b) { return a < b; };
 bool b = glambda(3, 3.14);                                      // OK
 auto vglambda = [](auto printer) {
+  return [=](auto&& ... ts) {                                   // OK, ts is a function parameter pack
     printer(std::forward<decltype(ts)>(ts)...);
     return [=]() {
       printer(ts ...);
     };
   };
 };
 auto p = vglambda( [](auto v1, auto v2, auto v3)
                    { std::cout << v1 << v2 << v3; } );
+auto q = p(1, 'a', 3.14);                                       // OK, outputs 1a3.14
+q();                                                            // OK, outputs 1a3.14
+auto fact = [](this auto self, int n) -> int {                  // OK, explicit object parameter
+  return (n <= 1) ? 1 : n * self(n-1);
+};
+std::cout << fact(5);                                           // OK, outputs 120
+```
+— *end example*]
+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
+struct C {
+  template <typename T>
+  C(T);
+};
+void func(int i) {
+  int x = [=](this auto&&) { return i; }();     // OK
+  int y = [=](this C) { return i; }();          // error
+  int z = [](this C) { return 42; }();          // OK
+}
 ```
 — *end example*]
+The function call operator or operator template is a static member
+function or static member function template [[class.static.mfct]] if the
+*lambda-expression*’s *parameter-declaration-clause* is followed by
+`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
+constexpr function if either the corresponding *lambda-expression*'s
+*parameter-declaration-clause* is followed by `constexpr` or
+`consteval`, or it is constexpr-suitable [[dcl.constexpr]]. It is an
 immediate function [[dcl.constexpr]] if the corresponding
 *lambda-expression*'s *parameter-declaration-clause* is followed by
 `consteval`.
+[*Example 3*:
 ``` cpp
 auto ID = [](auto a) { return a; };
 static_assert(ID(3) == 3);                      // OK
 static_assert(ID(NonLiteral{3}).n == 3);        // error
 ```
 — *end example*]
+[*Example 4*:
 ``` cpp
 auto monoid = [](auto v) { return [=] { return v; }; };
 auto add = [](auto m1) constexpr {
   auto ret = m1();
 static_assert(add(one)(one)() == monoid(2)());  // OK
 ```
 — *end example*]
+[*Note 3*:
+The function call operator or operator template can be constrained
 [[temp.constr.decl]] by a *type-constraint* [[temp.param]], a
 *requires-clause* [[temp.pre]], or a trailing *requires-clause*
 [[dcl.decl]].
+[*Example 5*:
 ``` cpp
 template <typename T> concept C1 = ...;
 template <std::size_t N> concept C2 = ...;
 template <typename A, typename B> concept C3 = ...;
 *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
 };
 ```
 — *end note*]
+[*Example 6*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 auto glambda = [](auto a) { return a; };
 f1(glambda);                    // OK
 f2(glambda);                    // error: ID is not convertible
 g(glambda);                     // error: ambiguous
+h(glambda);                     // OK, calls #3 since it is convertible from ID
 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)
 ```
 — *end example*]
 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; };
 ```
 — *end example*]
 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);
 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]].
 A member of a closure type shall not be explicitly instantiated
 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
 *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*.
+If an *identifier* in a *capture* appears as the *declarator-id* of a
+parameter of the *lambda-declarator*’s *parameter-declaration-clause* or
+as the name of a template parameter of the *lambda-expression*’s
+*template-parameter-list*, the program is ill-formed.
 [*Example 2*:
 ``` cpp
 void f() {
   int x = 0;
+  auto g = [x](int x) { return 0; };    // error: parameter and capture have the same name
+  auto h = [y = 0]<typename y>(y) { return 0; };    // error: template parameter and capture
+                                                    // have the same name
 }
 ```
 — *end example*]
+An *init-capture* inhabits the lambda scope [[basic.scope.lambda]] of
+the *lambda-expression*. An *init-capture* without ellipsis behaves as
+if it declares and explicitly captures a variable of the form “`auto`
+*init-capture* `;`”, except that:
 - if the capture is by copy (see below), the non-static data member
   declared for the capture and the variable are treated as two different
   ways of referring to the same object, which has the lifetime of the
   non-static data member, and no additional copy and destruction is
 auto y = [&r = x, x = x+1]()->int {
             r += 2;
             return x+2;
          }();                               // Updates ::x to 6, and initializes y to 7.
+auto z = [a = 42](int a) { return 1; };     // error: parameter and conceptual local variable have the same name
+auto counter = [i=0]() mutable -> decltype(i) {     // OK, returns int
+  return i++;
+};
 ```
 — *end example*]
 For the purposes of lambda capture, an expression potentially references
   *id-expression*. — *end note*]
 - A `this` expression potentially references `*this`.
 - A *lambda-expression* potentially references the local entities named
   by its *simple-capture*s.
+If an expression potentially references a local entity within a scope in
+which it is odr-usable [[basic.def.odr]], and the expression would be
+potentially evaluated if the effect of any enclosing `typeid`
 expressions [[expr.typeid]] were ignored, the entity is said to be
 *implicitly captured* by each intervening *lambda-expression* with an
 associated *capture-default* that does not explicitly capture it. The
 implicit capture of `*this` is deprecated when the *capture-default* is
 `=`; see [[depr.capture.this]].
 void f(int, const int (&)[2] = {});         // #1
 void f(const int&, const int (&)[1]);       // #2
 void test() {
   const int x = 17;
   auto g = [](auto a) {
+    f(x);                       // OK, calls #1, does not capture x
   };
   auto g1 = [=](auto a) {
+    f(x);                       // OK, calls #1, captures x
   };
   auto g2 = [=](auto a) {
     int selector[sizeof(a) == 1 ? 1 : 2]{};
+    f(x, selector);             // OK, captures x, can call #1 or #2
   };
   auto g3 = [=](auto a) {
     typeid(a + x);              // captures x regardless of whether a + x is an unevaluated operand
   };
 }
 ```
+Within `g1`, an implementation can optimize away the capture of `x` as
 it is not odr-used.
 — *end example*]
 [*Note 4*:
 The set of captured entities is determined syntactically, and entities
+are implicitly captured even if the expression denoting a local entity
+is within a discarded statement [[stmt.if]].
 [*Example 5*:
 ``` cpp
 template<bool B>
 — *end example*]
 — *end note*]
 An entity is *captured* if it is captured explicitly or implicitly. An
+entity captured by a *lambda-expression* is odr-used [[term.odr.use]] by
+the *lambda-expression*.
 [*Note 5*: As a consequence, if a *lambda-expression* explicitly
 captures an entity that is not odr-usable, the program is ill-formed
 [[basic.def.odr]]. — *end note*]
 void f1(int i) {
   int const N = 20;
   auto m1 = [=]{
     int const M = 30;
     auto m2 = [i]{
+      int x[N][M];              // OK, N and M are not odr-used
+      x[0][0] = i;              // OK, i is explicitly captured by m2 and implicitly captured by m1
     };
   };
   struct s1 {
     int f;
     void work(int n) {
       int m = n*n;
       int j = 40;
       auto m3 = [this,m] {
         auto m4 = [&,j] {       // error: j not odr-usable due to intervening lambda m3
           int x = n;            // error: n is odr-used but not odr-usable due to intervening lambda m3
+          x += m;               // OK, m implicitly captured by m4 and explicitly captured by m3
           x += i;               // error: i is odr-used but not odr-usable
                                 // due to intervening function and class scopes
+          x += f;               // OK, this captured implicitly by m4 and explicitly by m3
         };
       };
     }
   };
 }
 referenced function type if the entity is a reference to a function, or
 the type of the corresponding captured entity otherwise. A member of an
 anonymous union shall not be captured by copy.
 Every *id-expression* within the *compound-statement* of a
+*lambda-expression* that is an odr-use [[term.odr.use]] of an entity
 captured by copy is transformed into an access to the corresponding
 unnamed data member of the closure type.
 [*Note 7*: An *id-expression* that is not an odr-use refers to the
 original entity, never to a member of the closure type. However, such an
 ``` 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
   };
 }
 ```
 If a *lambda-expression* `m2` captures an entity and that entity is
 captured by an immediately enclosing *lambda-expression* `m1`, then
 `m2`’s capture is transformed as follows:
+- If `m1` captures the entity by copy, `m2` captures the corresponding
+  non-static data member of `m1`’s closure type; if `m1` is not
+ `mutable`, the non-static data member is considered to be
+  const-qualified.
+- If `m1` captures the entity by reference, `m2` captures the same
   entity captured by `m1`.
 [*Example 11*:
 The nested *lambda-expression*s and invocations below will output
 corresponding *lambda-expression* after the lifetime of the entity has
 ended is likely to result in undefined behavior. — *end note*]
 A *simple-capture* containing an ellipsis is a pack expansion
 [[temp.variadic]]. An *init-capture* containing an ellipsis is a pack
+expansion that declares an *init-capture* pack [[temp.variadic]].
 [*Example 12*:
 ``` cpp
 template<class... 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
 on template arguments that can be checked by name lookup
 [[basic.lookup]] or by checking properties of types and expressions.
 ``` bnf
     requires requirement-parameter-listₒₚₜ requirement-body
 ```
 ``` bnf
 requirement-parameter-list:
+    '(' parameter-declaration-clause ')'
 ```
 ``` bnf
 requirement-body:
     '{' requirement-seq '}'
 ```
 ``` bnf
 requirement-seq:
     requirement
+    requirement requirement-seq
 ```
 ``` bnf
 requirement:
     simple-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:
 — *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.
 };
 ```
 — *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
 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 =
 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*]
 A *type-requirement* that names a class template specialization does not
+require that type to be complete [[term.incomplete.type]].
 #### Compound requirements <a id="expr.prim.req.compound">[[expr.prim.req.compound]]</a>
 ``` bnf
 compound-requirement:
 - If the *return-type-requirement* is present, then:
   - Substitution of template arguments (if any) into the
     *return-type-requirement* is performed.
   - The immediately-declared constraint [[temp.param]] of the
     *type-constraint* for `decltype((E))` shall be satisfied.
   \[*Example 1*:
   Given concepts `C` and `D`,
   ``` cpp
   requires {
     { E1 } -> C;
 `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>
 Postfix expressions group left-to-right.
 ``` bnf
 postfix-expression:
     primary-expression
+    postfix-expression '[' expression-listₒₚₜ ']'
     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 ')'
     const_cast '<' type-id '>' '(' expression ')'
     typeid '(' expression ')'
 expression-list:
     initializer-list
 ```
 [*Note 1*: The `>` token following the *type-id* in a `dynamic_cast`,
+`static_cast`, `reinterpret_cast`, or `const_cast` can be the product of
+replacing a `>>` token by two consecutive `>` tokens
 [[temp.names]]. — *end note*]
 #### Subscripting <a id="expr.sub">[[expr.sub]]</a>
+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.
+[*Note 1*: Despite its asymmetric appearance, subscripting is a
 commutative operation except for sequencing. See  [[expr.unary]] and
 [[expr.add]] for details of `*` and `+` and  [[dcl.array]] for details
 of array types. — *end note*]
 #### Function call <a id="expr.call">[[expr.call]]</a>
 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.
 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
 *virtual function call*.
+[*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
 `virtual` keyword), even if the type of the function actually called is
+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]],
 [[class.access.base]], and  [[expr.ref]]. — *end note*]
 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
 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
 default arguments [[dcl.fct.default]]) or more arguments (by using the
 ellipsis, `...`, or a function parameter pack [[dcl.fct]]) than the
 number of parameters in the function definition [[dcl.fct.def]].
 by a *braced-init-list* (the initializer) constructs a value of the
 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 {};
+void f(A&);             // #1
+void f(A&&);            // #2
+A& g();
+void h() {
+  f(g());               // calls #1
+  f(A(g()));            // calls #2 with a temporary object
+  f(auto(g()));         // calls #2 with a temporary object
+}
+```
+— *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*]
 Otherwise, the object expression shall be of class type. The class type
 shall be complete unless the class member access appears in the
 definition of that class.
+[*Note 3*: The program is ill-formed if the result differs from that
+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*
   *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 {};
+void f() {
+  D d;
+  static_cast<B&>(d).j;             // OK, object expression designates the B subobject of d
+  reinterpret_cast<B&>(d).j;        // undefined behavior
+}
+```
+— *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
 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
 [[expr.pre.incr]]. — *end note*]
 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*:
 ``` cpp
 struct B { };
 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`.
+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
 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
 [[conv.func]] conversions are not applied to the expression. If the
 expression is a prvalue, the temporary materialization conversion
 [[conv.rval]] is applied. The expression is an unevaluated operand
+[[term.unevaluated.operand]].
 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
 typeid(D)  == typeid(const D&); // yields true
 ```
 — *end example*]
+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>
 static_cast<D&>(br);            // produces lvalue denoting the original d object
 ```
 — *end example*]
+An lvalue of type `T1` can be cast to type “rvalue reference to `T2`” if
+`T2` is reference-compatible with `T1` [[dcl.init.ref]]. If the value is
+not a bit-field, the result refers to the object or the specified base
+class subobject thereof; otherwise, the lvalue-to-rvalue conversion
+[[conv.lval]] is applied to the bit-field and the resulting prvalue is
+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
 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
 that of converting from the original value to the floating-point type.
 A value of integral or enumeration type can be explicitly converted to a
 complete enumeration type. If the enumeration type has a fixed
 underlying type, the value is first converted to that type by integral
+promotion [[conv.prom]] or integral conversion [[conv.integral]], if
+necessary, and then to the enumeration type. If the enumeration type
+does not have a fixed underlying type, the value is unchanged if the
+original value is within the range of the enumeration values
+[[dcl.enum]], and otherwise, the behavior is undefined. A value of
+floating-point type can also be explicitly converted to an enumeration
+type. The resulting value is the same as converting the original value
+to the underlying type of the enumeration [[conv.fpint]], and
+subsequently to the enumeration type.
+A prvalue of floating-point type can be explicitly converted to any
+other floating-point type. If the source value can be exactly
+represented in the destination type, the result of the conversion has
+that exact representation. If the source value is between two adjacent
+destination values, the result of the conversion is an
+*implementation-defined* choice of either of those values. Otherwise,
+the behavior is undefined.
 A prvalue of type “pointer to *cv1* `B`”, where `B` is a class type, can
 be converted to a prvalue of type “pointer 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. The
 null pointer value [[basic.compound]] is converted to the null pointer
 value of the destination type. If the prvalue of type “pointer to *cv1*
+`B`” points to a `B` that is actually a base class subobject of an
+object of type `D`, the resulting pointer points to the enclosing object
+of type `D`. Otherwise, the behavior is undefined.
 A prvalue of type “pointer to member of `D` of type *cv1* `T`” can be
 converted to a prvalue of type “pointer to member of `B` of type *cv2*
 `T`”, where `D` is a complete class type and `B` is a base class
 [[class.derived]] of `D`, if *cv2* is the same cv-qualification as, or
 greater cv-qualification than, *cv1*.
+[*Note 5*: Function types (including those used in
 pointer-to-member-function types) are never cv-qualified
 [[dcl.fct]]. — *end note*]
 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
 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*]
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
 *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;
 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
 function type [[dcl.fct]] that is not the same as the type used in the
 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*]
 Converting a function pointer to an object pointer type or vice versa is
 conditionally-supported. The meaning of such a conversion is
 *implementation-defined*, except that if an implementation supports
 conversions in both directions, converting a prvalue of one type to the
 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:
 - Converting a prvalue of type “pointer to member function” to a
   different pointer-to-member-function type and back to its original
   type yields the original pointer-to-member value.
 - Converting a prvalue of type “pointer to data member of `X` of type
 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
 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*]
 A conversion from a type `T1` to a type `T2` *casts away constness* if
+`T1` and `T2` are different, there is a qualification-decomposition
+[[conv.qual]] of `T1` yielding *n* such that `T2` has a
+qualification-decomposition of the form
 and there is no qualification conversion that converts `T1` to
 Casting from an lvalue of type `T1` to an lvalue of type `T2` using an
 lvalue reference cast or casting from an expression of type `T1` to an
 xvalue of type `T2` using an rvalue reference cast casts away constness
 if a cast from a prvalue of type “pointer to `T1`” to the type “pointer
 to `T2`” casts away constness.
 [*Note 3*: Some conversions which involve only changes in
+cv-qualification cannot be done using `const_cast`. For instance,
 conversions between pointers to functions are not covered because such
 conversions lead to values whose use causes undefined behavior. For the
 same reasons, conversions between pointers to member functions, and in
 particular, the conversion from a pointer to a const member function to
 a pointer to a non-const member function, are not
 covered. — *end note*]
 ### Unary expressions <a id="expr.unary">[[expr.unary]]</a>
+#### General <a id="expr.unary.general">[[expr.unary.general]]</a>
 Expressions with unary operators group right-to-left.
 ``` bnf
+%% Ed. note: character protrusion would misalign operators.
 unary-expression:
     postfix-expression
     unary-operator cast-expression
     '++' cast-expression
+    '--' cast-expression
     await-expression
     sizeof unary-expression
     sizeof '(' type-id ')'
     sizeof '...' '(' identifier ')'
     alignof '(' type-id ')'
     new-expression
     delete-expression
 ```
 ``` bnf
+%% Ed. note: character protrusion would misalign operators.
 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; };
 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>
 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*]
 ```
 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]]
   of the enclosing coroutine and `P` is the type of that object.
+- Unless the *await-expression* was implicitly produced by a
+  *yield-expression* [[expr.yield]], an initial await expression, or a
+  final await expression [[dcl.fct.def.coroutine]], a search is
+ performed for the name `await_transform` in the scope of `P`
+  [[class.member.lookup]]. If this search is performed and finds at
+  least one declaration, then *a* is
   *p*`.await_transform(`*cast-expression*`)`; otherwise, *a* is the
   *cast-expression*.
 - *o* is determined by enumerating the applicable `operator co_await`
   functions for an argument *a* [[over.match.oper]], and choosing the
   best one through overload resolution [[over.match]]. If overload
 - If the result of *await-ready* is `false`, the coroutine is considered
   suspended. Then:
   - If the type of *await-suspend* is `std::coroutine_handle<Z>`,
     *await-suspend*`.resume()` is evaluated. \[*Note 1*: This resumes
     the coroutine referred to by the result of *await-suspend*. Any
+    number of coroutines can be successively resumed in this fashion,
     eventually returning control flow to the current coroutine caller or
     resumer [[dcl.fct.def.coroutine]]. — *end note*]
   - Otherwise, if the type of *await-suspend* is `bool`, *await-suspend*
     is evaluated, and the coroutine is resumed if the result is `false`.
   - Otherwise, *await-suspend* is evaluated.
   If the evaluation of *await-suspend* exits via an exception, the
   exception is caught, the coroutine is resumed, and the exception is
+  immediately rethrown [[except.throw]]. Otherwise, control flow returns
+  to the current coroutine caller or resumer [[dcl.fct.def.coroutine]]
+  without exiting any scopes [[stmt.jump]]. The point in the coroutine
+  immediately prior to control returning to its caller or resumer is a
+  coroutine *suspend point*.
 - If the result of *await-ready* is `true`, or when the coroutine is
+  resumed other than by rethrowing an exception from *await-suspend*,
+  the *await-resume* expression is evaluated, and its result is the
+  result of the *await-expression*.
+[*Note 2*: With respect to sequencing, an *await-expression* is
+indivisible [[intro.execution]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template <typename T>
 using namespace std::chrono;
 my_future<int> h();
 my_future<void> g() {
+  std::cout << "just about to go to sleep...\n";
   co_await 10ms;
   std::cout << "resumed\n";
   co_await h();
 }
 #### Sizeof <a id="expr.sizeof">[[expr.sizeof]]</a>
 The `sizeof` operator yields the number of bytes occupied by a
 non-potentially-overlapping object of the type of its operand. The
 operand is either an expression, which is an unevaluated operand
+[[term.unevaluated.operand]], or a parenthesized *type-id*. The `sizeof`
+operator shall not be applied to an expression that has function or
+incomplete type, to the parenthesized name of such types, or to a
+glvalue that designates a bit-field. The result of `sizeof` applied to
+any of the narrow character types is `1`. The result of `sizeof` applied
+to any other fundamental type [[basic.fundamental]] is
+*implementation-defined*.
+[*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
 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 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
 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 ')'
 ```
 #### 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
 created by *new-expression*s. — *end note*]
+[*Note 2*: The *type-id* can be a cv-qualified type, in which case the
 object created by the *new-expression* has a cv-qualified
 type. — *end note*]
 ``` bnf
 new-expression:
 — *end example*]
 — *end note*]
 The *attribute-specifier-seq* in a *noptr-new-declarator* appertains to
 the associated array type.
 Every *constant-expression* in a *noptr-new-declarator* shall be a
 converted constant expression [[expr.const]] of type `std::size_t` and
 `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
   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
     non-throwing exception specification [[except.spec]], the value of
     the *new-expression* is the null pointer value of the required
     result type;
     `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
 storage by calling a deallocation function
 [[basic.stc.dynamic.deallocation]]. If the allocated type is a non-array
 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
+*new-expression* can include functions that do not perform allocation or
+deallocation; for example, see [[new.delete.placement]]. — *end note*]
+If the *new-expression* does not begin with a unary `::` operator and
+the allocated type is a class type `T` or array thereof, a search is
+performed for the allocation function’s name in the scope of `T`
+[[class.member.lookup]]. Otherwise, or if nothing is found, the
+allocation function’s name is looked up by searching for it in the
+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.
 — *end example*]
 [*Note 10*: Unless an allocation function has a non-throwing exception
 specification [[except.spec]], it indicates failure to allocate storage
+by throwing a `std::bad_alloc` exception
+[[basic.stc.dynamic.allocation]], [[except]], [[bad.alloc]]; it returns
 a non-null pointer otherwise. If the allocation function has a
 non-throwing exception specification, it returns null to indicate
 failure to allocate storage and a non-null pointer
 otherwise. — *end note*]
 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
+unambiguous matching deallocation function can be found, propagating the
+exception does not cause the object’s memory to be freed.
 [*Note 13*: This is appropriate when the called allocation function
 does not allocate memory; otherwise, it is likely to result in a memory
 leak. — *end note*]
+If the *new-expression* does not begin with a unary `::` operator and
+the allocated type is a class type `T` or an array thereof, a search is
+performed for the deallocation function’s name in the scope of `T`.
+Otherwise, or if nothing is found, the deallocation function’s name is
+looked up by searching for it in the global scope.
 A declaration of a placement deallocation function matches the
 declaration of a placement allocation function if it has the same number
 of parameters and, after parameter transformations [[dcl.fct]], all
 parameter types except the first are identical. If the lookup finds a
 ```
 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
 *new-expression*. — *end note*]
 *delete-expression*; it is not necessary to cast away the constness
 [[expr.const.cast]] of the pointer expression before it is used as the
 operand of the *delete-expression*. — *end note*]
 In a single-object delete expression, if the static type of the object
+to be deleted is not similar [[conv.qual]] to its dynamic type and the
+selected deallocation function (see below) is not a destroying operator
+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
 If the value of the operand of the *delete-expression* is a null pointer
 value, it is unspecified whether a deallocation function will be called
 as described above.
+If a deallocation function is called, it is `operator delete` for a
+single-object delete expression or `operator delete[]` for an array
+delete expression.
+[*Note 4*:  An implementation provides default definitions of the
+global deallocation functions
+[[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]]. — *end note*]
+If the keyword `delete` in a *delete-expression* is not preceded by the
+unary `::` operator and the type of the operand is a pointer to a
+(possibly cv-qualified) class type `T` or (possibly multidimensional)
+array thereof:
+- For a single-object delete expression, if the operand is a pointer to
+  cv `T` and `T` has a virtual destructor, the deallocation function is
+  the one selected at the point of definition of the dynamic type’s
+  virtual destructor [[class.dtor]].
+- Otherwise, a search is performed for the deallocation function’s name
+  in the scope of `T`.
+Otherwise, or if nothing is found, the deallocation function’s name is
+looked up by searching for it in the global scope. In any case, any
+declarations other than of usual deallocation functions
+[[basic.stc.dynamic.deallocation]] are discarded.
+[*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
   type `std::align_val_t` is preferred; otherwise a function without
   such a parameter is preferred. If any preferred functions are found,
   all non-preferred functions are eliminated from further consideration.
 - If exactly one function remains, that function is selected and the
   selection process terminates.
+- If the deallocation functions belong to a class scope, the one without
+ a parameter of type `std::size_t` is selected.
 - If the type is complete and if, for an array delete expression only,
   the operand is a pointer to a class type with a non-trivial destructor
+  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
 delete and the deleted object is not the most derived object in the
 former case, the behavior is undefined, as stated above. — *end note*]
 For an array delete expression, the deleted object is the array object.
 When a *delete-expression* is executed, the selected deallocation
 function shall be called with the address of the deleted object in a
 single-object delete expression, or the address of the deleted object
 suitably adjusted for the array allocation overhead [[expr.new]] in an
 array delete expression, as its first argument.
+[*Note 7*: Any cv-qualifiers in the type of the deleted object are
 ignored when forming this argument. — *end note*]
 If a destroying operator delete is used, an unspecified value is passed
 as the argument corresponding to the parameter of type
 `std::destroying_delete_t`. If a deallocation function with a parameter
 deallocation function with a parameter of type `std::size_t` is used,
 the size of the deleted object in a single-object delete expression, or
 of the array plus allocation overhead in an array delete expression, is
 passed as the corresponding argument.
+[*Note 8*: If this results in a call to a replaceable deallocation
 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
 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
+undefined. The expression `E1` is sequenced before the expression `E2`.
 The restrictions on cv-qualification, and the manner in which the
 cv-qualifiers of the operands are combined to produce the cv-qualifiers
 of the result, are the same as the rules for `E1.E2` given in
 [[expr.ref]].
 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
   (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.
+[*Example 1*:
+``` cpp
+int arr[5] = {1, 2, 3, 4, 5};
+unsigned int *p = reinterpret_cast<unsigned int*>(arr + 1);
+unsigned int k = *p;            // OK, value of k is 2[conv.lval]
+unsigned int *q = p + 1;        // undefined behavior: p points to an int, not an unsigned int object
+```
+— *end example*]
 ### Shift operators <a id="expr.shift">[[expr.shift]]</a>
 The shift operators `<<` and `>>` group left-to-right.
 If both operands have the same enumeration type `E`, the operator yields
 the result of converting the operands to the underlying type of `E` and
 applying `<=>` to the converted operands.
+If at least one of the operands is of object pointer type and the other
+operand is of object pointer or array type, array-to-pointer conversions
 [[conv.array]], pointer conversions [[conv.ptr]], and qualification
 conversions [[conv.qual]] are performed on both operands to bring them
 to their composite pointer type [[expr.type]]. After the conversions,
 the operands shall have the same type.
 [*Note 1*: If both of the operands are arrays, array-to-pointer
 conversions [[conv.array]] are not applied. — *end note*]
+In this case, `p <=> q` is of type `std::strong_ordering` and the result
+is defined by the following rules:
+- If two pointer operands `p` and `q` compare equal [[expr.eq]],
+  `p <=> q` yields `std::strong_ordering::equal`;
+- otherwise, if `p` and `q` compare unequal, `p <=> q` yields
   `std::strong_ordering::less` if `q` compares greater than `p` and
   `std::strong_ordering::greater` if `p` compares greater than `q`
+ [[expr.rel]];
+- otherwise, the result is unspecified.
 Otherwise, the program is ill-formed.
 The three comparison category types [[cmp.categories]] (the types
 `std::strong_ordering`, `std::weak_ordering`, and
+`std::partial_ordering`) are not predefined; if a standard library
+declaration [[compare.syn]], [[std.modules]] of such a class type does
+not precede [[basic.lookup.general]] a use of that type — even an
+implicit use in which the type is not named (e.g., via the `auto`
 specifier [[dcl.spec.auto]] in a defaulted three-way comparison
+[[class.spaceship]] or use of the built-in operator) — the program is
 ill-formed.
 ### Relational operators <a id="expr.rel">[[expr.rel]]</a>
 The relational operators group left-to-right.
 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
   subobjects thereof, the pointer to the element with the higher
   subscript is required to compare greater.
 - If two pointers point to different non-static data members of the same
   object, or to subobjects of such members, recursively, the pointer to
+  the later declared member is required to compare greater provided
+ neither member is a subobject of zero size and their class is not a
+  union.
 - Otherwise, neither pointer is required to compare greater than the
   other.
 If two operands `p` and `q` compare equal [[expr.eq]], `p<=q` and `p>=q`
 both yield `true` and `p<q` and `p>q` both yield `false`. Otherwise, if
+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.
 The `^` operator groups left-to-right. The operands shall be of integral
 or unscoped enumeration type. The usual arithmetic conversions
 [[expr.arith.conv]] are performed. Given the coefficients `xᵢ` and `yᵢ`
 of the base-2 representation [[basic.fundamental]] of the converted
 operands `x` and `y`, the coefficient `rᵢ` of the base-2 representation
+of the result `r` is 1 if either (but not both) of `xᵢ` and `yᵢ` is 1,
 and 0 otherwise.
 [*Note 1*: The result is the bitwise exclusive function of the
 operands. — *end note*]
 The `|` operator groups left-to-right. The operands shall be of integral
 or unscoped enumeration type. The usual arithmetic conversions
 [[expr.arith.conv]] are performed. Given the coefficients `xᵢ` and `yᵢ`
 of the base-2 representation [[basic.fundamental]] of the converted
 operands `x` and `y`, the coefficient `rᵢ` of the base-2 representation
+of the result `r` is 1 if at least one of `xᵢ` and `yᵢ` is 1, and 0
 otherwise.
 [*Note 1*: The result is the bitwise inclusive function of the
 operands. — *end note*]
 Attempts are made to form an implicit conversion sequence from an
 operand expression `E1` of type `T1` to a target type related to the
 type `T2` of the operand expression `E2` as follows:
 - If `E2` is an lvalue, the target type is “lvalue reference to `T2`”,
+ but an implicit conversion sequence can only be formed if the
+ reference would bind directly [[dcl.init.ref]] to a glvalue.
 - If `E2` is an xvalue, the target type is “rvalue reference to `T2`”,
+ 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
 or if both are bit-fields.
 Otherwise, the result is a prvalue. If the second and third operands do
 not have the same type, and either has (possibly cv-qualified) class
 type, overload resolution is used to determine the conversions (if any)
+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.
 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
 enclosing coroutine [[dcl.fct.def.coroutine]], then the
 *yield-expression* is equivalent to the expression
+`co_await p.yield_value(e)`.
 [*Example 1*:
 ``` cpp
 template <typename T>
   iterator begin();
   iterator end();
 };
 my_generator<pair<int,int>> g1() {
+  for (int i = 0; i < 10; ++i) co_yield {i,i};
 }
 my_generator<pair<int,int>> g2() {
+  for (int i = 0; i < 10; ++i) co_yield make_pair(i,i);
 }
 auto f(int x = co_yield 5);     // error: yield-expression outside of function suspension context
 int a[] = { co_yield 1 };       // error: yield-expression outside of function suspension context
 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:
 ``` cpp
 try {
   // ...
 } catch (...) {     // catch all exceptions
 ### 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
+the left operand is a bit-field. In all cases, the assignment is
+sequenced after the value computation of the right and left operands,
+and before the value computation of the assignment expression. The right
+operand is sequenced before the left operand. With respect to an
+indeterminately-sequenced function call, the operation of a compound
+assignment is a single evaluation.
 [*Note 1*: Therefore, a function call cannot intervene between the
 lvalue-to-rvalue conversion and the side effect associated with any
 single compound assignment operator. — *end note*]
 When the left operand of an assignment operator is a bit-field that
 cannot represent the value of the expression, the resulting value of the
 bit-field is *implementation-defined*.
+An assignment whose left operand is of a volatile-qualified type is
+deprecated [[depr.volatile.type]] unless the (possibly parenthesized)
+assignment is a discarded-value expression or an unevaluated operand
+[[term.unevaluated.operand]].
 The behavior of an expression of the form `E1 op= E2` is equivalent to
+`E1 = E1 op E2` except that `E1` is evaluated only once.
+[*Note 2*: The object designated by `E1` is accessed
+twice. — *end note*]
+For `+=` and `-=`, `E1` shall either have arithmetic type or be a
+pointer to a possibly cv-qualified completely-defined object type. In
+all other cases, `E1` shall have arithmetic type.
 If the value being stored in an object is read via another object that
 overlaps in any way the storage of the first object, then the overlap
 shall be exact and the two objects shall have the same type, otherwise
 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;
 [[intro.execution]]. The type and value of the result are the type and
 value of the right operand; the result is of the same value category as
 its right operand, and is a bit-field if its right operand is a
 bit-field.
+[*Note 1*:
+In contexts where the comma token is given special meaning (e.g.,
+function calls [[expr.call]], subscript expressions [[expr.sub]], lists
+of initializers [[dcl.init]], or *template-argument-list*s
+[[temp.names]]), the comma operator as described in this subclause can
+appear only in parentheses.
+[*Example 1*:
 ``` cpp
 f(a, (t=3, t+2), c);
 ```
 has three arguments, the second of which has the value `5`.
 — *end example*]
+— *end note*]
 ## Constant expressions <a id="expr.const">[[expr.const]]</a>
 Certain contexts require expressions that satisfy additional
 requirements as detailed in this subclause; other contexts have
   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
+constant expressions* at a point P if V’s initializing declaration D is
 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
 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
+  refers to a non-active member of a union or a subobject thereof;
 - an lvalue-to-rvalue conversion that is applied to an object with an
   indeterminate value [[basic.indet]];
 - an invocation of an implicitly-defined copy/move constructor or
   copy/move assignment operator for a union whose active member (if any)
   is mutable, unless the lifetime of the union object began within the
   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
     };
   }
   ```
   — *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()); };
   };
   — *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
   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) { }
   int m;
 };
+constexpr int v = A(true).m;        // OK, constructor call initializes m with the value 42
 constexpr int w = A(false).m;       // error: initializer for m is x, which is non-constant
 constexpr int f1(int k) {
   constexpr int x = k;              // error: x is not initialized by a constant expression
                                     // because lifetime of k began outside the initializer of x
   return x;
 }
 constexpr int f2(int k) {
+  int x = k;                        // OK, not required to be a constant expression
                                     // because x is not constexpr
   return x;
 }
 constexpr int incr(int &n) {
   constexpr int x = incr(k);        // error: incr(k) is not a core constant expression
                                     // because lifetime of k began outside the expression incr(k)
   return x;
 }
 constexpr int h(int k) {
+  int x = incr(k);                  // OK, incr(k) is not required to be a core constant expression
   return x;
 }
+constexpr int y = h(1);             // OK, initializes y with the value 2
                                     // h(1) is a core constant expression because
                                     // the lifetime of k begins inside h(1)
 ```
 — *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;
+}
+void use_array(int const (&gold_medal_mel)[2]) {
+  constexpr auto gold = array_size(gold_medal_mel);     // OK
+}
+constexpr auto olympic_mile() {
+  const int ledecky = 1500;
+  return []{ return ledecky; };
+}
+static_assert(olympic_mile()() == 1500);                // OK
+struct Swim {
+  constexpr int phelps() { return 28; }
+  virtual constexpr int lochte() { return 12; }
+  int coughlin = 12;
+};
+constexpr int how_many(Swim& swam) {
+  Swim* p = &swam;
+  return (p + 1 - 1)->phelps();
+}
+void splash(Swim& swam) {
+  static_assert(swam.phelps() == 28);           // OK
+  static_assert((&swam)->phelps() == 28);       // OK
+  Swim* pswam = &swam;
+  static_assert(pswam->phelps() == 28);         // error: lvalue-to-rvalue conversion on a pointer
+                                                // not usable in constant expressions
+  static_assert(how_many(swam) == 28);          // OK
+  static_assert(Swim().lochte() == 12);         // OK
+  static_assert(swam.lochte() == 12);           // error: invoking virtual function on reference
+                                                // with constexpr-unknown dynamic type
+  static_assert(swam.coughlin == 12);           // error: lvalue-to-rvalue conversion on an object
+                                                // not usable in constant expressions
+}
+extern Swim dc;
+extern Swim& trident;
+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; }
   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*]
 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
 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(); }
                                                 // 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
 — *end example*]
 — *end note*]
 An expression or conversion is in an *immediate function context* if it
+is potentially evaluated and either:
+- its innermost enclosing non-block scope is a function parameter scope
+ of an immediate function,
+- it is a subexpression of a manifestly constant-evaluated expression or
+  conversion, or
+- its enclosing statement is enclosed [[stmt.pre]] by the
+  *compound-statement* of a consteval if statement [[stmt.if]].
+An invocation is an *immediate invocation* if it is a
+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,
+- a defaulted special member function that is not declared with the
+  `consteval` specifier, or
+- a function that results from the instantiation of a templated entity
+  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; }
+template<class T>
+constexpr int f(T t) {
+  return t + id(t);
+}
+auto a = &f<char>;              // OK, f<char> is not an immediate function
+auto b = &f<int>;               // error: f<int> is an immediate function
+static_assert(f(3) == 6);       // OK
+template<class T>
+constexpr int g(T t) {          // g<int> is not an immediate function
+  return t + id(42);            // because id(42) is already a constant
+}
+template<class T, class F>
+constexpr bool is_not(T t, F f) {
+  return not f(t);
+}
+consteval bool is_even(int i) { return i % 2 == 0; }
+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
+struct A {
+  int x;
+  int y = id(x);
+};
+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:
 - a *constant-expression*, or
 - 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
   const int b = std::is_constant_evaluated() ? 2 : y;     // static initialization to 2
   int c = y + (std::is_constant_evaluated() ? 2 : y);     // dynamic initialization to y+y
   constexpr int f() {
     const int n = std::is_constant_evaluated() ? 13 : 17; // n is 13
+    int m = std::is_constant_evaluated() ? 13 : 17;       // m can be 13 or 17 (see below)
     char arr[n] = {}; // char[13]
     return m + sizeof(arr);
   }
   int p = f();                                            // m is 13; initialized to 26
   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:
 - a constexpr function that is named by an expression [[basic.def.odr]]
   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.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.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
+[class.union.anon]: class.md#class.union.anon
 [class.virtual]: class.md#class.virtual
 [cmp.categories]: support.md#cmp.categories
+[compare.syn]: support.md#compare.syn
 [conv]: #conv
 [conv.array]: #conv.array
 [conv.bool]: #conv.bool
 [conv.double]: #conv.double
 [conv.fctptr]: #conv.fctptr
 [conv.fpint]: #conv.fpint
 [conv.fpprom]: #conv.fpprom
 [conv.func]: #conv.func
+[conv.general]: #conv.general
 [conv.integral]: #conv.integral
 [conv.lval]: #conv.lval
 [conv.mem]: #conv.mem
 [conv.prom]: #conv.prom
 [conv.ptr]: #conv.ptr
 [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.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
 [expr.mptr.oper]: #expr.mptr.oper
 [expr.mul]: #expr.mul
 [expr.new]: #expr.new
 [expr.or]: #expr.or
 [expr.post]: #expr.post
+[expr.post.general]: #expr.post.general
 [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.throw]: #expr.throw
 [expr.type]: #expr.type
 [expr.type.conv]: #expr.type.conv
 [expr.typeid]: #expr.typeid
 [expr.unary]: #expr.unary
+[expr.unary.general]: #expr.unary.general
 [expr.unary.noexcept]: #expr.unary.noexcept
 [expr.unary.op]: #expr.unary.op
 [expr.xor]: #expr.xor
 [expr.yield]: #expr.yield
 [function.objects]: utilities.md#function.objects
 [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.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.
 [^2]: Overloaded operators are never assumed to be associative or
 [^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]].
     be obtained.
 [^8]: The rule for conversion of pointers to members (from pointer to
     member of base to pointer to member of derived) appears inverted
     compared to the rule for pointers to objects (from pointer to
+    derived to pointer to base) [[conv.ptr]], [[class.derived]]. This
     inversion is necessary to ensure type safety. Note that a pointer to
     member is not an object pointer or a function pointer and the rules
     for conversions of such pointers do not apply to pointers to
     members. In particular, a pointer to member cannot be converted to a
     `void*`.
 [^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
 [^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.
 [^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]].

Diff to HTML by rtfpessoa