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

Files changed (1) hide show

tmp/tmpjy5su6eb/{from.md → to.md} +326 -140

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

@@ -18,10 +18,11 @@ unary-expression:
     sizeof '...' '(' identifier ')'
     alignof '(' type-id ')'
     noexcept-expression
     new-expression
     delete-expression
 ```
 ``` bnf
 %% Ed. note: character protrusion would misalign operators.
@@ -31,33 +32,42 @@ unary-operator: one of
 #### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
 The unary `*` operator performs *indirection*. Its operand shall be a
 prvalue of type “pointer to `T`”, where `T` is an object or function
-type. The operator yields an lvalue of type `T` denoting the object or
-function to which the operand points.
-[*Note 1*: Indirection through a pointer to an incomplete type (other
 than cv `void`) is valid. The lvalue thus obtained can be used in
 limited ways (to initialize a reference, for example); this lvalue must
 not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
 Each of the following unary operators yields a prvalue.
 The operand of the unary `&` operator shall be an lvalue of some type
-`T`. The result is a prvalue.
-- If the operand is a *qualified-id* naming a non-static or variant
-  member `m` of some class `C`, other than an explicit object member
-  function, the result has type “pointer to member of class `C` of type
- `T`” and designates `C::m`.
 - Otherwise, the result has type “pointer to `T`” and points to the
   designated object [[intro.memory]] or function [[basic.compound]]. If
-  the operand names an explicit object member function [[dcl.fct]], the
-  operand shall be a *qualified-id*. \[*Note 2*: In particular, taking
- the address of a variable of type “cv `T`” yields a pointer of type
-  “pointer to cv `T`”. — *end note*]
 [*Example 1*:
 ``` cpp
 struct A { int i; };
@@ -69,18 +79,19 @@ int* p2 = p1 + 1;   // defined behavior
 bool b = p2 > p1;   // defined behavior, with value true
 ```
 — *end example*]
-[*Note 3*: A pointer to member formed from a `mutable` non-static data
 member [[dcl.stc]] does not reflect the `mutable` specifier associated
 with the non-static data member. — *end note*]
 A pointer to member is only formed when an explicit `&` is used and its
-operand is a *qualified-id* not enclosed in parentheses.
-[*Note 4*: That is, the expression `&(qualified-id)`, where the
 *qualified-id* is enclosed in parentheses, does not form an expression
 of type “pointer to member”. Neither does `qualified-id`, because there
 is no implicit conversion from a *qualified-id* for a non-static member
 function to the type “pointer to member function” as there is from an
 lvalue of function type to the type “pointer to function” [[conv.func]].
@@ -90,99 +101,96 @@ the *unqualified-id*’s class. — *end note*]
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
-[*Note 5*: The address of an overload set [[over]] can be taken only in
 a context that uniquely determines which function is referred to (see
 [[over.over]]). Since the context can affect whether the operand is a
 static or non-static member function, the context can also affect
 whether the expression has type “pointer to function” or “pointer to
 member function”. — *end note*]
-The operand of the unary `+` operator shall have arithmetic, unscoped
-enumeration, or pointer type and the result is the value of the
 argument. Integral promotion is performed on integral or enumeration
 operands. The type of the result is the type of the promoted operand.
-The operand of the unary `-` operator shall have arithmetic or unscoped
-enumeration type and the result is the negative of its operand. Integral
-promotion is performed on integral or enumeration operands. The negative
-of an unsigned quantity is computed by subtracting its value from 2ⁿ,
-where n is the number of bits in the promoted operand. The type of the
-result is the type of the promoted operand.
-[*Note 6*: The result is the two’s complement of the operand (where
 operand and result are considered as unsigned). — *end note*]
 The operand of the logical negation operator `!` is contextually
 converted to `bool` [[conv]]; its value is `true` if the converted
 operand is `false` and `false` otherwise. The type of the result is
 `bool`.
-The operand of the `~` operator shall have integral or unscoped
-enumeration type. Integral promotions are performed. The type of the
-result is the type of the promoted operand. Given the coefficients `xᵢ`
-of the base-2 representation [[basic.fundamental]] of the promoted
-operand `x`, the coefficient `rᵢ` of the base-2 representation of the
-result `r` is 1 if `xᵢ` is 0, and 0 otherwise.
-[*Note 7*: The result is the ones’ complement of the operand (where
 operand and result are considered as unsigned). — *end note*]
 There is an ambiguity in the grammar when `~` is followed by a
-*type-name* or *decltype-specifier*. The ambiguity is resolved by
 treating `~` as the operator rather than as the start of an
 *unqualified-id* naming a destructor.
-[*Note 8*: Because the grammar does not permit an operator to follow
 the `.`, `->`, or `::` tokens, a `~` followed by a *type-name* or
-*decltype-specifier* in a member access expression or *qualified-id* is
-unambiguously parsed as a destructor name. — *end note*]
 #### Increment and decrement <a id="expr.pre.incr">[[expr.pre.incr]]</a>
-The operand of prefix `++` is modified [[defns.access]] by adding `1`.
-The operand shall be a modifiable lvalue. The type of the operand shall
-be an arithmetic type other than cv `bool`, or a pointer to a
-completely-defined object type. An operand with volatile-qualified type
-is deprecated; see  [[depr.volatile.type]]. The result is the updated
-operand; it is an lvalue, and it is a bit-field if the operand is a
-bit-field. The expression `++x` is equivalent to `x+=1`.
-[*Note 1*: See the discussions of addition [[expr.add]] and assignment
-operators [[expr.ass]] for information on conversions. — *end note*]
-The operand of prefix `--` is modified [[defns.access]] by subtracting
-`1`. The requirements on the operand of prefix `--` and the properties
-of its result are otherwise the same as those of prefix `++`.
-[*Note 2*: For postfix increment and decrement, see
 [[expr.post.incr]]. — *end note*]
 #### Await <a id="expr.await">[[expr.await]]</a>
 The `co_await` expression is used to suspend evaluation of a coroutine
 [[dcl.fct.def.coroutine]] while awaiting completion of the computation
-represented by the operand expression.
 ``` bnf
 await-expression:
- 'co_await' cast-expression
 ```
-An *await-expression* shall appear only in a potentially-evaluated
-expression within the *compound-statement* of a *function-body* outside
-of a *handler* [[except.pre]]. In a *declaration-statement* or in the
 *simple-declaration* (if any) of an *init-statement*, an
 *await-expression* shall appear only in an *initializer* of that
 *declaration-statement* or *simple-declaration*. An *await-expression*
 shall not appear in a default argument [[dcl.fct.default]]. An
 *await-expression* shall not appear in the initializer of a block
-variable with static or thread storage duration. A context within a
-function where an *await-expression* can appear is called a *suspension
-context* of the function.
 Evaluation of an *await-expression* involves the following auxiliary
 types, expressions, and objects:
 - *p* is an lvalue naming the promise object [[dcl.fct.def.coroutine]]
@@ -302,11 +310,11 @@ to any other fundamental type [[basic.fundamental]] is
 [*Note 1*:
 In particular, the values of `sizeof(bool)`, `sizeof(char16_t)`,
 `sizeof(char32_t)`, and `sizeof(wchar_t)` are
-implementation-defined.[^21]
 — *end note*]
 [*Note 2*: See  [[intro.memory]] for the definition of byte and
 [[term.object.representation]] for the definition of object
@@ -315,83 +323,84 @@ representation. — *end note*]
 When applied to a reference type, the result is the size of the
 referenced type. When applied to a class, the result is the number of
 bytes in an object of that class including any padding required for
 placing objects of that type in an array. The result of applying
 `sizeof` to a potentially-overlapping subobject is the size of the type,
-not the size of the subobject.[^22]
 When applied to an array, the result is the total number of bytes in the
 array. This implies that the size of an array of n elements is n times
 the size of an element.
 The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are not applied
 to the operand of `sizeof`. If the operand is a prvalue, the temporary
 materialization conversion [[conv.rval]] is applied.
-The identifier in a `sizeof...` expression shall name a pack. The
 `sizeof...` operator yields the number of elements in the pack
 [[temp.variadic]]. A `sizeof...` expression is a pack expansion
 [[temp.variadic]].
 [*Example 1*:
 ``` cpp
 template<class... Types>
 struct count {
-  static const std::size_t value = sizeof...(Types);
 };
 ```
 — *end example*]
 The result of `sizeof` and `sizeof...` is a prvalue of type
 `std::size_t`.
 [*Note 3*: A `sizeof` expression is an integral constant expression
-[[expr.const]]. The type `std::size_t` is defined in the standard header
-`<cstddef>` [[cstddef.syn]], [[support.types.layout]]. — *end note*]
 #### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 An `alignof` expression yields the alignment requirement of its operand
 type. The operand shall be a *type-id* representing a complete object
 type, or an array thereof, or a reference to one of those types.
 The result is a prvalue of type `std::size_t`.
 [*Note 1*: An `alignof` expression is an integral constant expression
-[[expr.const]]. The type `std::size_t` is defined in the standard header
-`<cstddef>` [[cstddef.syn]], [[support.types.layout]]. — *end note*]
 When `alignof` is applied to a reference type, the result is the
 alignment of the referenced type. When `alignof` is applied to an array
 type, the result is the alignment of the element type.
 #### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
-The `noexcept` operator determines whether the evaluation of its
-operand, which is an unevaluated operand [[term.unevaluated.operand]],
-can throw an exception [[except.throw]].
 ``` bnf
 noexcept-expression:
   noexcept '(' expression ')'
 ```
-The result of the `noexcept` operator is a prvalue of type `bool`.
 [*Note 1*: A *noexcept-expression* is an integral constant expression
 [[expr.const]]. — *end note*]
-The result of the `noexcept` operator is `true` unless the *expression*
-is potentially-throwing [[except.spec]].
 #### New <a id="expr.new">[[expr.new]]</a>
-The *new-expression* attempts to create an object of the *type-id*
-[[dcl.name]] or *new-type-id* to which it is applied. The type of that
 object is the *allocated type*. This type shall be a complete object
 type [[term.incomplete.type]], but not an abstract class type
 [[class.abstract]] or array thereof [[intro.object]].
 [*Note 1*: Because references are not objects, references cannot be
@@ -433,17 +442,17 @@ noptr-new-declarator:
 new-initializer:
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
-If a placeholder type [[dcl.spec.auto]] appears in the
-*type-specifier-seq* of a *new-type-id* or *type-id* of a
-*new-expression*, the allocated type is deduced as follows: Let *init*
-be the *new-initializer*, if any, and `T` be the *new-type-id* or
-*type-id* of the *new-expression*, then the allocated type is the type
-deduced for the variable `x` in the invented declaration
-[[dcl.spec.auto]]:
 ``` cpp
 T x init ;
 ```
@@ -515,34 +524,41 @@ converted constant expression [[expr.const]] of type `std::size_t` and
 its value shall be greater than zero.
 [*Example 4*: Given the definition `int n = 42`, `new float[n][5]` is
 well-formed (because `n` is the *expression* of a
 *noptr-new-declarator*), but `new float[5][n]` is ill-formed (because
-`n` is not a constant expression). — *end example*]
 If the *type-id* or *new-type-id* denotes an array type of unknown bound
 [[dcl.array]], the *new-initializer* shall not be omitted; the allocated
 object is an array with `n` elements, where `n` is determined from the
 number of initial elements supplied in the *new-initializer*
 [[dcl.init.aggr]], [[dcl.init.string]].
 If the *expression* in a *noptr-new-declarator* is present, it is
-implicitly converted to `std::size_t`. The *expression* is erroneous if:
 - the expression is of non-class type and its value before converting to
   `std::size_t` is less than zero;
 - the expression is of class type and its value before application of
-  the second standard conversion [[over.ics.user]][^23] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
   the *implementation-defined* limit [[implimits]]; or
 - the *new-initializer* is a *braced-init-list* and the number of array
   elements for which initializers are provided (including the
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
-If the *expression* is erroneous after converting to `std::size_t`:
 - if the *expression* is a potentially-evaluated core constant
   expression, the program is ill-formed;
 - otherwise, an allocation function is not called; instead
   - if the allocation function that would have been called has a
@@ -554,24 +570,34 @@ If the *expression* is erroneous after converting to `std::size_t`:
     `std::bad_array_new_length` [[new.badlength]].
 When the value of the *expression* is zero, the allocation function is
 called to allocate an array with no elements.
 Objects created by a *new-expression* have dynamic storage duration
 [[basic.stc.dynamic]].
-[*Note 5*:  The lifetime of such an object is not necessarily
 restricted to the scope in which it is created. — *end note*]
 When the allocated type is “array of `N` `T`” (that is, the
 *noptr-new-declarator* syntax is used or the *new-type-id* or *type-id*
 denotes an array type), the *new-expression* yields a prvalue of type
 “pointer to `T`” that points to the initial element (if any) of the
 array. Otherwise, let `T` be the allocated type; the *new-expression* is
 a prvalue of type “pointer to T” that points to the object created.
-[*Note 6*: Both `new int` and `new int[10]` have type `int*` and the
 type of `new int[i][10]` is `int (*)[10]`. — *end note*]
 A *new-expression* may obtain storage for the object by calling an
 allocation function [[basic.stc.dynamic.allocation]]. If the
 *new-expression* terminates by throwing an exception, it may release
@@ -580,11 +606,11 @@ storage by calling a deallocation function
 type, the allocation function’s name is `operator new` and the
 deallocation function’s name is `operator delete`. If the allocated type
 is an array type, the allocation function’s name is `operator new[]` and
 the deallocation function’s name is `operator delete[]`.
-[*Note 7*: An implementation is required to provide default definitions
 for the global allocation functions
 [[basic.stc.dynamic]], [[new.delete.single]], [[new.delete.array]]. A
 C++ program can provide alternative definitions of these functions
 [[replacement.functions]] and/or class-specific versions [[class.free]].
 The set of allocation and deallocation functions that can be called by a
@@ -601,16 +627,12 @@ global scope.
 An implementation is allowed to omit a call to a replaceable global
 allocation function [[new.delete.single]], [[new.delete.array]]. When it
 does so, the storage is instead provided by the implementation or
 provided by extending the allocation of another *new-expression*.
-During an evaluation of a constant expression, a call to an allocation
-function is always omitted.
-[*Note 8*: Only *new-expression*s that would otherwise result in a call
-to a replaceable global allocation function can be evaluated in constant
-expressions [[expr.const]]. — *end note*]
 The implementation may extend the allocation of a *new-expression* `e1`
 to provide storage for a *new-expression* `e2` if the following would be
 true were the allocation not extended:
@@ -749,13 +771,13 @@ not be done, the deallocation function shall not be called, and the
 value of the *new-expression* shall be null.
 [*Note 11*: When the allocation function returns a value other than
 null, it must be a pointer to a block of storage in which space for the
 object has been reserved. The block of storage is assumed to be
-appropriately aligned and of the requested size. The address of the
-created object will not necessarily be the same as that of the block if
-the object is an array. — *end note*]
 A *new-expression* that creates an object of type `T` initializes that
 object as follows:
 - If the *new-initializer* is omitted, the object is default-initialized
@@ -767,18 +789,14 @@ object as follows:
 The invocation of the allocation function is sequenced before the
 evaluations of expressions in the *new-initializer*. Initialization of
 the allocated object is sequenced before the value computation of the
 *new-expression*.
-If the *new-expression* creates an object or an array of objects of
-class type, access and ambiguity control are done for the allocation
-function, the deallocation function [[basic.stc.dynamic.deallocation]],
-and the constructor [[class.ctor]] selected for the initialization (if
-any). If the *new-expression* creates an array of objects of class type,
-the destructor is potentially invoked [[class.dtor]].
-If any part of the object initialization described above[^24]
 terminates by throwing an exception and a suitable deallocation function
 can be found, the deallocation function is called to free the memory in
 which the object was being constructed, after which the exception
 continues to propagate in the context of the *new-expression*. If no
@@ -803,11 +821,13 @@ single matching deallocation function, that function will be called;
 otherwise, no deallocation function will be called. If the lookup finds
 a usual deallocation function and that function, considered as a
 placement deallocation function, would have been selected as a match for
 the allocation function, the program is ill-formed. For a non-placement
 allocation function, the normal deallocation function lookup is used to
-find the matching deallocation function [[expr.delete]].
 [*Example 7*:
 ``` cpp
 struct S {
@@ -846,30 +866,26 @@ delete-expression:
 ```
 The first alternative is a *single-object delete expression*, and the
 second is an *array delete expression*. Whenever the `delete` keyword is
 immediately followed by empty square brackets, it shall be interpreted
-as the second alternative.[^25]
-The operand shall be of pointer to object type or of class type. If of
-class type, the operand is contextually implicitly converted [[conv]] to
-a pointer to object type.[^26]
-The *delete-expression* has type `void`.
-If the operand has a class type, the operand is converted to a pointer
-type by calling the above-mentioned conversion function, and the
-converted operand is used in place of the original operand for the
-remainder of this subclause. In a single-object delete expression, the
-value of the operand of `delete` may be a null pointer value, a pointer
-value that resulted from a previous non-array *new-expression*, or a
-pointer to a base class subobject of an object created by such a
-*new-expression*. If not, the behavior is undefined. In an array delete
-expression, the value of the operand of `delete` may be a null pointer
-value or a pointer value that resulted from a previous array
-*new-expression* whose allocation function was not a non-allocating form
-[[new.delete.placement]].[^27]
 If not, the behavior is undefined.
 [*Note 1*: This means that the syntax of the *delete-expression* must
 match the type of the object allocated by `new`, not the syntax of the
@@ -887,24 +903,21 @@ delete, the static type shall be a base class of the dynamic type of the
 object to be deleted and the static type shall have a virtual destructor
 or the behavior is undefined. In an array delete expression, if the
 dynamic type of the object to be deleted is not similar to its static
 type, the behavior is undefined.
-The *cast-expression* in a *delete-expression* shall be evaluated
-exactly once.
 If the object being deleted has incomplete class type at the point of
-deletion and the complete class has a non-trivial destructor or a
-deallocation function, the behavior is undefined.
 If the value of the operand of the *delete-expression* is not a null
 pointer value and the selected deallocation function (see below) is not
-a destroying operator delete, the *delete-expression* will invoke the
-destructor (if any) for the object or the elements of the array being
-deleted. In the case of an array, the elements will be destroyed in
-order of decreasing address (that is, in reverse order of the completion
-of their constructor; see  [[class.base.init]]).
 If the value of the operand of the *delete-expression* is not a null
 pointer value, then:
 - If the allocation call for the *new-expression* for the object to be
@@ -961,12 +974,11 @@ declarations other than of usual deallocation functions
 [*Note 5*: If only a placement deallocation function is found in a
 class, the program is ill-formed because the lookup set is empty
 [[basic.lookup]]. — *end note*]
-If more than one deallocation function is found, the function to be
-called is selected as follows:
 - If any of the deallocation functions is a destroying operator delete,
   all deallocation functions that are not destroying operator deletes
   are eliminated from further consideration.
 - If the type has new-extended alignment, a function with a parameter of
@@ -982,10 +994,15 @@ called is selected as follows:
   or a (possibly multidimensional) array thereof, the function with a
   parameter of type `std::size_t` is selected.
 - Otherwise, it is unspecified whether a deallocation function with a
   parameter of type `std::size_t` is selected.
 For a single-object delete expression, the deleted object is the object
 A pointed to by the operand if the static type of A does not have a
 virtual destructor, and the most-derived object of A otherwise.
 [*Note 6*: If the deallocation function is not a destroying operator
@@ -1016,8 +1033,177 @@ passed as the corresponding argument.
 function, and either the first argument was not the result of a prior
 call to a replaceable allocation function or the second or third
 argument was not the corresponding argument in said call, the behavior
 is undefined [[new.delete.single]], [[new.delete.array]]. — *end note*]
-Access and ambiguity control are done for both the deallocation function
-and the destructor [[class.dtor]], [[class.free]].

     sizeof '...' '(' identifier ')'
     alignof '(' type-id ')'
     noexcept-expression
     new-expression
     delete-expression
+    reflect-expression
 ```
 ``` bnf
 %% Ed. note: character protrusion would misalign operators.
 #### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
 The unary `*` operator performs *indirection*. Its operand shall be a
 prvalue of type “pointer to `T`”, where `T` is an object or function
+type. The operator yields an lvalue of type `T`. If the operand points
+to an object or function, the result denotes that object or function;
+otherwise, the behavior is undefined except as specified in
+[[expr.typeid]].
+[*Note 1*: Indirection through a pointer to an out-of-lifetime object
+is valid [[basic.life]]. — *end note*]
+[*Note 2*:  Indirection through a pointer to an incomplete type (other
 than cv `void`) is valid. The lvalue thus obtained can be used in
 limited ways (to initialize a reference, for example); this lvalue must
 not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
 Each of the following unary operators yields a prvalue.
 The operand of the unary `&` operator shall be an lvalue of some type
+`T`.
+- If the operand is a *qualified-id* or *splice-expression* designating
+ a non-static member `m`, other than an explicit object member
+  function, `m` shall be a direct member of some class `C` that is not
+ an anonymous union. The result has type “pointer to member of class
+  `C` of type `T`” and designates `C::m`. \[*Note 3*: A *qualified-id*
+  that names a member of a namespace-scope anonymous union is considered
+  to be a class member access expression [[expr.prim.id.general]] and
+  cannot be used to form a pointer to member. — *end note*]
 - Otherwise, the result has type “pointer to `T`” and points to the
   designated object [[intro.memory]] or function [[basic.compound]]. If
+  the operand designates an explicit object member function [[dcl.fct]],
+ the operand shall be a *qualified-id* or a *splice-expression*.
+ \[*Note 4*: In particular, taking the address of a variable of type
+  “cv `T`” yields a pointer of type “pointer to cv `T`”. — *end note*]
 [*Example 1*:
 ``` cpp
 struct A { int i; };
 bool b = p2 > p1;   // defined behavior, with value true
 ```
 — *end example*]
+[*Note 5*: A pointer to member formed from a `mutable` non-static data
 member [[dcl.stc]] does not reflect the `mutable` specifier associated
 with the non-static data member. — *end note*]
 A pointer to member is only formed when an explicit `&` is used and its
+operand is a *qualified-id* or *splice-expression* not enclosed in
+parentheses.
+[*Note 6*: That is, the expression `&(qualified-id)`, where the
 *qualified-id* is enclosed in parentheses, does not form an expression
 of type “pointer to member”. Neither does `qualified-id`, because there
 is no implicit conversion from a *qualified-id* for a non-static member
 function to the type “pointer to member function” as there is from an
 lvalue of function type to the type “pointer to function” [[conv.func]].
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
+[*Note 7*: The address of an overload set [[over]] can be taken only in
 a context that uniquely determines which function is referred to (see
 [[over.over]]). Since the context can affect whether the operand is a
 static or non-static member function, the context can also affect
 whether the expression has type “pointer to function” or “pointer to
 member function”. — *end note*]
+The operand of the unary `+` operator shall be a prvalue of arithmetic,
+unscoped enumeration, or pointer type and the result is the value of the
 argument. Integral promotion is performed on integral or enumeration
 operands. The type of the result is the type of the promoted operand.
+The operand of the unary `-` operator shall be a prvalue of arithmetic
+or unscoped enumeration type and the result is the negative of its
+operand. Integral promotion is performed on integral or enumeration
+operands. The negative of an unsigned quantity is computed by
+subtracting its value from 2ⁿ, where n is the number of bits in the
+promoted operand. The type of the result is the type of the promoted
+operand.
+[*Note 8*: The result is the two’s complement of the operand (where
 operand and result are considered as unsigned). — *end note*]
 The operand of the logical negation operator `!` is contextually
 converted to `bool` [[conv]]; its value is `true` if the converted
 operand is `false` and `false` otherwise. The type of the result is
 `bool`.
+The operand of the `~` operator shall be a prvalue of integral or
+unscoped enumeration type. Integral promotions are performed. The type
+of the result is the type of the promoted operand. Given the
+coefficients `xᵢ` of the base-2 representation [[basic.fundamental]] of
+the promoted operand `x`, the coefficient `rᵢ` of the base-2
+representation of the result `r` is 1 if `xᵢ` is 0, and 0 otherwise.
+[*Note 9*: The result is the ones’ complement of the operand (where
 operand and result are considered as unsigned). — *end note*]
 There is an ambiguity in the grammar when `~` is followed by a
+*type-name* or *computed-type-specifier*. The ambiguity is resolved by
 treating `~` as the operator rather than as the start of an
 *unqualified-id* naming a destructor.
+[*Note 10*: Because the grammar does not permit an operator to follow
 the `.`, `->`, or `::` tokens, a `~` followed by a *type-name* or
+*computed-type-specifier* in a member access expression or
+*qualified-id* is unambiguously parsed as a destructor
+name. — *end note*]
 #### Increment and decrement <a id="expr.pre.incr">[[expr.pre.incr]]</a>
+The operand of prefix `++` or `--` shall not be of type cv `bool`. An
+operand with volatile-qualified type is deprecated; see
+[[depr.volatile.type]]. The expression `++x` is otherwise equivalent to
+`x+=1` and the expression `--x` is otherwise equivalent to `x-=1`
+[[expr.assign]].
+[*Note 1*: For postfix increment and decrement, see
 [[expr.post.incr]]. — *end note*]
 #### Await <a id="expr.await">[[expr.await]]</a>
 The `co_await` expression is used to suspend evaluation of a coroutine
 [[dcl.fct.def.coroutine]] while awaiting completion of the computation
+represented by the operand expression. Suspending the evaluation of a
+coroutine transfers control to its caller or resumer.
 ``` bnf
 await-expression:
+    co_await cast-expression
 ```
+An *await-expression* shall appear only as a potentially-evaluated
+expression within the *compound-statement* of a *function-body* or
+*lambda-expression*, in either case outside of a *handler*
+[[except.pre]]. In a *declaration-statement* or in the
 *simple-declaration* (if any) of an *init-statement*, an
 *await-expression* shall appear only in an *initializer* of that
 *declaration-statement* or *simple-declaration*. An *await-expression*
 shall not appear in a default argument [[dcl.fct.default]]. An
 *await-expression* shall not appear in the initializer of a block
+variable with static or thread storage duration. An *await-expression*
+shall not be a potentially-evaluated subexpression of the predicate of a
+contract assertion [[basic.contract]]. A context within a function where
+an *await-expression* can appear is called a *suspension context* of the
+function.
 Evaluation of an *await-expression* involves the following auxiliary
 types, expressions, and objects:
 - *p* is an lvalue naming the promise object [[dcl.fct.def.coroutine]]
 [*Note 1*:
 In particular, the values of `sizeof(bool)`, `sizeof(char16_t)`,
 `sizeof(char32_t)`, and `sizeof(wchar_t)` are
+implementation-defined.[^19]
 — *end note*]
 [*Note 2*: See  [[intro.memory]] for the definition of byte and
 [[term.object.representation]] for the definition of object
 When applied to a reference type, the result is the size of the
 referenced type. When applied to a class, the result is the number of
 bytes in an object of that class including any padding required for
 placing objects of that type in an array. The result of applying
 `sizeof` to a potentially-overlapping subobject is the size of the type,
+not the size of the subobject.[^20]
 When applied to an array, the result is the total number of bytes in the
 array. This implies that the size of an array of n elements is n times
 the size of an element.
 The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are not applied
 to the operand of `sizeof`. If the operand is a prvalue, the temporary
 materialization conversion [[conv.rval]] is applied.
+The *identifier* in a `sizeof...` expression shall name a pack. The
 `sizeof...` operator yields the number of elements in the pack
 [[temp.variadic]]. A `sizeof...` expression is a pack expansion
 [[temp.variadic]].
 [*Example 1*:
 ``` cpp
 template<class... Types>
 struct count {
+  static constexpr std::size_t value = sizeof...(Types);
 };
 ```
 — *end example*]
 The result of `sizeof` and `sizeof...` is a prvalue of type
 `std::size_t`.
 [*Note 3*: A `sizeof` expression is an integral constant expression
+[[expr.const]]. The *typedef-name* `std::size_t` is declared in the
+standard header `<cstddef>`
+[[cstddef.syn]], [[support.types.layout]]. — *end note*]
 #### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 An `alignof` expression yields the alignment requirement of its operand
 type. The operand shall be a *type-id* representing a complete object
 type, or an array thereof, or a reference to one of those types.
 The result is a prvalue of type `std::size_t`.
 [*Note 1*: An `alignof` expression is an integral constant expression
+[[expr.const]]. The *typedef-name* `std::size_t` is declared in the
+standard header `<cstddef>`
+[[cstddef.syn]], [[support.types.layout]]. — *end note*]
 When `alignof` is applied to a reference type, the result is the
 alignment of the referenced type. When `alignof` is applied to an array
 type, the result is the alignment of the element type.
 #### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
 ``` bnf
 noexcept-expression:
   noexcept '(' expression ')'
 ```
+The operand of the `noexcept` operator is an unevaluated operand
+[[term.unevaluated.operand]]. If the operand is a prvalue, the temporary
+materialization conversion [[conv.rval]] is applied.
+The result of the `noexcept` operator is a prvalue of type `bool`. The
+result is `false` if the full-expression of the operand is
+potentially-throwing [[except.spec]], and `true` otherwise.
 [*Note 1*: A *noexcept-expression* is an integral constant expression
 [[expr.const]]. — *end note*]
 #### New <a id="expr.new">[[expr.new]]</a>
+The *new-expression* attempts to create an object of the *type-id* or
+*new-type-id* [[dcl.name]] to which it is applied. The type of that
 object is the *allocated type*. This type shall be a complete object
 type [[term.incomplete.type]], but not an abstract class type
 [[class.abstract]] or array thereof [[intro.object]].
 [*Note 1*: Because references are not objects, references cannot be
 new-initializer:
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
+If a placeholder type [[dcl.spec.auto]] or a placeholder for a deduced
+class type [[dcl.type.class.deduct]] appears in the *type-specifier-seq*
+of a *new-type-id* or *type-id* of a *new-expression*, the allocated
+type is deduced as follows: Let *init* be the *new-initializer*, if any,
+and `T` be the *new-type-id* or *type-id* of the *new-expression*, then
+the allocated type is the type deduced for the variable `x` in the
+invented declaration [[dcl.spec.auto]]:
 ``` cpp
 T x init ;
 ```
 its value shall be greater than zero.
 [*Example 4*: Given the definition `int n = 42`, `new float[n][5]` is
 well-formed (because `n` is the *expression* of a
 *noptr-new-declarator*), but `new float[5][n]` is ill-formed (because
+`n` is not a constant expression). Furthermore, `new float[0]` is
+well-formed (because `0` is the *expression* of a
+*noptr-new-declarator*, where a value of zero results in the allocation
+of an array with no elements), but `new float[n][0]` is ill-formed
+(because `0` is the *constant-expression* of a *noptr-new-declarator*,
+where only values greater than zero are allowed). — *end example*]
 If the *type-id* or *new-type-id* denotes an array type of unknown bound
 [[dcl.array]], the *new-initializer* shall not be omitted; the allocated
 object is an array with `n` elements, where `n` is determined from the
 number of initial elements supplied in the *new-initializer*
 [[dcl.init.aggr]], [[dcl.init.string]].
 If the *expression* in a *noptr-new-declarator* is present, it is
+implicitly converted to `std::size_t`. The value of the *expression* is
+invalid if
 - the expression is of non-class type and its value before converting to
   `std::size_t` is less than zero;
 - the expression is of class type and its value before application of
+  the second standard conversion [[over.ics.user]][^21] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
   the *implementation-defined* limit [[implimits]]; or
 - the *new-initializer* is a *braced-init-list* and the number of array
   elements for which initializers are provided (including the
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
+If the value of the *expression* is invalid after converting to
+`std::size_t`:
 - if the *expression* is a potentially-evaluated core constant
   expression, the program is ill-formed;
 - otherwise, an allocation function is not called; instead
   - if the allocation function that would have been called has a
     `std::bad_array_new_length` [[new.badlength]].
 When the value of the *expression* is zero, the allocation function is
 called to allocate an array with no elements.
+If the allocated type is an array, the *new-initializer* is a
+*braced-init-list*, and the *expression* is potentially-evaluated and
+not a core constant expression, the semantic constraints of
+copy-initializing a hypothetical element of the array from an empty
+initializer list are checked [[dcl.init.list]].
+[*Note 5*: The array can contain more elements than there are elements
+in the *braced-init-list*, requiring initialization of the remainder of
+the array elements from an empty initializer list. — *end note*]
 Objects created by a *new-expression* have dynamic storage duration
 [[basic.stc.dynamic]].
+[*Note 6*:  The lifetime of such an object is not necessarily
 restricted to the scope in which it is created. — *end note*]
 When the allocated type is “array of `N` `T`” (that is, the
 *noptr-new-declarator* syntax is used or the *new-type-id* or *type-id*
 denotes an array type), the *new-expression* yields a prvalue of type
 “pointer to `T`” that points to the initial element (if any) of the
 array. Otherwise, let `T` be the allocated type; the *new-expression* is
 a prvalue of type “pointer to T” that points to the object created.
+[*Note 7*: Both `new int` and `new int[10]` have type `int*` and the
 type of `new int[i][10]` is `int (*)[10]`. — *end note*]
 A *new-expression* may obtain storage for the object by calling an
 allocation function [[basic.stc.dynamic.allocation]]. If the
 *new-expression* terminates by throwing an exception, it may release
 type, the allocation function’s name is `operator new` and the
 deallocation function’s name is `operator delete`. If the allocated type
 is an array type, the allocation function’s name is `operator new[]` and
 the deallocation function’s name is `operator delete[]`.
+[*Note 8*: An implementation is expected to provide default definitions
 for the global allocation functions
 [[basic.stc.dynamic]], [[new.delete.single]], [[new.delete.array]]. A
 C++ program can provide alternative definitions of these functions
 [[replacement.functions]] and/or class-specific versions [[class.free]].
 The set of allocation and deallocation functions that can be called by a
 An implementation is allowed to omit a call to a replaceable global
 allocation function [[new.delete.single]], [[new.delete.array]]. When it
 does so, the storage is instead provided by the implementation or
 provided by extending the allocation of another *new-expression*.
+During an evaluation of a constant expression, a call to a replaceable
+allocation function is always omitted [[expr.const]].
 The implementation may extend the allocation of a *new-expression* `e1`
 to provide storage for a *new-expression* `e2` if the following would be
 true were the allocation not extended:
 value of the *new-expression* shall be null.
 [*Note 11*: When the allocation function returns a value other than
 null, it must be a pointer to a block of storage in which space for the
 object has been reserved. The block of storage is assumed to be
+appropriately aligned [[basic.align]] and of the requested size. The
+address of the created object will not necessarily be the same as that
+of the block if the object is an array. — *end note*]
 A *new-expression* that creates an object of type `T` initializes that
 object as follows:
 - If the *new-initializer* is omitted, the object is default-initialized
 The invocation of the allocation function is sequenced before the
 evaluations of expressions in the *new-initializer*. Initialization of
 the allocated object is sequenced before the value computation of the
 *new-expression*.
+If the *new-expression* creates an array of objects of class type, the
+destructor is potentially invoked [[class.dtor]].
+If any part of the object initialization described above[^22]
 terminates by throwing an exception and a suitable deallocation function
 can be found, the deallocation function is called to free the memory in
 which the object was being constructed, after which the exception
 continues to propagate in the context of the *new-expression*. If no
 otherwise, no deallocation function will be called. If the lookup finds
 a usual deallocation function and that function, considered as a
 placement deallocation function, would have been selected as a match for
 the allocation function, the program is ill-formed. For a non-placement
 allocation function, the normal deallocation function lookup is used to
+find the matching deallocation function [[expr.delete]]. In any case,
+the matching deallocation function (if any) shall be non-deleted and
+accessible from the point where the *new-expression* appears.
 [*Example 7*:
 ``` cpp
 struct S {
 ```
 The first alternative is a *single-object delete expression*, and the
 second is an *array delete expression*. Whenever the `delete` keyword is
 immediately followed by empty square brackets, it shall be interpreted
+as the second alternative.[^23]
+If the operand is of class type, it is contextually implicitly converted
+[[conv]] to a pointer to object type and the converted operand is used
+in place of the original operand for the remainder of this subclause.
+Otherwise, it shall be a prvalue of pointer to object type. The
+*delete-expression* has type `void`.
+In a single-object delete expression, the value of the operand of
+`delete` may be a null pointer value, a pointer value that resulted from
+a previous non-array *new-expression*, or a pointer to a base class
+subobject of an object created by such a *new-expression*. If not, the
+behavior is undefined. In an array delete expression, the value of the
+operand of `delete` may be a null pointer value or a pointer value that
+resulted from a previous array *new-expression* whose allocation
+function was not a non-allocating form [[new.delete.placement]].[^24]
 If not, the behavior is undefined.
 [*Note 1*: This means that the syntax of the *delete-expression* must
 match the type of the object allocated by `new`, not the syntax of the
 object to be deleted and the static type shall have a virtual destructor
 or the behavior is undefined. In an array delete expression, if the
 dynamic type of the object to be deleted is not similar to its static
 type, the behavior is undefined.
 If the object being deleted has incomplete class type at the point of
+deletion, the program is ill-formed.
 If the value of the operand of the *delete-expression* is not a null
 pointer value and the selected deallocation function (see below) is not
+a destroying operator delete, evaluating the *delete-expression* invokes
+the destructor (if any) for the object or the elements of the array
+being deleted. The destructor shall be accessible from the point where
+the *delete-expression* appears. In the case of an array, the elements
+are destroyed in order of decreasing address (that is, in reverse order
+of the completion of their constructor; see  [[class.base.init]]).
 If the value of the operand of the *delete-expression* is not a null
 pointer value, then:
 - If the allocation call for the *new-expression* for the object to be
 [*Note 5*: If only a placement deallocation function is found in a
 class, the program is ill-formed because the lookup set is empty
 [[basic.lookup]]. — *end note*]
+The deallocation function to be called is selected as follows:
 - If any of the deallocation functions is a destroying operator delete,
   all deallocation functions that are not destroying operator deletes
   are eliminated from further consideration.
 - If the type has new-extended alignment, a function with a parameter of
   or a (possibly multidimensional) array thereof, the function with a
   parameter of type `std::size_t` is selected.
 - Otherwise, it is unspecified whether a deallocation function with a
   parameter of type `std::size_t` is selected.
+Unless the deallocation function is selected at the point of definition
+of the dynamic type’s virtual destructor, the selected deallocation
+function shall be accessible from the point where the
+*delete-expression* appears.
 For a single-object delete expression, the deleted object is the object
 A pointed to by the operand if the static type of A does not have a
 virtual destructor, and the most-derived object of A otherwise.
 [*Note 6*: If the deallocation function is not a destroying operator
 function, and either the first argument was not the result of a prior
 call to a replaceable allocation function or the second or third
 argument was not the corresponding argument in said call, the behavior
 is undefined [[new.delete.single]], [[new.delete.array]]. — *end note*]
+#### The reflection operator <a id="expr.reflect">[[expr.reflect]]</a>
+``` bnf
+reflect-expression:
+    '^^' '::'
+    '^^' reflection-name
+    '^^' type-id
+    '^^' id-expression
+```
+``` bnf
+reflection-name:
+    nested-name-specifierₒₚₜ identifier
+    nested-name-specifier template identifier
+```
+The unary `^^` operator, called the *reflection operator*, yields a
+prvalue of type `std::meta::info` [[basic.fundamental]].
+[*Note 1*: This document places no restriction on representing, by
+reflections, constructs not described by this document or using the
+names of such constructs as operands of
+*reflect-expression*s. — *end note*]
+The component names of a *reflection-name* are those of its
+*nested-name-specifier* (if any) and its *identifier*. The terminal name
+of a *reflection-name* of the form *nested-name-specifier* `template`
+*identifier* shall denote a template.
+A *reflect-expression* is parsed as the longest possible sequence of
+tokens that could syntactically form a *reflect-expression*. An
+unparenthesized *reflect-expression* that represents a template shall
+not be followed by `<`.
+[*Example 1*:
+``` cpp
+static_assert(std::meta::is_type(^^int()));     // ^^ applies to the type-id int()
+template<bool> struct X {};
+consteval bool operator<(std::meta::info, X<false>) { return false; }
+consteval void g(std::meta::info r, X<false> xv) {
+  r == ^^int && true;       // error: ^^ applies to the type-id int&&
+  r == ^^int & true;        // error: ^^ applies to the type-id int&
+  r == (^^int) && true;     // OK
+  r == ^^int &&&& true;     // error: int &&&& is not a valid type-id
+  ^^X < xv;                 // error: reflect-expression that represents a template is followed by <
+  (^^X) < xv;               // OK
+  ^^X<true> < xv;           // OK
+}
+```
+— *end example*]
+A *reflect-expression* of the form `^^ ::` represents the global
+namespace.
+If a *reflect-expression* R matches the form `^^ reflection-name`, it is
+interpreted as such; the *identifier* is looked up and the
+representation of R is determined as follows:
+- If lookup finds a declaration that replaced a *using-declarator*
+  during a single search [[basic.lookup.general]], [[namespace.udecl]],
+  R is ill-formed.
+  \[*Example 2*:
+  ``` cpp
+  struct A { struct S {}; };
+  struct B : A { using A::S; };
+  constexpr std::meta::info r1 = ^^B::S;  // error: A::S found through using-declarator
+  struct C : virtual B { struct S {}; };
+  struct D : virtual B, C {};
+  D::S s;                                 // OK, names C::S per [class.member.lookup]
+  constexpr std::meta::info r2 = ^^D::S;  // OK, result C::S not found through using-declarator
+  ```
+  — *end example*]
+- Otherwise, if lookup finds a namespace alias [[namespace.alias]], R
+  represents that namespace alias.
+- Otherwise, if lookup finds a namespace [[basic.namespace]], R
+  represents that namespace.
+- Otherwise, if lookup finds a concept [[temp.concept]], R represents
+  the denoted concept.
+- Otherwise, if lookup finds a template [[temp.names]], the
+  representation of R is determined as follows:
+  - If lookup finds an injected-class-name [[class.pre]], then:
+    - If the *reflection-name* is of the form
+      `nested-name-specifier template identifier`, then R represents the
+      class template named by the injected-class-name.
+    - Otherwise, the injected-class-name shall be unambiguous when
+      considered as a *type-name* and R represents the class template
+      specialization so named.
+  - Otherwise, if lookup finds an overload set, that overload set shall
+    contain only declarations of a unique function template F; R
+    represents F.
+  - Otherwise, if lookup finds a class template, variable template, or
+    alias template, R represents that template. \[*Note 2*: Lookup never
+    finds a partial or explicit specialization. — *end note*]
+- Otherwise, if lookup finds a type alias A, R represents the underlying
+  entity of A if A was introduced by the declaration of a template
+  parameter; otherwise, R represents A.
+- Otherwise, if lookup finds a class or an enumeration, R represents the
+  denoted type.
+- Otherwise, if lookup finds a class member of an anonymous union
+  [[class.union.anon]], R represents that class member.
+- Otherwise, the *reflection-name* shall be an *id-expression* `I` and R
+  is `^^ I` (see below).
+A *reflect-expression* R of the form `^^ type-id` represents an entity
+determined as follows:
+- If the *type-id* designates a placeholder type
+  [[dcl.spec.auto.general]], R is ill-formed.
+- Otherwise, if the *type-id* names a type alias that is a
+  specialization of an alias template [[temp.alias]], R represents that
+  type alias.
+- Otherwise, R represents the type denoted by the *type-id*.
+A *reflect-expression* R of the form `^^ id-expression` represents an
+entity determined as follows:
+- If the *id-expression* denotes
+  - a variable declared by an *init-capture*
+    [[expr.prim.lambda.capture]],
+  - a function-local predefined variable [[dcl.fct.def.general]],
+  - a local parameter introduced by a *requires-expression*
+    [[expr.prim.req]], or
+  - a local entity E [[basic.pre]] for which a lambda scope intervenes
+    between the point at which E was introduced and R,
+  then R is ill-formed.
+- Otherwise, if the *id-expression* denotes an overload set S, overload
+  resolution for the expression `&S` with no target shall select a
+  unique function [[over.over]]; R represents that function.
+- Otherwise, if the *id-expression* denotes a variable, structured
+  binding, enumerator, or non-static data member, R represents that
+  entity.
+- Otherwise, R is ill-formed. \[*Note 3*: This includes
+  *unqualified-id*s that name a constant template parameter and
+  *pack-index-expression*s. — *end note*]
+The *id-expression* of a *reflect-expression* is an unevaluated operand
+[[expr.context]].
+[*Example 3*:
+``` cpp
+template<typename T> void fn() requires (^^T != ^^int);
+template<typename T> void fn() requires (^^T == ^^int);
+template<typename T> void fn() requires (sizeof(T) == sizeof(int));
+constexpr std::meta::info a = ^^fn<char>;       // OK
+constexpr std::meta::info b = ^^fn<int>;        // error: ambiguous
+constexpr std::meta::info c = ^^std::vector;    // OK
+template<typename T>
+struct S {
+  static constexpr std::meta::info r = ^^T;
+  using type = T;
+};
+static_assert(S<int>::r == ^^int);
+static_assert(^^S<int>::type != ^^int);
+typedef struct X {} Y;
+typedef struct Z {} Z;
+constexpr std::meta::info e = ^^Y;              // OK, represents the type alias Y
+constexpr std::meta::info f = ^^Z;              // OK, represents the type alias Z, not the type[basic.lookup.general]
+```
+— *end example*]

Diff to HTML by rtfpessoa