[expr.prim] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpdsorgp23/{from.md → to.md} +629 -209

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

@@ -1,16 +1,19 @@
 ## Primary expressions <a id="expr.prim">[[expr.prim]]</a>
 ``` bnf
 primary-expression:
     literal
     this
     '(' expression ')'
     id-expression
     lambda-expression
     fold-expression
     requires-expression
 ```
 ### Literals <a id="expr.prim.literal">[[expr.prim.literal]]</a>
 The type of a *literal* is determined based on its form as specified in
@@ -30,19 +33,26 @@ The *current class* at a program point is the class associated with the
 innermost class scope containing that point.
 [*Note 1*: A *lambda-expression* does not introduce a class
 scope. — *end note*]
 If a declaration declares a member function or member function template
 of a class `X`, the expression `this` is a prvalue of type “pointer to
 *cv-qualifier-seq* `X`” wherever `X` is the current class between the
 optional *cv-qualifier-seq* and the end of the *function-definition*,
 *member-declarator*, or *declarator*. It shall not appear within the
-declaration of either a static member function or an explicit object
-member function of the current class (although its type and value
-category are defined within such member functions as they are within an
-implicit object member function).
 [*Note 2*: This is because declaration matching does not occur until
 the complete declarator is known. — *end note*]
 [*Note 3*:
@@ -106,62 +116,104 @@ otherwise indicated.
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
 ```
 An *id-expression* is a restricted form of a *primary-expression*.
 [*Note 1*: An *id-expression* can appear after `.` and `->` operators
 [[expr.ref]]. — *end note*]
 If an *id-expression* E denotes a member M of an anonymous union
 [[class.union.anon]] U:
 - If U is a non-static data member, E refers to M as a member of the
-  lookup context of the terminal name of E (after any transformation to
-  a class member access expression [[class.mfct.non.static]]).
-  \[*Example 1*: `o.x` is interpreted as `o.u.x`, where u names the
   anonymous union member. — *end example*]
 - Otherwise, E is interpreted as a class member access [[expr.ref]] that
   designates the member subobject M of the anonymous union variable for
-  U. \[*Note 2*: Under this interpretation, E no longer denotes a
-  non-static data member. — *end note*] \[*Example 2*: `N::x` is
   interpreted as `N::u.x`, where u names the anonymous union
   variable. — *end example*]
-An *id-expression* that denotes a non-static data member or implicit
-object member function of a class can only be used:
-- as part of a class member access [[expr.ref]] in which the object
-  expression refers to the member’s class[^10] or a class derived from
-  that class, or
 - to form a pointer to member [[expr.unary.op]], or
-- if that *id-expression* denotes a non-static data member and it
-  appears in an unevaluated operand.
-  \[*Example 3*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
   ```
   — *end example*]
 For an *id-expression* that denotes an overload set, overload resolution
 is performed to select a unique function [[over.match]], [[over.over]].
-[*Note 3*:
 A program cannot refer to a function with a trailing *requires-clause*
 whose *constraint-expression* is not satisfied, because such functions
 are never selected by overload resolution.
-[*Example 4*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
 };
@@ -172,12 +224,12 @@ void g() {
   decltype(A<int>::f)* p2 = nullptr;    // error: the type decltype(A<int>::f) is invalid
 }
 ```
 In each case, the constraints of `f` are not satisfied. In the
-declaration of `p2`, those constraints are required to be satisfied even
-though `f` is an unevaluated operand [[term.unevaluated.operand]].
 — *end example*]
 — *end note*]
@@ -188,27 +240,24 @@ unqualified-id:
     identifier
     operator-function-id
     conversion-function-id
     literal-operator-id
     '~' type-name
-    '~' decltype-specifier
     template-id
 ```
 An *identifier* is only an *id-expression* if it has been suitably
-declared [[dcl.dcl]] or if it appears as part of a *declarator-id*
-[[dcl.decl]]. An *identifier* that names a coroutine parameter refers to
-the copy of the parameter [[dcl.fct.def.coroutine]].
 [*Note 1*: For *operator-function-id*s, see  [[over.oper]]; for
 *conversion-function-id*s, see  [[class.conv.fct]]; for
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
-[[temp.names]]. A *type-name* or *decltype-specifier* prefixed by `~`
-denotes the destructor of the type so named; see  [[expr.prim.id.dtor]].
-Within the definition of a non-static member function, an *identifier*
-that names a non-static member is transformed to a class member access
-expression [[class.mfct.non.static]]. — *end note*]
 A *component name* of an *unqualified-id* U is
 - U if it is a name or
 - the component name of the *template-id* or *type-name* of U, if any.
@@ -219,46 +268,147 @@ several component names
 The *terminal name* of a construct is the component name of that
 construct that appears lexically last.
 The result is the entity denoted by the *unqualified-id*
-[[basic.lookup.unqual]]. If the *unqualified-id* appears in a
-*lambda-expression* at program point P and the entity is a local entity
-[[basic.pre]] or a variable declared by an *init-capture*
-[[expr.prim.lambda.capture]], then let S be the *compound-statement* of
-the innermost enclosing *lambda-expression* of P. If naming the entity
-from outside of an unevaluated operand within S would refer to an entity
-captured by copy in some intervening *lambda-expression*, then let E be
-the innermost such *lambda-expression*.
-- If there is such a *lambda-expression* and if P is in E’s function
- parameter scope but not its *parameter-declaration-clause*, then the
- type of the expression is the type of a class member access expression
-  [[expr.ref]] naming the non-static data member that would be declared
- for such a capture in the object parameter [[dcl.fct]] of the function
- call operator of E. \[*Note 3*: If E is not declared `mutable`, the
-  type of such an identifier will typically be `const`
-  qualified. — *end note*]
-- Otherwise (if there is no such *lambda-expression* or if P either
-  precedes E’s function parameter scope or is in E’s
-  *parameter-declaration-clause*), the type of the expression is the
-  type of the result.
-[*Note 4*: If the entity is a template parameter object for a template
 parameter of type `T` [[temp.param]], the type of the expression is
-`const T`. — *end note*]
-[*Note 5*: The type will be adjusted as described in [[expr.type]] if
 it is cv-qualified or is a reference type. — *end note*]
 The expression is an xvalue if it is move-eligible (see below); an
 lvalue if the entity is a function, variable, structured binding
-[[dcl.struct.bind]], data member, or template parameter object; and a
-prvalue otherwise [[basic.lval]]; it is a bit-field if the identifier
-designates a bit-field.
-[*Example 1*:
 ``` cpp
 void f() {
   float x, &r = x;
@@ -285,27 +435,23 @@ void f() {
 }
 ```
 — *end example*]
-An *implicitly movable entity* is a variable of automatic storage
 duration that is either a non-volatile object or an rvalue reference to
-a non-volatile object type. In the following contexts, an
-*id-expression* is *move-eligible*:
-- If the *id-expression* (possibly parenthesized) is the operand of a
-  `return` [[stmt.return]] or `co_return` [[stmt.return.coroutine]]
- statement, and names an implicitly movable entity declared in the body
- or *parameter-declaration-clause* of the innermost enclosing function
-  or *lambda-expression*, or
-- if the *id-expression* (possibly parenthesized) is the operand of a
-  *throw-expression* [[expr.throw]], and names an implicitly movable
- entity that belongs to a scope that does not contain the
-  *compound-statement* of the innermost *lambda-expression*,
-  *try-block*, or *function-try-block* (if any) whose
-  *compound-statement* or *ctor-initializer* contains the
-  *throw-expression*.
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
@@ -315,71 +461,152 @@ qualified-id:
 ``` bnf
 nested-name-specifier:
     '::'
     type-name '::'
     namespace-name '::'
- decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
 The component names of a *qualified-id* are those of its
 *nested-name-specifier* and *unqualified-id*. The component names of a
 *nested-name-specifier* are its *identifier* (if any) and those of its
 *type-name*, *namespace-name*, *simple-template-id*, and/or
 *nested-name-specifier*.
 A *nested-name-specifier* is *declarative* if it is part of
 - a *class-head-name*,
 - an *enum-head-name*,
 - a *qualified-id* that is the *id-expression* of a *declarator-id*, or
 - a declarative *nested-name-specifier*.
 A declarative *nested-name-specifier* shall not have a
-*decltype-specifier*. A declaration that uses a declarative
-*nested-name-specifier* shall be a friend declaration or inhabit a scope
-that contains the entity being redeclared or specialized.
-The *nested-name-specifier* `::` nominates the global namespace. A
-*nested-name-specifier* with a *decltype-specifier* nominates the type
-denoted by the *decltype-specifier*, which shall be a class or
-enumeration type. If a *nested-name-specifier* N is declarative and has
-a *simple-template-id* with a template argument list A that involves a
   template parameter, let T be the template nominated by N without A. T
   shall be a class template.
   - If A is the template argument list [[temp.arg]] of the corresponding
- *template-head* H [[temp.mem]], N nominates the primary template of T;
- H shall be equivalent to the *template-head* of T [[temp.over.link]].
-- Otherwise, N nominates the partial specialization
- [[temp.spec.partial]] of T whose template argument list is equivalent
-  to A [[temp.over.link]]; the program is ill-formed if no such partial
-  specialization exists.
-Any other *nested-name-specifier* nominates the entity denoted by its
-*type-name*, *namespace-name*, *identifier*, or *simple-template-id*. If
-the *nested-name-specifier* is not declarative, the entity shall not be
-a template.
 A *qualified-id* shall not be of the form *nested-name-specifier*
-`template`ₒₚₜ  `~` *decltype-specifier* nor of the form
-*decltype-specifier* `::` `~` *type-name*.
 The result of a *qualified-id* Q is the entity it denotes
-[[basic.lookup.qual]]. The type of the expression is the type of the
-result. The result is an lvalue if the member is
 - a function other than a non-static member function,
 - a non-static member function if Q is the operand of a unary `&`
   operator,
 - a variable,
 - a structured binding [[dcl.struct.bind]], or
 - a data member,
 and a prvalue otherwise.
 #### Destruction <a id="expr.prim.id.dtor">[[expr.prim.id.dtor]]</a>
 An *id-expression* that denotes the destructor of a type `T` names the
 destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 *id-expression* is said to name a *pseudo-destructor*.
@@ -426,14 +653,15 @@ lambda-introducer:
 ```
 ``` bnf
 lambda-declarator:
     lambda-specifier-seq noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
-    noexcept-specifier attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
-    trailing-return-typeₒₚₜ
     '(' parameter-declaration-clause ')' lambda-specifier-seqₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
-       trailing-return-typeₒₚₜ requires-clauseₒₚₜ
 ```
 ``` bnf
 lambda-specifier:
     consteval
@@ -442,12 +670,11 @@ lambda-specifier:
     static
 ```
 ``` bnf
 lambda-specifier-seq:
-    lambda-specifier
-    lambda-specifier lambda-specifier-seq
 ```
 A *lambda-expression* provides a concise way to create a simple function
 object.
@@ -473,12 +700,24 @@ An ambiguity can arise because a *requires-clause* can end in an
 *attribute-specifier-seq*, which collides with the
 *attribute-specifier-seq* in *lambda-expression*. In such cases, any
 attributes are treated as *attribute-specifier-seq* in
 *lambda-expression*.
-[*Note 2*: Such ambiguous cases cannot have valid semantics because the
-constraint expression would not have type `bool`. — *end note*]
 A *lambda-specifier-seq* shall contain at most one of each
 *lambda-specifier* and shall not contain both `constexpr` and
 `consteval`. If the *lambda-declarator* contains an explicit object
 parameter [[dcl.fct]], then no *lambda-specifier* in the
@@ -488,19 +727,20 @@ the *lambda-specifier-seq* contains `static`, there shall be no
 *lambda-capture*.
 [*Note 3*: The trailing *requires-clause* is described in
 [[dcl.decl]]. — *end note*]
-If a *lambda-declarator* does not include a
-*parameter-declaration-clause*, it is as if `()` were inserted at the
-start of the *lambda-declarator*. If the *lambda-declarator* does not
-include a *trailing-return-type*, it is considered to be `-> auto`.
 [*Note 4*: In that case, the return type is deduced from `return`
 statements as described in [[dcl.spec.auto]]. — *end note*]
-[*Example 2*:
 ``` cpp
 auto x1 = [](int i) { return i; };      // OK, return type is int
 auto x2 = []{ return { 1, 2 }; };       // error: deducing return type from braced-init-list
 int j;
@@ -511,53 +751,62 @@ auto x3 = [&]()->auto&& { return j; };  // OK, return type is int&
 A lambda is a *generic lambda* if the *lambda-expression* has any
 generic parameter type placeholders [[dcl.spec.auto]], or if the lambda
 has a *template-parameter-list*.
-[*Example 3*:
 ``` cpp
-int i = [](int i, auto a) { return i; }(3, 4); // OK, a generic lambda
-int j = []<class T>(T t, int i) { return i; }(3, 4); // OK, a generic lambda
 ```
 — *end example*]
 #### Closure types <a id="expr.prim.lambda.closure">[[expr.prim.lambda.closure]]</a>
 The type of a *lambda-expression* (which is also the type of the closure
 object) is a unique, unnamed non-union class type, called the *closure
 type*, whose properties are described below.
 The closure type is declared in the smallest block scope, class scope,
 or namespace scope that contains the corresponding *lambda-expression*.
 [*Note 1*: This determines the set of namespaces and classes associated
 with the closure type [[basic.lookup.argdep]]. The parameter types of a
 *lambda-declarator* do not affect these associated namespaces and
 classes. — *end note*]
-The closure type is not an aggregate type [[dcl.init.aggr]]. An
-implementation may define the closure type differently from what is
-described below provided this does not alter the observable behavior of
-the program other than by changing:
 - the size and/or alignment of the closure type,
-- whether the closure type is trivially copyable [[class.prop]], or
 - whether the closure type is a standard-layout class [[class.prop]].
 An implementation shall not add members of rvalue reference type to the
 closure type.
 The closure type for a *lambda-expression* has a public inline function
 call operator (for a non-generic lambda) or function call operator
 template (for a generic lambda) [[over.call]] whose parameters and
-return type are described by the *lambda-expression*’s
 *parameter-declaration-clause* and *trailing-return-type* respectively,
 and whose *template-parameter-list* consists of the specified
-*template-parameter-list*, if any. The *requires-clause* of the function
-call operator template is the *requires-clause* immediately following
 `<` *template-parameter-list* `>`, if any. The trailing
 *requires-clause* of the function call operator or operator template is
 the *requires-clause* of the *lambda-declarator*, if any.
 [*Note 2*: The function call operator template for a generic lambda can
@@ -594,11 +843,12 @@ std::cout << fact(5);                                           // OK, outputs 1
 Given a lambda with a *lambda-capture*, the type of the explicit object
 parameter, if any, of the lambda’s function call operator (possibly
 instantiated from a function call operator template) shall be either:
 - the closure type,
-- a class type derived from the closure type, or
 - a reference to a possibly cv-qualified such type.
 [*Example 2*:
 ``` cpp
@@ -622,13 +872,14 @@ function or static member function template [[class.static.mfct]] if the
 `static`. Otherwise, it is a non-static member function or member
 function template [[class.mfct.non.static]] that is declared `const`
 [[class.mfct.non.static]] if and only if the *lambda-expression*’s
 *parameter-declaration-clause* is not followed by `mutable` and the
 *lambda-declarator* does not contain an explicit object parameter. It is
-neither virtual nor declared `volatile`. Any *noexcept-specifier*
-specified on a *lambda-expression* applies to the corresponding function
-call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-declarator* appertains to the type of the corresponding function
 call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-expression* preceding a *lambda-declarator* appertains to the
 corresponding function call operator or operator template. The function
 call operator or any given operator template specialization is a
@@ -707,35 +958,80 @@ auto f = []<typename T1, C1 T2> requires C2<sizeof(T1) + sizeof(T2)>
 — *end example*]
 — *end note*]
 The closure type for a non-generic *lambda-expression* with no
-*lambda-capture* whose constraints (if any) are satisfied has a
-conversion function to pointer to function with C++ language linkage
-[[dcl.link]] having the same parameter and return types as the closure
-type’s function call operator. The conversion is to “pointer to
-`noexcept` function” if the function call operator has a non-throwing
-exception specification. If the function call operator is a static
-member function, then the value returned by this conversion function is
-the address of the function call operator. Otherwise, the value returned
-by this conversion function is the address of a function `F` that, when
-invoked, has the same effect as invoking the closure type’s function
-call operator on a default-constructed instance of the closure type. `F`
-is a constexpr function if the function call operator is a constexpr
-function and is an immediate function if the function call operator is
-an immediate function.
-For a generic lambda with no *lambda-capture*, the closure type has a
-conversion function template to pointer to function. The conversion
-function template has the same invented template parameter list, and the
-pointer to function has the same parameter types, as the function call
-operator template. The return type of the pointer to function shall
-behave as if it were a *decltype-specifier* denoting the return type of
-the corresponding function call operator template specialization.
-[*Note 4*:
 If the generic lambda has no *trailing-return-type* or the
 *trailing-return-type* contains a placeholder type, return type
 deduction of the corresponding function call operator template
 specialization has to be done. The corresponding specialization is that
@@ -767,11 +1063,11 @@ struct Closure {
 };
 ```
 — *end note*]
-[*Example 6*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
@@ -791,27 +1087,26 @@ int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; };        // OK
 — *end example*]
 If the function call operator template is a static member function
 template, then the value returned by any given specialization of this
-conversion function template is the address of the corresponding
-function call operator template specialization. Otherwise, the value
-returned by any given specialization of this conversion function
-template is the address of a function `F` that, when invoked, has the
-same effect as invoking the generic lambda’s corresponding function call
-operator template specialization on a default-constructed instance of
-the closure type. `F` is a constexpr function if the corresponding
-specialization is a constexpr function and `F` is an immediate function
-if the function call operator template specialization is an immediate
-function.
-[*Note 5*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
-parameter types are required to match the return type and parameter
-types of the pointer to function. — *end note*]
-[*Example 7*:
 ``` cpp
 auto GL = [](auto a) { std::cout << a; return a; };
 int (*GL_int)(int) = GL;        // OK, through conversion function template
 GL_int(3);                      // OK, same as GL(3)
@@ -821,11 +1116,11 @@ GL_int(3);                      // OK, same as GL(3)
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing
 exception specification [[except.spec]].
-[*Example 8*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
@@ -840,11 +1135,11 @@ static_assert(Fwd(NC,3) == 3);  // error
 The *lambda-expression*’s *compound-statement* yields the
 *function-body* [[dcl.fct.def]] of the function call operator, but it is
 not within the scope of the closure type.
-[*Example 9*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
@@ -857,23 +1152,25 @@ struct S1 {
 };
 ```
 — *end example*]
-Further, a variable `__func__` is implicitly defined at the beginning of
-the *compound-statement* of the *lambda-expression*, with semantics as
-described in  [[dcl.fct.def.general]].
 The closure type associated with a *lambda-expression* has no default
 constructor if the *lambda-expression* has a *lambda-capture* and a
 defaulted default constructor otherwise. It has a defaulted copy
 constructor and a defaulted move constructor [[class.copy.ctor]]. It has
 a deleted copy assignment operator if the *lambda-expression* has a
 *lambda-capture* and defaulted copy and move assignment operators
 otherwise [[class.copy.assign]].
-[*Note 6*: These special member functions are implicitly defined as
 usual, which can result in them being defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].
@@ -911,30 +1208,30 @@ capture:
 ``` bnf
 simple-capture:
     identifier '...'ₒₚₜ
     '&' identifier '...'ₒₚₜ
     this
-    '*' 'this'
 ```
 ``` bnf
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
 The body of a *lambda-expression* may refer to local entities of
-enclosing block scopes by capturing those entities, as described below.
 If a *lambda-capture* includes a *capture-default* that is `&`, no
 identifier in a *simple-capture* of that *lambda-capture* shall be
 preceded by `&`. If a *lambda-capture* includes a *capture-default* that
 is `=`, each *simple-capture* of that *lambda-capture* shall be of the
 form “`&` *identifier* `...`ₒₚₜ ”, “`this`”, or “`* this`”.
 [*Note 1*: The form `[&,this]` is redundant but accepted for
-compatibility with ISO C++14. — *end note*]
 Ignoring appearances in *initializer*s of *init-capture*s, an identifier
 or `this` shall not appear more than once in a *lambda-capture*.
 [*Example 1*:
@@ -953,14 +1250,19 @@ void S2::f(int i) {
 ```
 — *end example*]
 A *lambda-expression* shall not have a *capture-default* or
-*simple-capture* in its *lambda-introducer* unless its innermost
-enclosing scope is a block scope [[basic.scope.block]] or it appears
-within a default member initializer and its innermost enclosing scope is
-the corresponding class scope [[basic.scope.class]].
 The *identifier* in a *simple-capture* shall denote a local entity
 [[basic.lookup.unqual]], [[basic.pre]]. The *simple-capture*s `this` and
 `* this` denote the local entity `*this`. An entity that is designated
 by a *simple-capture* is said to be *explicitly captured*.
@@ -1178,11 +1480,12 @@ void f2() {
 An entity is *captured by copy* if
 - it is implicitly captured, the *capture-default* is `=`, and the
   captured entity is not `*this`, or
 - it is explicitly captured with a capture that is not of the form
-  `this`, `&` *identifier*, or `&` *identifier* *initializer*.
 For each entity captured by copy, an unnamed non-static data member is
 declared in the closure type. The declaration order of these members is
 unspecified. The type of such a data member is the referenced type if
 the entity is a reference to an object, an lvalue reference to the
@@ -1209,11 +1512,11 @@ the closure type.
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
-    int arr[N];     // OK, not an odr-use, refers to automatic variable
     f(&N);          // OK, causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```
@@ -1380,10 +1683,12 @@ bool f(Args ...args) {
 }
 ```
 — *end example*]
 ### Requires expressions <a id="expr.prim.req">[[expr.prim.req]]</a>
 #### General <a id="expr.prim.req.general">[[expr.prim.req.general]]</a>
 A *requires-expression* provides a concise way to express requirements
@@ -1405,12 +1710,11 @@ requirement-body:
     '{' requirement-seq '}'
 ```
 ``` bnf
 requirement-seq:
-    requirement
-    requirement requirement-seq
 ```
 ``` bnf
 requirement:
     simple-requirement
@@ -1418,12 +1722,11 @@ requirement:
     compound-requirement
     nested-requirement
 ```
 A *requires-expression* is a prvalue of type `bool` whose value is
-described below. Expressions appearing within a *requirement-body* are
-unevaluated operands [[term.unevaluated.operand]].
 [*Example 1*:
 A common use of *requires-expression*s is to define requirements in
 concepts such as the one below:
@@ -1450,38 +1753,43 @@ The first `requires` introduces the *requires-clause*, and the second
 introduces the *requires-expression*.
 — *end example*]
 A *requires-expression* may introduce local parameters using a
-*parameter-declaration-clause* [[dcl.fct]]. A local parameter of a
-*requires-expression* shall not have a default argument. These
-parameters have no linkage, storage, or lifetime; they are only used as
-notation for the purpose of defining *requirement*s. The
-*parameter-declaration-clause* of a *requirement-parameter-list* shall
-not terminate with an ellipsis.
 [*Example 2*:
 ``` cpp
 template<typename T>
 concept C = requires(T t, ...) {    // error: terminates with an ellipsis
   t;
 };
 ```
 — *end example*]
-The substitution of template arguments into a *requires-expression* may
-result in the formation of invalid types or expressions in its
-*requirement*s or the violation of the semantic constraints of those
-*requirement*s. In such cases, the *requires-expression* evaluates to
-`false`; it does not cause the program to be ill-formed. The
-substitution and semantic constraint checking proceeds in lexical order
-and stops when a condition that determines the result of the
-*requires-expression* is encountered. If substitution (if any) and
-semantic constraint checking succeed, the *requires-expression*
-evaluates to `true`.
 [*Note 1*: If a *requires-expression* contains invalid types or
 expressions in its *requirement*s, and it does not appear within the
 declaration of a templated entity, then the program is
 ill-formed. — *end note*]
@@ -1493,11 +1801,11 @@ diagnostic required.
 [*Example 3*:
 ``` cpp
 template<typename T> concept C =
 requires {
-  new int[-(int)sizeof(T)]; // ill-formed, no diagnostic required
 };
 ```
 — *end example*]
@@ -1506,16 +1814,16 @@ requires {
 ``` bnf
 simple-requirement:
     expression ';'
 ```
-A *simple-requirement* asserts the validity of an *expression*.
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
-if substitution of template arguments into the *expression* fails. The
-*expression* is an unevaluated operand
-[[term.unevaluated.operand]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename T> concept C =
@@ -1535,13 +1843,17 @@ as a *simple-requirement*.
 #### Type requirements <a id="expr.prim.req.type">[[expr.prim.req.type]]</a>
 ``` bnf
 type-requirement:
     typename nested-name-specifierₒₚₜ type-name ';'
 ```
-A *type-requirement* asserts the validity of a type.
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
 if substitution of template arguments fails. — *end note*]
 [*Example 1*:
@@ -1550,13 +1862,15 @@ if substitution of template arguments fails. — *end note*]
 template<typename T, typename T::type = 0> struct S;
 template<typename T> using Ref = T&;
 template<typename T> concept C = requires {
   typename T::inner;        // required nested member name
-  typename S<T>; // required valid[temp.names] template-id;
- // fails if T::type does not exist as a type to which 0 can be implicitly converted
   typename Ref<T>;          // required alias template substitution, fails if T is void
 };
 ```
 — *end example*]
@@ -1573,13 +1887,14 @@ compound-requirement:
 ``` bnf
 return-type-requirement:
     '->' type-constraint
 ```
-A *compound-requirement* asserts properties of the *expression* E.
-Substitution of template arguments (if any) and verification of semantic
-properties proceed in the following order:
 - Substitution of template arguments (if any) into the *expression* is
   performed.
 - If the `noexcept` specifier is present, E shall not be a
   potentially-throwing expression [[except.spec]].
@@ -1669,5 +1984,110 @@ template<typename T> concept D = requires (T t) {
 `D<T>` is satisfied if `sizeof(decltype (+t)) == 1`
 [[temp.constr.atomic]].
 — *end example*]

 ## Primary expressions <a id="expr.prim">[[expr.prim]]</a>
+### Grammar <a id="expr.prim.grammar">[[expr.prim.grammar]]</a>
 ``` bnf
 primary-expression:
     literal
     this
     '(' expression ')'
     id-expression
     lambda-expression
     fold-expression
     requires-expression
+    splice-expression
 ```
 ### Literals <a id="expr.prim.literal">[[expr.prim.literal]]</a>
 The type of a *literal* is determined based on its form as specified in
 innermost class scope containing that point.
 [*Note 1*: A *lambda-expression* does not introduce a class
 scope. — *end note*]
+If the expression `this` appears within the predicate of a contract
+assertion [[basic.contract.general]] (including as the result of an
+implicit transformation [[expr.prim.id.general]] and including in the
+bodies of nested *lambda-expression*s) and the current class encloses
+the contract assertion, `const` is combined with the *cv-qualifier-seq*
+used to generate the resulting type (see below).
 If a declaration declares a member function or member function template
 of a class `X`, the expression `this` is a prvalue of type “pointer to
 *cv-qualifier-seq* `X`” wherever `X` is the current class between the
 optional *cv-qualifier-seq* and the end of the *function-definition*,
 *member-declarator*, or *declarator*. It shall not appear within the
+declaration of a static or explicit object member function of the
+current class (although its type and value category are defined within
+such member functions as they are within an implicit object member
+function).
 [*Note 2*: This is because declaration matching does not occur until
 the complete declarator is known. — *end note*]
 [*Note 3*:
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
+    pack-index-expression
 ```
 An *id-expression* is a restricted form of a *primary-expression*.
 [*Note 1*: An *id-expression* can appear after `.` and `->` operators
 [[expr.ref]]. — *end note*]
+If an *id-expression* E denotes a non-static non-type member of some
+class `C` at a point where the current class [[expr.prim.this]] is `X`
+and
+- E is potentially evaluated or `C` is `X` or a base class of `X`, and
+- E is not the *id-expression* of a class member access expression
+  [[expr.ref]], and
+- E is not the *id-expression* of a *reflect-expression*
+  [[expr.reflect]], and
+- if E is a *qualified-id*, E is not the un-parenthesized operand of the
+  unary `&` operator [[expr.unary.op]],
+the *id-expression* is transformed into a class member access expression
+using `(*this)` as the object expression. If this transformation occurs
+in the predicate of a precondition assertion of a constructor of `X` or
+a postcondition assertion of a destructor of `X`, the expression is
+ill-formed.
+[*Note 2*: If `C` is not `X` or a base class of `X`, the class member
+access expression is ill-formed. Also, if the *id-expression* occurs
+within a static or explicit object member function, the class member
+access is ill-formed. — *end note*]
+This transformation does not apply in the template definition context
+[[temp.dep.type]].
+[*Example 1*:
+``` cpp
+struct C {
+  bool b;
+  C() pre(b)                // error
+      pre(&this->b)         // OK
+      pre(sizeof(b) > 0);   // OK, b is not potentially evaluated.
+};
+```
+— *end example*]
 If an *id-expression* E denotes a member M of an anonymous union
 [[class.union.anon]] U:
 - If U is a non-static data member, E refers to M as a member of the
+  lookup context of the terminal name of E (after any implicit
+ transformation to a class member access expression).
+  \[*Example 2*: `o.x` is interpreted as `o.u.x`, where u names the
   anonymous union member. — *end example*]
 - Otherwise, E is interpreted as a class member access [[expr.ref]] that
   designates the member subobject M of the anonymous union variable for
+  U. \[*Note 3*: Under this interpretation, E no longer denotes a
+  non-static data member. — *end note*] \[*Example 3*: `N::x` is
   interpreted as `N::u.x`, where u names the anonymous union
   variable. — *end example*]
+An *id-expression* or *splice-expression* that designates a non-static
+data member or implicit object member function of a class can only be
+used:
+- as part of a class member access (after any implicit transformation
+ (see above)) in which the object expression refers to the member’s
+ class or a class derived from that class, or
 - to form a pointer to member [[expr.unary.op]], or
+- if that *id-expression* or *splice-expression* designates a non-static
+ data member and it appears in an unevaluated operand.
+  \[*Example 4*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
+  int S::*k = &[:^^S::m:];        // OK
   ```
   — *end example*]
 For an *id-expression* that denotes an overload set, overload resolution
 is performed to select a unique function [[over.match]], [[over.over]].
+[*Note 4*:
 A program cannot refer to a function with a trailing *requires-clause*
 whose *constraint-expression* is not satisfied, because such functions
 are never selected by overload resolution.
+[*Example 5*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
 };
   decltype(A<int>::f)* p2 = nullptr;    // error: the type decltype(A<int>::f) is invalid
 }
 ```
 In each case, the constraints of `f` are not satisfied. In the
+declaration of `p2`, those constraints need to be satisfied even though
+`f` is an unevaluated operand [[term.unevaluated.operand]].
 — *end example*]
 — *end note*]
     identifier
     operator-function-id
     conversion-function-id
     literal-operator-id
     '~' type-name
+    '~' computed-type-specifier
     template-id
 ```
 An *identifier* is only an *id-expression* if it has been suitably
+declared [[dcl]] or if it appears as part of a *declarator-id*
+[[dcl.decl]].
 [*Note 1*: For *operator-function-id*s, see  [[over.oper]]; for
 *conversion-function-id*s, see  [[class.conv.fct]]; for
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
+[[temp.names]]. A *type-name* or *computed-type-specifier* prefixed by
+`~` denotes the destructor of the type so named; see
+[[expr.prim.id.dtor]]. — *end note*]
 A *component name* of an *unqualified-id* U is
 - U if it is a name or
 - the component name of the *template-id* or *type-name* of U, if any.
 The *terminal name* of a construct is the component name of that
 construct that appears lexically last.
 The result is the entity denoted by the *unqualified-id*
+[[basic.lookup.unqual]].
+If
+- the *unqualified-id* appears in a *lambda-expression* at program point
+  P,
+- the entity is a local entity [[basic.pre]] or a variable declared by
+  an *init-capture* [[expr.prim.lambda.capture]],
+- naming the entity within the *compound-statement* of the innermost
+  enclosing *lambda-expression* of P, but not in an unevaluated operand,
+ would refer to an entity captured by copy in some intervening
+ *lambda-expression*, and
+- P is in the function parameter scope, but not the
+ *parameter-declaration-clause*, of the innermost such
+  *lambda-expression* E,
+then the type of the expression is the type of a class member access
+expression [[expr.ref]] naming the non-static data member that would be
+declared for such a capture in the object parameter [[dcl.fct]] of the
+function call operator of E.
+[*Note 3*: If E is not declared `mutable`, the type of such an
+identifier will typically be `const` qualified. — *end note*]
+Otherwise, if the *unqualified-id* names a coroutine parameter, the type
+of the expression is that of the copy of the parameter
+[[dcl.fct.def.coroutine]], and the result is that copy.
+Otherwise, if the *unqualified-id* names a result binding
+[[dcl.contract.res]] attached to a function with return type `U`,
+- if `U` is “reference to `T`”, then the type of the expression is
+  `const T`;
+- otherwise, the type of the expression is `const U`.
+Otherwise, if the *unqualified-id* appears in the predicate of a
+contract assertion C [[basic.contract]] and the entity is
+- a variable declared outside of C of object type `T`,
+- a variable or template parameter declared outside of C of type
+  “reference to `T`”, or
+- a structured binding of type `T` whose corresponding variable is
+  declared outside of C,
+then the type of the expression is `const` `T`.
+[*Example 1*:
+``` cpp
+int n = 0;
+struct X { bool m(); };
+struct Y {
+  int z = 0;
+  void f(int i, int* p, int& r, X x, X* px)
+    pre (++n)       // error: attempting to modify const lvalue
+    pre (++i)       // error: attempting to modify const lvalue
+    pre (++(*p))    // OK
+    pre (++r)       // error: attempting to modify const lvalue
+    pre (x.m())     // error: calling non-const member function
+    pre (px->m())   // OK
+    pre ([=,&i,*this] mutable {
+      ++n;          // error: attempting to modify const lvalue
+      ++i;          // error: attempting to modify const lvalue
+      ++p;          // OK, refers to member of closure type
+      ++r;          // OK, refers to non-reference member of closure type
+      ++this->z;    // OK, captured *this
+      ++z;          // OK, captured *this
+      int j = 17;
+      [&]{
+        int k = 34;
+        ++i;    // error: attempting to modify const lvalue
+        ++j;    // OK
+        ++k;    // OK
+      }();
+      return true;
+    }());
+  template <int N, int& R, int* P>
+  void g()
+    pre(++N)        // error: attempting to modify prvalue
+    pre(++R)        // error: attempting to modify const lvalue
+    pre(++(*P));    // OK
+  int h()
+    post(r : ++r)   // error: attempting to modify const lvalue
+    post(r: [=] mutable {
+       ++r;         // OK, refers to member of closure type
+       return true;
+     }());
+  int& k()
+    post(r : ++r);  // error: attempting to modify const lvalue
+};
+```
+— *end example*]
+Otherwise, if the entity is a template parameter object for a template
 parameter of type `T` [[temp.param]], the type of the expression is
+`const T`.
+In all other cases, the type of the expression is the type of the
+entity.
+[*Note 4*: The type will be adjusted as described in [[expr.type]] if
 it is cv-qualified or is a reference type. — *end note*]
 The expression is an xvalue if it is move-eligible (see below); an
 lvalue if the entity is a function, variable, structured binding
+[[dcl.struct.bind]], result binding [[dcl.contract.res]], data member,
+or template parameter object; and a prvalue otherwise [[basic.lval]]; it
+is a bit-field if the identifier designates a bit-field.
+If an *id-expression* E appears in the predicate of a function contract
+assertion attached to a function *f* and denotes a function parameter of
+*f* and the implementation introduces any temporary objects to hold the
+value of that parameter as specified in [[class.temporary]],
+- if the contract assertion is a precondition assertion and the
+  evaluation of the precondition assertion is sequenced before the
+  initialization of the parameter object, E refers to the most recently
+  initialized such temporary object, and
+- if the contract assertion is a postcondition assertion, it is
+  unspecified whether E refers to one of the temporary objects or the
+  parameter object; the choice is consistent within a single evaluation
+  of a postcondition assertion.
+If an *id-expression* E names a result binding in a postcondition
+assertion and the implementation introduces any temporary objects to
+hold the result object as specified in [[class.temporary]], and the
+postcondition assertion is sequenced before the initialization of the
+result object [[expr.call]], E refers to the most recently initialized
+such temporary object.
+[*Example 2*:
 ``` cpp
 void f() {
   float x, &r = x;
 }
 ```
 — *end example*]
+An *implicitly movable entity* is a variable with automatic storage
 duration that is either a non-volatile object or an rvalue reference to
+a non-volatile object type. An *id-expression* or *splice-expression*
+[[expr.prim.splice]] is *move-eligible* if
+- it designates an implicitly movable entity,
+- it is the (possibly parenthesized) operand of a `return`
+ [[stmt.return]] or `co_return` [[stmt.return.coroutine]] statement or
+ of a *throw-expression* [[expr.throw]], and
+- each intervening scope between the declaration of the entity and the
+  innermost enclosing scope of the expression is a block scope and, for
+ a *throw-expression*, is not the block scope of a *try-block* or
+ *function-try-block*.
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
 ``` bnf
 nested-name-specifier:
     '::'
     type-name '::'
     namespace-name '::'
+ computed-type-specifier '::'
+    splice-scope-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
+``` bnf
+splice-scope-specifier:
+    splice-specifier
+    templateₒₚₜ splice-specialization-specifier
+```
 The component names of a *qualified-id* are those of its
 *nested-name-specifier* and *unqualified-id*. The component names of a
 *nested-name-specifier* are its *identifier* (if any) and those of its
 *type-name*, *namespace-name*, *simple-template-id*, and/or
 *nested-name-specifier*.
+A *splice-specifier* or *splice-specialization-specifier* that is not
+followed by `::` is never interpreted as part of a
+*splice-scope-specifier*. The keyword `template` may only be omitted
+from the form `\opt{template} splice-specialization-specifier ::` when
+the *splice-specialization-specifier* is preceded by `typename`.
+[*Example 1*:
+``` cpp
+template<int V>
+struct TCls {
+  static constexpr int s = V;
+  using type = int;
+};
+int v1 = [:^^TCls<1>:]::s;
+int v2 = template [:^^TCls:]<2>::s;             // OK, template binds to splice-scope-specifier
+typename [:^^TCls:]<3>::type v3 = 3;            // OK, typename binds to the qualified name
+template [:^^TCls:]<3>::type v4 = 4;            // OK, template binds to the splice-scope-specifier
+typename template [:^^TCls:]<3>::type v5 = 5;   // OK, same as v3
+[:^^TCls:]<3>::type v6 = 6;                     // error: unexpected <
+```
+— *end example*]
 A *nested-name-specifier* is *declarative* if it is part of
 - a *class-head-name*,
 - an *enum-head-name*,
 - a *qualified-id* that is the *id-expression* of a *declarator-id*, or
 - a declarative *nested-name-specifier*.
 A declarative *nested-name-specifier* shall not have a
+*computed-type-specifier* or a *splice-scope-specifier*. A declaration
+that uses a declarative *nested-name-specifier* shall be a friend
+declaration or inhabit a scope that contains the entity being redeclared
+or specialized.
+The entity designated by a *nested-name-specifier* is determined as
+follows:
+- The *nested-name-specifier* `::` designates the global namespace.
+- A *nested-name-specifier* with a *computed-type-specifier* designates
+  the same type designated by the *computed-type-specifier*, which shall
+  be a class or enumeration type.
+- For a *nested-name-specifier* of the form `splice-specifier ::`, the
+  *splice-specifier* shall designate a class or enumeration type or a
+  namespace. The *nested-name-specifier* designates the same entity as
+  the *splice-specifier*.
+- For a *nested-name-specifier* of the form
+  `\opt{template} splice-specialization-specifier ::`, the
+  *splice-specifier* of the *splice-specialization-specifier* shall
+  designate a class template or an alias template T. Letting S be the
+  specialization of T corresponding to the template argument list of the
+  *splice-specialization-specifier*, S shall either be a class template
+  specialization or an alias template specialization that denotes a
+  class or enumeration type. The *nested-name-specifier* designates the
+  underlying entity of S.
+- If a *nested-name-specifier* N is declarative and has a
+  *simple-template-id* with a template argument list A that involves a
   template parameter, let T be the template nominated by N without A. T
   shall be a class template.
   - If A is the template argument list [[temp.arg]] of the corresponding
+ *template-head* H [[temp.mem]], N designates the primary template of
+    T; H shall be equivalent to the *template-head* of T
+    [[temp.over.link]].
+ - Otherwise, N designates the partial specialization
+ [[temp.spec.partial]] of T whose template argument list is
+    equivalent to A [[temp.over.link]]; the program is ill-formed if no
+    such partial specialization exists.
+- Any other *nested-name-specifier* designates the entity denotes by its
+ *type-name*, *namespace-name*, *identifier*, or *simple-template-id*.
+  If the *nested-name-specifier* is not declarative, the entity shall
+  not be a template.
 A *qualified-id* shall not be of the form *nested-name-specifier*
+`template`ₒₚₜ  `~` *computed-type-specifier* nor of the form
+*computed-type-specifier* `::` `~` *type-name*.
 The result of a *qualified-id* Q is the entity it denotes
+[[basic.lookup.qual]].
+If Q appears in the predicate of a contract assertion C
+[[basic.contract]] and the entity is
+- a variable declared outside of C of object type `T`,
+- a variable declared outside of C of type “reference to `T`”, or
+- a structured binding of type `T` whose corresponding variable is
+  declared outside of C,
+then the type of the expression is `const` `T`.
+Otherwise, the type of the expression is the type of the result.
+The result is an lvalue if the member is
 - a function other than a non-static member function,
 - a non-static member function if Q is the operand of a unary `&`
   operator,
 - a variable,
 - a structured binding [[dcl.struct.bind]], or
 - a data member,
 and a prvalue otherwise.
+#### Pack indexing expression <a id="expr.prim.pack.index">[[expr.prim.pack.index]]</a>
+``` bnf
+pack-index-expression:
+    id-expression '...' '[' constant-expression ']'
+```
+The *id-expression* P in a *pack-index-expression* shall be an
+*identifier* that denotes a pack.
+The *constant-expression* shall be a converted constant expression
+[[expr.const]] of type `std::size_t` whose value V, termed the index, is
+such that 0 ≤ V < `sizeof...($P$)`.
+A *pack-index-expression* is a pack expansion [[temp.variadic]].
+[*Note 1*: A *pack-index-expression* denotes the Vᵗʰ element of the
+pack. — *end note*]
 #### Destruction <a id="expr.prim.id.dtor">[[expr.prim.id.dtor]]</a>
 An *id-expression* that denotes the destructor of a type `T` names the
 destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 *id-expression* is said to name a *pseudo-destructor*.
 ```
 ``` bnf
 lambda-declarator:
     lambda-specifier-seq noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
+       function-contract-specifier-seqₒₚₜ
+ noexcept-specifier attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ function-contract-specifier-seqₒₚₜ
+    trailing-return-typeₒₚₜ function-contract-specifier-seqₒₚₜ
     '(' parameter-declaration-clause ')' lambda-specifier-seqₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
+       trailing-return-typeₒₚₜ requires-clauseₒₚₜ function-contract-specifier-seqₒₚₜ
 ```
 ``` bnf
 lambda-specifier:
     consteval
     static
 ```
 ``` bnf
 lambda-specifier-seq:
+    lambda-specifier lambda-specifier-seqₒₚₜ
 ```
 A *lambda-expression* provides a concise way to create a simple function
 object.
 *attribute-specifier-seq*, which collides with the
 *attribute-specifier-seq* in *lambda-expression*. In such cases, any
 attributes are treated as *attribute-specifier-seq* in
 *lambda-expression*.
+[*Note 2*:
+Such ambiguous cases cannot have valid semantics because the constraint
+expression would not have type `bool`.
+[*Example 2*:
+``` cpp
+auto x = []<class T> requires T::operator int [[some_attribute]] (int) { }
+```
+— *end example*]
+— *end note*]
 A *lambda-specifier-seq* shall contain at most one of each
 *lambda-specifier* and shall not contain both `constexpr` and
 `consteval`. If the *lambda-declarator* contains an explicit object
 parameter [[dcl.fct]], then no *lambda-specifier* in the
 *lambda-capture*.
 [*Note 3*: The trailing *requires-clause* is described in
 [[dcl.decl]]. — *end note*]
+A *lambda-expression*'s *parameter-declaration-clause* is the
+*parameter-declaration-clause* of the *lambda-expression*'s
+*lambda-declarator*, if any, or empty otherwise. If the
+*lambda-declarator* does not include a *trailing-return-type*, it is
+considered to be `-> auto`.
 [*Note 4*: In that case, the return type is deduced from `return`
 statements as described in [[dcl.spec.auto]]. — *end note*]
+[*Example 3*:
 ``` cpp
 auto x1 = [](int i) { return i; };      // OK, return type is int
 auto x2 = []{ return { 1, 2 }; };       // error: deducing return type from braced-init-list
 int j;
 A lambda is a *generic lambda* if the *lambda-expression* has any
 generic parameter type placeholders [[dcl.spec.auto]], or if the lambda
 has a *template-parameter-list*.
+[*Example 4*:
 ``` cpp
+auto x = [](int i, auto a) { return i; }; // OK, a generic lambda
+auto y = [](this auto self, int i) { return i; }; // OK, a generic lambda
+auto z = []<class T>(int i) { return i; };              // OK, a generic lambda
 ```
 — *end example*]
 #### Closure types <a id="expr.prim.lambda.closure">[[expr.prim.lambda.closure]]</a>
 The type of a *lambda-expression* (which is also the type of the closure
 object) is a unique, unnamed non-union class type, called the *closure
 type*, whose properties are described below.
+The closure type is incomplete until the end of its corresponding
+*compound-statement*.
 The closure type is declared in the smallest block scope, class scope,
 or namespace scope that contains the corresponding *lambda-expression*.
 [*Note 1*: This determines the set of namespaces and classes associated
 with the closure type [[basic.lookup.argdep]]. The parameter types of a
 *lambda-declarator* do not affect these associated namespaces and
 classes. — *end note*]
+The closure type is not an aggregate type [[dcl.init.aggr]]; it is a
+structural type [[term.structural.type]] if and only if the lambda has
+no *lambda-capture*. An implementation may define the closure type
+differently from what is described below provided this does not alter
+the observable behavior of the program other than by changing:
 - the size and/or alignment of the closure type,
+- whether the closure type is trivially copyable [[class.prop]],
+- whether the closure type is trivially relocatable [[class.prop]],
+- whether the closure type is replaceable [[class.prop]], or
 - whether the closure type is a standard-layout class [[class.prop]].
 An implementation shall not add members of rvalue reference type to the
 closure type.
 The closure type for a *lambda-expression* has a public inline function
 call operator (for a non-generic lambda) or function call operator
 template (for a generic lambda) [[over.call]] whose parameters and
+return type are those of the *lambda-expression*'s
 *parameter-declaration-clause* and *trailing-return-type* respectively,
 and whose *template-parameter-list* consists of the specified
+*template-parameter-list*, if any. The function call operator or the
+function call operator template are direct members of the closure type.
+The *requires-clause* of the function call operator template is the
+*requires-clause* immediately following
 `<` *template-parameter-list* `>`, if any. The trailing
 *requires-clause* of the function call operator or operator template is
 the *requires-clause* of the *lambda-declarator*, if any.
 [*Note 2*: The function call operator template for a generic lambda can
 Given a lambda with a *lambda-capture*, the type of the explicit object
 parameter, if any, of the lambda’s function call operator (possibly
 instantiated from a function call operator template) shall be either:
 - the closure type,
+- a class type publicly and unambiguously derived from the closure type,
+  or
 - a reference to a possibly cv-qualified such type.
 [*Example 2*:
 ``` cpp
 `static`. Otherwise, it is a non-static member function or member
 function template [[class.mfct.non.static]] that is declared `const`
 [[class.mfct.non.static]] if and only if the *lambda-expression*’s
 *parameter-declaration-clause* is not followed by `mutable` and the
 *lambda-declarator* does not contain an explicit object parameter. It is
+neither virtual nor declared `volatile`. Any *noexcept-specifier* or
+*function-contract-specifier* [[dcl.contract.func]] specified on a
+*lambda-expression* applies to the corresponding function call operator
+or operator template. An *attribute-specifier-seq* in a
 *lambda-declarator* appertains to the type of the corresponding function
 call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-expression* preceding a *lambda-declarator* appertains to the
 corresponding function call operator or operator template. The function
 call operator or any given operator template specialization is a
 — *end example*]
 — *end note*]
+If all potential references to a local entity implicitly captured by a
+*lambda-expression* L occur within the function contract assertions
+[[dcl.contract.func]] of the call operator or operator template of L or
+within *assertion-statement*s [[stmt.contract.assert]] within the body
+of L, the program is ill-formed.
+[*Note 4*: Adding a contract assertion to an existing C++ program
+cannot cause additional captures. — *end note*]
+[*Example 6*:
+``` cpp
+static int i = 0;
+void test() {
+  auto f1 = [=] pre(i > 0) {};  // OK, no local entities are captured.
+  int i = 1;
+  auto f2 = [=] pre(i > 0) {};  // error: cannot implicitly capture i here
+  auto f3 = [i] pre(i > 0) {};  // OK, i is captured explicitly.
+  auto f4 = [=] {
+    contract_assert(i > 0);     // error: cannot implicitly capture i here
+  };
+  auto f5 = [=] {
+    contract_assert(i > 0);     // OK, i is referenced elsewhere.
+    (void)i;
+  };
+  auto f6 = [=] pre(                // #1
+    []{
+      bool x = true;
+      return [=]{ return x; }();    // OK, #1 captures nothing.
+    }()) {};
+  bool y = true;
+  auto f7 = [=] pre([=]{ return y; }());    // error: outer capture of y is invalid.
+}
+```
+— *end example*]
 The closure type for a non-generic *lambda-expression* with no
+*lambda-capture* and no explicit object parameter [[dcl.fct]] whose
+constraints (if any) are satisfied has a conversion function to pointer
+to function with C++ language linkage [[dcl.link]] having the same
+parameter and return types as the closure type’s function call operator.
+The conversion is to “pointer to `noexcept` function” if the function
+call operator has a non-throwing exception specification. If the
+function call operator is a static member function, then the value
+returned by this conversion function is a pointer to the function call
+operator. Otherwise, the value returned by this conversion function is a
+pointer to a function `F` that, when invoked, has the same effect as
+invoking the closure type’s function call operator on a
+default-constructed instance of the closure type. `F` is a constexpr
+function if the function call operator is a constexpr function and is an
+immediate function if the function call operator is an immediate
+function.
+For a generic lambda with no *lambda-capture* and no explicit object
+parameter [[dcl.fct]], the closure type has a conversion function
+template to pointer to function. The conversion function template has
+the same invented template parameter list, and the pointer to function
+has the same parameter types, as the function call operator template.
+The return type of the pointer to function shall behave as if it were a
+*decltype-specifier* denoting the return type of the corresponding
+function call operator template specialization.
+[*Note 5*:
 If the generic lambda has no *trailing-return-type* or the
 *trailing-return-type* contains a placeholder type, return type
 deduction of the corresponding function call operator template
 specialization has to be done. The corresponding specialization is that
 };
 ```
 — *end note*]
+[*Example 7*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 — *end example*]
 If the function call operator template is a static member function
 template, then the value returned by any given specialization of this
+conversion function template is a pointer to the corresponding function
+call operator template specialization. Otherwise, the value returned by
+any given specialization of this conversion function template is a
+pointer to a function `F` that, when invoked, has the same effect as
+invoking the generic lambda’s corresponding function call operator
+template specialization on a default-constructed instance of the closure
+type. `F` is a constexpr function if the corresponding specialization is
+a constexpr function and `F` is an immediate function if the function
+call operator template specialization is an immediate function.
+[*Note 6*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
+parameter types need to match the return type and parameter types of the
+pointer to function. — *end note*]
+[*Example 8*:
 ``` cpp
 auto GL = [](auto a) { std::cout << a; return a; };
 int (*GL_int)(int) = GL;        // OK, through conversion function template
 GL_int(3);                      // OK, same as GL(3)
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing
 exception specification [[except.spec]].
+[*Example 9*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
 The *lambda-expression*’s *compound-statement* yields the
 *function-body* [[dcl.fct.def]] of the function call operator, but it is
 not within the scope of the closure type.
+[*Example 10*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
 };
 ```
 — *end example*]
+Unless the *compound-statement* is that of a
+*consteval-block-declaration* [[dcl.pre]], a variable `__func__` is
+implicitly defined at the beginning of the *compound-statement* of the
+*lambda-expression*, with semantics as described in
+[[dcl.fct.def.general]].
 The closure type associated with a *lambda-expression* has no default
 constructor if the *lambda-expression* has a *lambda-capture* and a
 defaulted default constructor otherwise. It has a defaulted copy
 constructor and a defaulted move constructor [[class.copy.ctor]]. It has
 a deleted copy assignment operator if the *lambda-expression* has a
 *lambda-capture* and defaulted copy and move assignment operators
 otherwise [[class.copy.assign]].
+[*Note 7*: These special member functions are implicitly defined as
 usual, which can result in them being defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].
 ``` bnf
 simple-capture:
     identifier '...'ₒₚₜ
     '&' identifier '...'ₒₚₜ
     this
+    '*' this
 ```
 ``` bnf
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
 The body of a *lambda-expression* may refer to local entities of
+enclosing scopes by capturing those entities, as described below.
 If a *lambda-capture* includes a *capture-default* that is `&`, no
 identifier in a *simple-capture* of that *lambda-capture* shall be
 preceded by `&`. If a *lambda-capture* includes a *capture-default* that
 is `=`, each *simple-capture* of that *lambda-capture* shall be of the
 form “`&` *identifier* `...`ₒₚₜ ”, “`this`”, or “`* this`”.
 [*Note 1*: The form `[&,this]` is redundant but accepted for
+compatibility with C++14. — *end note*]
 Ignoring appearances in *initializer*s of *init-capture*s, an identifier
 or `this` shall not appear more than once in a *lambda-capture*.
 [*Example 1*:
 ```
 — *end example*]
 A *lambda-expression* shall not have a *capture-default* or
+*simple-capture* in its *lambda-introducer* unless
+- its innermost enclosing scope is a block scope [[basic.scope.block]],
+- it appears within a default member initializer and its innermost
+  enclosing scope is the corresponding class scope
+  [[basic.scope.class]], or
+- it appears within a contract assertion and its innermost enclosing
+  scope is the corresponding contract-assertion scope
+  [[basic.scope.contract]].
 The *identifier* in a *simple-capture* shall denote a local entity
 [[basic.lookup.unqual]], [[basic.pre]]. The *simple-capture*s `this` and
 `* this` denote the local entity `*this`. An entity that is designated
 by a *simple-capture* is said to be *explicitly captured*.
 An entity is *captured by copy* if
 - it is implicitly captured, the *capture-default* is `=`, and the
   captured entity is not `*this`, or
 - it is explicitly captured with a capture that is not of the form
+  `this`, `&` *identifier* `...`ₒₚₜ , or `&` `...`ₒₚₜ  *identifier*
+  *initializer*.
 For each entity captured by copy, an unnamed non-static data member is
 declared in the closure type. The declaration order of these members is
 unspecified. The type of such a data member is the referenced type if
 the entity is a reference to an object, an lvalue reference to the
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
+    int arr[N];     // OK, not an odr-use, refers to variable with automatic storage duration
     f(&N);          // OK, causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```
 }
 ```
 — *end example*]
+A fold expression is a pack expansion.
 ### Requires expressions <a id="expr.prim.req">[[expr.prim.req]]</a>
 #### General <a id="expr.prim.req.general">[[expr.prim.req.general]]</a>
 A *requires-expression* provides a concise way to express requirements
     '{' requirement-seq '}'
 ```
 ``` bnf
 requirement-seq:
+    requirement requirement-seqₒₚₜ
 ```
 ``` bnf
 requirement:
     simple-requirement
     compound-requirement
     nested-requirement
 ```
 A *requires-expression* is a prvalue of type `bool` whose value is
+described below.
 [*Example 1*:
 A common use of *requires-expression*s is to define requirements in
 concepts such as the one below:
 introduces the *requires-expression*.
 — *end example*]
 A *requires-expression* may introduce local parameters using a
+*parameter-declaration-clause*. A local parameter of a
+*requires-expression* shall not have a default argument. The type of
+such a parameter is determined as specified for a function parameter in
+[[dcl.fct]]. These parameters have no linkage, storage, or lifetime;
+they are only used as notation for the purpose of defining
+*requirement*s. The *parameter-declaration-clause* of a
+*requirement-parameter-list* shall not terminate with an ellipsis.
 [*Example 2*:
 ``` cpp
 template<typename T>
 concept C = requires(T t, ...) {    // error: terminates with an ellipsis
   t;
 };
+template<typename T>
+concept C2 = requires(T p[2]) {
+  (decltype(p))nullptr;             // OK, p has type ``pointer to T''
+};
 ```
 — *end example*]
+The substitution of template arguments into a *requires-expression* can
+result in the formation of invalid types or expressions in the immediate
+context of its *requirement*s [[temp.deduct.general]] or the violation
+of the semantic constraints of those *requirement*s. In such cases, the
+*requires-expression* evaluates to `false`; it does not cause the
+program to be ill-formed. The substitution and semantic constraint
+checking proceeds in lexical order and stops when a condition that
+determines the result of the *requires-expression* is encountered. If
+substitution (if any) and semantic constraint checking succeed, the
+*requires-expression* evaluates to `true`.
 [*Note 1*: If a *requires-expression* contains invalid types or
 expressions in its *requirement*s, and it does not appear within the
 declaration of a templated entity, then the program is
 ill-formed. — *end note*]
 [*Example 3*:
 ``` cpp
 template<typename T> concept C =
 requires {
+  new decltype((void)T{}); // ill-formed, no diagnostic required
 };
 ```
 — *end example*]
 ``` bnf
 simple-requirement:
     expression ';'
 ```
+A *simple-requirement* asserts the validity of an *expression*. The
+*expression* is an unevaluated operand.
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
+if substitution of template arguments into the *expression*
+fails. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename T> concept C =
 #### Type requirements <a id="expr.prim.req.type">[[expr.prim.req.type]]</a>
 ``` bnf
 type-requirement:
     typename nested-name-specifierₒₚₜ type-name ';'
+    typename splice-specifier
+    typename splice-specialization-specifier
 ```
+A *type-requirement* asserts the validity of a type. The component names
+of a *type-requirement* are those of its *nested-name-specifier* (if
+any) and *type-name* (if any).
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
 if substitution of template arguments fails. — *end note*]
 [*Example 1*:
 template<typename T, typename T::type = 0> struct S;
 template<typename T> using Ref = T&;
 template<typename T> concept C = requires {
   typename T::inner;        // required nested member name
+  typename S<T>; // required valid[temp.names] template-id; fails if T::type does not exist as a type
+ // to which 0 can be implicitly converted
   typename Ref<T>;          // required alias template substitution, fails if T is void
+  typename [:T::r1:];       // fails if T::r1 is not a reflection of a type
+  typename [:T::r2:]<int>;  // fails if T::r2 is not a reflection of a template Z for which Z<int> is a type
 };
 ```
 — *end example*]
 ``` bnf
 return-type-requirement:
     '->' type-constraint
 ```
+A *compound-requirement* asserts properties of the *expression* E. The
+*expression* is an unevaluated operand. Substitution of template
+arguments (if any) and verification of semantic properties proceed in
+the following order:
 - Substitution of template arguments (if any) into the *expression* is
   performed.
 - If the `noexcept` specifier is present, E shall not be a
   potentially-throwing expression [[except.spec]].
 `D<T>` is satisfied if `sizeof(decltype (+t)) == 1`
 [[temp.constr.atomic]].
 — *end example*]
+### Expression splicing <a id="expr.prim.splice">[[expr.prim.splice]]</a>
+``` bnf
+splice-expression:
+    splice-specifier
+    template splice-specifier
+    template splice-specialization-specifier
+```
+A *splice-specifier* or *splice-specialization-specifier* immediately
+followed by `::` or preceded by `typename` is never interpreted as part
+of a *splice-expression*.
+[*Example 1*:
+``` cpp
+struct S { static constexpr int a = 1; };
+template<typename> struct TCls { static constexpr int b = 2; };
+constexpr int c = [:^^S:]::a;                   // OK, [:^^ S:] is not an expression
+constexpr int d = template [:^^TCls:]<int>::b;  // OK, template [:^^ TCls:]<int> is not an expression
+template<auto V> constexpr int e = [:V:];       // OK
+constexpr int f = template [:^^e:]<^^S::a>;     // OK
+constexpr auto g = typename [:^^int:](42);      // OK, typename [:^^ int:] is a splice-type-specifier
+constexpr auto h = ^^g;
+constexpr auto i = e<[:^^h:]>;          // error: unparenthesized splice-expression used as template argument
+constexpr auto j = e<([:^^h:])>;        // OK
+```
+— *end example*]
+For a *splice-expression* of the form *splice-specifier*, let S be the
+construct designated by *splice-specifier*.
+- The expression is ill-formed if S is
+  - a constructor,
+  - a destructor,
+  - an unnamed bit-field, or
+  - a local entity [[basic.pre]] such that
+    - there is a lambda scope that intervenes between the expression and
+      the point at which S was introduced and
+    - the expression would be potentially evaluated if the effect of any
+      enclosing `typeid` expressions [[expr.typeid]] were ignored.
+- Otherwise, if S is a function F, the expression denotes an overload
+  set containing all declarations of F that precede either the
+  expression or the point immediately following the *class-specifier* of
+  the outermost class for which the expression is in a complete-class
+  context; overload resolution is performed
+  [[over.match]], [[over.over]].
+- Otherwise, if S is an object or a non-static data member, the
+  expression is an lvalue designating S. The expression has the same
+  type as that of S, and is a bit-field if and only if S is a bit-field.
+  \[*Note 1*: The implicit transformation whereby an *id-expression*
+  denoting a non-static member becomes a class member access
+  [[expr.prim.id]] does not apply to a
+  *splice-expression*. — *end note*]
+- Otherwise, if S is a variable or a structured binding, S shall either
+  have static or thread storage duration or shall inhabit a scope
+  enclosing the expression. The expression is an lvalue referring to the
+  object or function X associated with or referenced by S, has the same
+  type as that of S, and is a bit-field if and only if X is a bit-field.
+  \[*Note 2*: The type of a *splice-expression* designating a variable
+  or structured binding of reference type will be adjusted to a
+  non-reference type [[expr.type]]. — *end note*]
+- Otherwise, if S is a value or an enumerator, the expression is a
+  prvalue that computes S and whose type is the same as that of S.
+- Otherwise, the expression is ill-formed.
+For a *splice-expression* of the form `template splice-specifier`, the
+*splice-specifier* shall designate a function template T that is not a
+constructor template. The expression denotes an overload set containing
+all declarations of T that precede either the expression or the point
+immediately following the *class-specifier* of the outermost class for
+which the expression is in a complete-class context; overload resolution
+is performed.
+[*Note 3*: During overload resolution, candidate function templates
+undergo template argument deduction and the resulting specializations
+are considered as candidate functions. — *end note*]
+For a *splice-expression* of the form
+`template splice-specialization-specifier`, the *splice-specifier* of
+the *splice-specialization-specifier* shall designate a template T.
+- If T is a function template, the expression denotes an overload set
+  containing all declarations of T that precede either the expression or
+  the point immediately following the *class-specifier* of the outermost
+  class for which the expression is in a complete-class context;
+  overload resolution is performed [[over.match]], [[over.over]].
+- Otherwise, if T is a variable template, let S be the specialization of
+  T corresponding to the template argument list of the
+  *splice-specialization-specifier*. The expression is an lvalue
+  referring to the object associated with S and has the same type as
+  that of S.
+- Otherwise, the expression is ill-formed.
+[*Note 4*: Class members are accessible from any point when designated
+by *splice-expression*s [[class.access.base]]. A class member access
+expression [[expr.ref]] whose right operand is a *splice-expression* is
+ill-formed if the left operand (considered as a pointer) cannot be
+implicitly converted to a pointer to the designating class of the right
+operand. — *end note*]

Diff to HTML by rtfpessoa