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

Files changed (1) hide show

tmp/tmpq7dej5ho/{from.md → to.md} +213 -165

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

@@ -1,15 +1,19 @@
 ### Unary expressions <a id="expr.unary">[[expr.unary]]</a>
 Expressions with unary operators group right-to-left.
 ``` bnf
 unary-expression:
     postfix-expression
     unary-operator cast-expression
     '++' cast-expression
-    '-{-}' cast-expression
     await-expression
     sizeof unary-expression
     sizeof '(' type-id ')'
     sizeof '...' '(' identifier ')'
     alignof '(' type-id ')'
@@ -17,41 +21,43 @@ unary-expression:
     new-expression
     delete-expression
 ```
 ``` bnf
 unary-operator: one of
     '* & + - ! ~'
 ```
 #### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
-The unary `*` operator performs *indirection*: the expression to which
-it is applied shall be a pointer to an object type, or a pointer to a
-function type and the result is an lvalue referring to the object or
-function to which the expression points. If the type of the expression
-is “pointer to `T`”, the type of the result is “`T`”.
 [*Note 1*:  Indirection through a pointer to an incomplete type (other
 than cv `void`) is valid. The lvalue thus obtained can be used in
 limited ways (to initialize a reference, for example); this lvalue must
 not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
-The result of each of the following unary operators is a prvalue.
-The result of the unary `&` operator is a pointer to its operand.
 - If the operand is a *qualified-id* naming a non-static or variant
-  member `m` of some class `C` with type `T`, the result has type
-  “pointer to member of class `C` of type `T`” and is a prvalue
- designating `C::m`.
-- Otherwise, if the operand is an lvalue of type `T`, the resulting
- expression is a prvalue of type “pointer to `T`” whose result is a
- pointer to the designated object [[intro.memory]] or function.
-  \[*Note 2*: In particular, taking the address of a variable of type
- “cv `T`” yields a pointer of type “pointer to cv `T`”. — *end note*]
-- Otherwise, the program is ill-formed.
 [*Example 1*:
 ``` cpp
 struct A { int i; };
@@ -84,44 +90,53 @@ the *unqualified-id*’s class. — *end note*]
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
-[*Note 5*: The address of an overloaded function [[over]] can be taken
-only in a context that uniquely determines which version of the
-overloaded function is referred to (see  [[over.over]]). Since the
-context might determine whether the operand is a static or non-static
-member function, the context can also affect whether the expression has
-type “pointer to function” or “pointer to member
-function”. — *end note*]
 The operand of the unary `+` operator shall have arithmetic, unscoped
 enumeration, or pointer type and the result is the value of the
 argument. Integral promotion is performed on integral or enumeration
 operands. The type of the result is the type of the promoted operand.
 The operand of the unary `-` operator shall have arithmetic or unscoped
-enumeration type and the result is the negation of its operand. Integral
 promotion is performed on integral or enumeration operands. The negative
 of an unsigned quantity is computed by subtracting its value from 2ⁿ,
 where n is the number of bits in the promoted operand. The type of the
 result is the type of the promoted operand.
 The operand of the logical negation operator `!` is contextually
 converted to `bool` [[conv]]; its value is `true` if the converted
 operand is `false` and `false` otherwise. The type of the result is
 `bool`.
-The operand of `~` shall have integral or unscoped enumeration type; the
-result is the ones’ complement of its operand. Integral promotions are
-performed. The type of the result is the type of the promoted operand.
 There is an ambiguity in the grammar when `~` is followed by a
 *type-name* or *decltype-specifier*. The ambiguity is resolved by
-treating `~` as the unary complement operator rather than as the start
-of an *unqualified-id* naming a destructor.
-[*Note 6*: Because the grammar does not permit an operator to follow
 the `.`, `->`, or `::` tokens, a `~` followed by a *type-name* or
 *decltype-specifier* in a member access expression or *qualified-id* is
 unambiguously parsed as a destructor name. — *end note*]
 #### Increment and decrement <a id="expr.pre.incr">[[expr.pre.incr]]</a>
@@ -135,12 +150,12 @@ operand; it is an lvalue, and it is a bit-field if the operand is a
 bit-field. The expression `++x` is equivalent to `x+=1`.
 [*Note 1*: See the discussions of addition [[expr.add]] and assignment
 operators [[expr.ass]] for information on conversions. — *end note*]
-The operand of prefix `\dcr` is modified [[defns.access]] by subtracting
-`1`. The requirements on the operand of prefix `\dcr` and the properties
 of its result are otherwise the same as those of prefix `++`.
 [*Note 2*: For postfix increment and decrement, see
 [[expr.post.incr]]. — *end note*]
@@ -156,30 +171,30 @@ await-expression:
 ```
 An *await-expression* shall appear only in a potentially-evaluated
 expression within the *compound-statement* of a *function-body* outside
 of a *handler* [[except.pre]]. In a *declaration-statement* or in the
-*simple-declaration* (if any) of a *for-init-statement*, an
 *await-expression* shall appear only in an *initializer* of that
 *declaration-statement* or *simple-declaration*. An *await-expression*
 shall not appear in a default argument [[dcl.fct.default]]. An
-*await-expression* shall not appear in the initializer of a block-scope
 variable with static or thread storage duration. A context within a
 function where an *await-expression* can appear is called a *suspension
 context* of the function.
 Evaluation of an *await-expression* involves the following auxiliary
 types, expressions, and objects:
 - *p* is an lvalue naming the promise object [[dcl.fct.def.coroutine]]
   of the enclosing coroutine and `P` is the type of that object.
-- *a* is the *cast-expression* if the *await-expression* was implicitly
- produced by a *yield-expression* [[expr.yield]], an initial suspend
- point, or a final suspend point [[dcl.fct.def.coroutine]]. Otherwise,
-  the *unqualified-id* `await_transform` is looked up within the scope
- of `P` by class member access lookup [[basic.lookup.classref]], and if
- this lookup finds at least one declaration, then *a* is
   *p*`.await_transform(`*cast-expression*`)`; otherwise, *a* is the
   *cast-expression*.
 - *o* is determined by enumerating the applicable `operator co_await`
   functions for an argument *a* [[over.match.oper]], and choosing the
   best one through overload resolution [[over.match]]. If overload
@@ -207,25 +222,31 @@ and the *await-ready* expression, then:
 - If the result of *await-ready* is `false`, the coroutine is considered
   suspended. Then:
   - If the type of *await-suspend* is `std::coroutine_handle<Z>`,
     *await-suspend*`.resume()` is evaluated. \[*Note 1*: This resumes
     the coroutine referred to by the result of *await-suspend*. Any
-    number of coroutines may be successively resumed in this fashion,
     eventually returning control flow to the current coroutine caller or
     resumer [[dcl.fct.def.coroutine]]. — *end note*]
   - Otherwise, if the type of *await-suspend* is `bool`, *await-suspend*
     is evaluated, and the coroutine is resumed if the result is `false`.
   - Otherwise, *await-suspend* is evaluated.
   If the evaluation of *await-suspend* exits via an exception, the
   exception is caught, the coroutine is resumed, and the exception is
-  immediately re-thrown [[except.throw]]. Otherwise, control flow
- returns to the current coroutine caller or resumer
- [[dcl.fct.def.coroutine]] without exiting any scopes [[stmt.jump]].
 - If the result of *await-ready* is `true`, or when the coroutine is
-  resumed, the *await-resume* expression is evaluated, and its result is
-  the result of the *await-expression*.
 [*Example 1*:
 ``` cpp
 template <typename T>
@@ -252,11 +273,11 @@ auto operator co_await(std::chrono::duration<Rep, Period> d) {
 using namespace std::chrono;
 my_future<int> h();
 my_future<void> g() {
-  std::cout << "just about go to sleep...\n";
   co_await 10ms;
   std::cout << "resumed\n";
   co_await h();
 }
@@ -269,33 +290,40 @@ int a[] = { co_await h() };     // error: await-expression outside of function s
 #### Sizeof <a id="expr.sizeof">[[expr.sizeof]]</a>
 The `sizeof` operator yields the number of bytes occupied by a
 non-potentially-overlapping object of the type of its operand. The
 operand is either an expression, which is an unevaluated operand
-[[expr.prop]], or a parenthesized *type-id*. The `sizeof` operator shall
-not be applied to an expression that has function or incomplete type, to
-the parenthesized name of such types, or to a glvalue that designates a
-bit-field. The result of `sizeof` applied to any of the narrow character
-types is `1`. The result of `sizeof` applied to any other fundamental
-type [[basic.fundamental]] is *implementation-defined*.
-[*Note 1*: In particular, `sizeof(bool)`, `sizeof(char16_t)`,
 `sizeof(char32_t)`, and `sizeof(wchar_t)` are
-implementation-defined.[^21] — *end note*]
 [*Note 2*: See  [[intro.memory]] for the definition of byte and
-[[basic.types]] for the definition of object
 representation. — *end note*]
 When applied to a reference type, the result is the size of the
 referenced type. When applied to a class, the result is the number of
 bytes in an object of that class including any padding required for
 placing objects of that type in an array. The result of applying
 `sizeof` to a potentially-overlapping subobject is the size of the type,
-not the size of the subobject. [^22] When applied to an array, the
-result is the total number of bytes in the array. This implies that the
-size of an array of n elements is n times the size of an element.
 The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are not applied
 to the operand of `sizeof`. If the operand is a prvalue, the temporary
 materialization conversion [[conv.rval]] is applied.
@@ -319,11 +347,11 @@ struct count {
 The result of `sizeof` and `sizeof...` is a prvalue of type
 `std::size_t`.
 [*Note 3*: A `sizeof` expression is an integral constant expression
 [[expr.const]]. The type `std::size_t` is defined in the standard header
-`<cstddef>` ([[cstddef.syn]], [[support.types.layout]]). — *end note*]
 #### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 An `alignof` expression yields the alignment requirement of its operand
 type. The operand shall be a *type-id* representing a complete object
@@ -331,21 +359,21 @@ type, or an array thereof, or a reference to one of those types.
 The result is a prvalue of type `std::size_t`.
 [*Note 1*: An `alignof` expression is an integral constant expression
 [[expr.const]]. The type `std::size_t` is defined in the standard header
-`<cstddef>` ([[cstddef.syn]], [[support.types.layout]]). — *end note*]
 When `alignof` is applied to a reference type, the result is the
 alignment of the referenced type. When `alignof` is applied to an array
 type, the result is the alignment of the element type.
 #### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
 The `noexcept` operator determines whether the evaluation of its
-operand, which is an unevaluated operand [[expr.prop]], can throw an
-exception [[except.throw]].
 ``` bnf
 noexcept-expression:
   noexcept '(' expression ')'
 ```
@@ -361,17 +389,17 @@ is potentially-throwing [[except.spec]].
 #### New <a id="expr.new">[[expr.new]]</a>
 The *new-expression* attempts to create an object of the *type-id*
 [[dcl.name]] or *new-type-id* to which it is applied. The type of that
 object is the *allocated type*. This type shall be a complete object
-type, but not an abstract class type or array thereof (
-[[intro.object]], [[basic.types]], [[class.abstract]]).
 [*Note 1*: Because references are not objects, references cannot be
 created by *new-expression*s. — *end note*]
-[*Note 2*: The *type-id* may be a cv-qualified type, in which case the
 object created by the *new-expression* has a cv-qualified
 type. — *end note*]
 ``` bnf
 new-expression:
@@ -477,27 +505,10 @@ returning `int`).
 — *end example*]
 — *end note*]
-Objects created by a *new-expression* have dynamic storage duration
-[[basic.stc.dynamic]].
-[*Note 5*:  The lifetime of such an object is not necessarily
-restricted to the scope in which it is created. — *end note*]
-When the allocated object is not an array, the result of the
-*new-expression* is a pointer to the object created.
-When the allocated object is an array (that is, the
-*noptr-new-declarator* syntax is used or the *new-type-id* or *type-id*
-denotes an array type), the *new-expression* yields a pointer to the
-initial element (if any) of the array.
-[*Note 6*: Both `new int` and `new int[10]` have type `int*` and the
-type of `new int[i][10]` is `int (*)[10]` — *end note*]
 The *attribute-specifier-seq* in a *noptr-new-declarator* appertains to
 the associated array type.
 Every *constant-expression* in a *noptr-new-declarator* shall be a
 converted constant expression [[expr.const]] of type `std::size_t` and
@@ -509,12 +520,12 @@ well-formed (because `n` is the *expression* of a
 `n` is not a constant expression). — *end example*]
 If the *type-id* or *new-type-id* denotes an array type of unknown bound
 [[dcl.array]], the *new-initializer* shall not be omitted; the allocated
 object is an array with `n` elements, where `n` is determined from the
-number of initial elements supplied in the *new-initializer* (
-[[dcl.init.aggr]], [[dcl.init.string]]).
 If the *expression* in a *noptr-new-declarator* is present, it is
 implicitly converted to `std::size_t`. The *expression* is erroneous if:
 - the expression is of non-class type and its value before converting to
@@ -529,12 +540,12 @@ implicitly converted to `std::size_t`. The *expression* is erroneous if:
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
 If the *expression* is erroneous after converting to `std::size_t`:
-- if the *expression* is a core constant expression, the program is
-  ill-formed;
 - otherwise, an allocation function is not called; instead
   - if the allocation function that would have been called has a
     non-throwing exception specification [[except.spec]], the value of
     the *new-expression* is the null pointer value of the required
     result type;
@@ -543,10 +554,26 @@ If the *expression* is erroneous after converting to `std::size_t`:
     `std::bad_array_new_length` [[new.badlength]].
 When the value of the *expression* is zero, the allocation function is
 called to allocate an array with no elements.
 A *new-expression* may obtain storage for the object by calling an
 allocation function [[basic.stc.dynamic.allocation]]. If the
 *new-expression* terminates by throwing an exception, it may release
 storage by calling a deallocation function
 [[basic.stc.dynamic.deallocation]]. If the allocated type is a non-array
@@ -554,28 +581,28 @@ type, the allocation function’s name is `operator new` and the
 deallocation function’s name is `operator delete`. If the allocated type
 is an array type, the allocation function’s name is `operator new[]` and
 the deallocation function’s name is `operator delete[]`.
 [*Note 7*: An implementation is required to provide default definitions
-for the global allocation functions ([[basic.stc.dynamic]],
-[[new.delete.single]], [[new.delete.array]]). A C++ program can provide
-alternative definitions of these functions [[replacement.functions]]
-and/or class-specific versions [[class.free]]. The set of allocation and
-deallocation functions that may be called by a *new-expression* may
-include functions that do not perform allocation or deallocation; for
-example, see [[new.delete.placement]]. — *end note*]
-If the *new-expression* begins with a unary `::` operator, the
-allocation function’s name is looked up in the global scope. Otherwise,
-if the allocated type is a class type `T` or array thereof, the
-allocation function’s name is looked up in the scope of `T`. If this
-lookup fails to find the name, or if the allocated type is not a class
-type, the allocation function’s name is looked up in the global scope.
 An implementation is allowed to omit a call to a replaceable global
-allocation function ([[new.delete.single]], [[new.delete.array]]). When
-it does so, the storage is instead provided by the implementation or
 provided by extending the allocation of another *new-expression*.
 During an evaluation of a constant expression, a call to an allocation
 function is always omitted.
@@ -706,12 +733,12 @@ from one invocation of `new` to another.
 — *end example*]
 [*Note 10*: Unless an allocation function has a non-throwing exception
 specification [[except.spec]], it indicates failure to allocate storage
-by throwing a `std::bad_alloc` exception (
-[[basic.stc.dynamic.allocation]], [[except]], [[bad.alloc]]); it returns
 a non-null pointer otherwise. If the allocation function has a
 non-throwing exception specification, it returns null to indicate
 failure to allocate storage and a non-null pointer
 otherwise. — *end note*]
@@ -742,34 +769,33 @@ evaluations of expressions in the *new-initializer*. Initialization of
 the allocated object is sequenced before the value computation of the
 *new-expression*.
 If the *new-expression* creates an object or an array of objects of
 class type, access and ambiguity control are done for the allocation
-function, the deallocation function [[class.free]], and the constructor
-[[class.ctor]] selected for the initialization (if any). If the
-*new-expression* creates an array of objects of class type, the
-destructor is potentially invoked [[class.dtor]].
-If any part of the object initialization described above[^24] terminates
-by throwing an exception and a suitable deallocation function can be
-found, the deallocation function is called to free the memory in which
-the object was being constructed, after which the exception continues to
-propagate in the context of the *new-expression*. If no unambiguous
-matching deallocation function can be found, propagating the exception
-does not cause the object’s memory to be freed.
 [*Note 13*: This is appropriate when the called allocation function
 does not allocate memory; otherwise, it is likely to result in a memory
 leak. — *end note*]
-If the *new-expression* begins with a unary `::` operator, the
-deallocation function’s name is looked up in the global scope.
-Otherwise, if the allocated type is a class type `T` or an array
-thereof, the deallocation function’s name is looked up in the scope of
-`T`. If this lookup fails to find the name, or if the allocated type is
-not a class type or array thereof, the deallocation function’s name is
-looked up in the global scope.
 A declaration of a placement deallocation function matches the
 declaration of a placement allocation function if it has the same number
 of parameters and, after parameter transformations [[dcl.fct]], all
 parameter types except the first are identical. If the lookup finds a
@@ -820,26 +846,32 @@ delete-expression:
 ```
 The first alternative is a *single-object delete expression*, and the
 second is an *array delete expression*. Whenever the `delete` keyword is
 immediately followed by empty square brackets, it shall be interpreted
-as the second alternative.[^25] The operand shall be of pointer to
-object type or of class type. If of class type, the operand is
-contextually implicitly converted [[conv]] to a pointer to object
-type.[^26] The *delete-expression*’s result has type `void`.
 If the operand has a class type, the operand is converted to a pointer
 type by calling the above-mentioned conversion function, and the
 converted operand is used in place of the original operand for the
 remainder of this subclause. In a single-object delete expression, the
 value of the operand of `delete` may be a null pointer value, a pointer
-to a non-array object created by a previous *new-expression*, or a
-pointer to a subobject [[intro.object]] representing a base class of
-such an object [[class.derived]]. If not, the behavior is undefined. In
-an array delete expression, the value of the operand of `delete` may be
-a null pointer value or a pointer value that resulted from a previous
-array *new-expression*.[^27] If not, the behavior is undefined.
 [*Note 1*: This means that the syntax of the *delete-expression* must
 match the type of the object allocated by `new`, not the syntax of the
 *new-expression*. — *end note*]
@@ -847,17 +879,17 @@ match the type of the object allocated by `new`, not the syntax of the
 *delete-expression*; it is not necessary to cast away the constness
 [[expr.const.cast]] of the pointer expression before it is used as the
 operand of the *delete-expression*. — *end note*]
 In a single-object delete expression, if the static type of the object
-to be deleted is different from its dynamic type and the selected
-deallocation function (see below) is not a destroying operator delete,
-the static type shall be a base class of the dynamic type of the object
-to be deleted and the static type shall have a virtual destructor or the
-behavior is undefined. In an array delete expression, if the dynamic
-type of the object to be deleted differs from its static type, the
-behavior is undefined.
 The *cast-expression* in a *delete-expression* shall be evaluated
 exactly once.
 If the object being deleted has incomplete class type at the point of
@@ -898,61 +930,78 @@ exception. — *end note*]
 If the value of the operand of the *delete-expression* is a null pointer
 value, it is unspecified whether a deallocation function will be called
 as described above.
-[*Note 4*: An implementation provides default definitions of the global
-deallocation functions `operator delete` for non-arrays
-[[new.delete.single]] and `operator delete[]` for arrays
-[[new.delete.array]]. A C++ program can provide alternative definitions
-of these functions [[replacement.functions]], and/or class-specific
-versions [[class.free]]. — *end note*]
-When the keyword `delete` in a *delete-expression* is preceded by the
-unary `::` operator, the deallocation function’s name is looked up in
-global scope. Otherwise, the lookup considers class-specific
-deallocation functions [[class.free]]. If no class-specific deallocation
-function is found, the deallocation function’s name is looked up in
-global scope.
-If deallocation function lookup finds more than one usual deallocation
-function, the function to be called is selected as follows:
 - If any of the deallocation functions is a destroying operator delete,
   all deallocation functions that are not destroying operator deletes
   are eliminated from further consideration.
 - If the type has new-extended alignment, a function with a parameter of
   type `std::align_val_t` is preferred; otherwise a function without
   such a parameter is preferred. If any preferred functions are found,
   all non-preferred functions are eliminated from further consideration.
 - If exactly one function remains, that function is selected and the
   selection process terminates.
-- If the deallocation functions have class scope, the one without a
-  parameter of type `std::size_t` is selected.
 - If the type is complete and if, for an array delete expression only,
   the operand is a pointer to a class type with a non-trivial destructor
-  or a (possibly multi-dimensional) array thereof, the function with a
   parameter of type `std::size_t` is selected.
 - Otherwise, it is unspecified whether a deallocation function with a
   parameter of type `std::size_t` is selected.
 For a single-object delete expression, the deleted object is the object
-denoted by the operand if its static type does not have a virtual
-destructor, and its most-derived object otherwise.
-[*Note 5*: If the deallocation function is not a destroying operator
 delete and the deleted object is not the most derived object in the
 former case, the behavior is undefined, as stated above. — *end note*]
 For an array delete expression, the deleted object is the array object.
 When a *delete-expression* is executed, the selected deallocation
 function shall be called with the address of the deleted object in a
 single-object delete expression, or the address of the deleted object
 suitably adjusted for the array allocation overhead [[expr.new]] in an
 array delete expression, as its first argument.
-[*Note 6*: Any cv-qualifiers in the type of the deleted object are
 ignored when forming this argument. — *end note*]
 If a destroying operator delete is used, an unspecified value is passed
 as the argument corresponding to the parameter of type
 `std::destroying_delete_t`. If a deallocation function with a parameter
@@ -961,15 +1010,14 @@ deleted object is passed as the corresponding argument. If a
 deallocation function with a parameter of type `std::size_t` is used,
 the size of the deleted object in a single-object delete expression, or
 of the array plus allocation overhead in an array delete expression, is
 passed as the corresponding argument.
-[*Note 7*: If this results in a call to a replaceable deallocation
 function, and either the first argument was not the result of a prior
 call to a replaceable allocation function or the second or third
 argument was not the corresponding argument in said call, the behavior
-is undefined ([[new.delete.single]],
-[[new.delete.array]]). — *end note*]
 Access and ambiguity control are done for both the deallocation function
-and the destructor ([[class.dtor]], [[class.free]]).

 ### Unary expressions <a id="expr.unary">[[expr.unary]]</a>
+#### General <a id="expr.unary.general">[[expr.unary.general]]</a>
 Expressions with unary operators group right-to-left.
 ``` bnf
+%% Ed. note: character protrusion would misalign operators.
 unary-expression:
     postfix-expression
     unary-operator cast-expression
     '++' cast-expression
+    '--' cast-expression
     await-expression
     sizeof unary-expression
     sizeof '(' type-id ')'
     sizeof '...' '(' identifier ')'
     alignof '(' type-id ')'
     new-expression
     delete-expression
 ```
 ``` bnf
+%% Ed. note: character protrusion would misalign operators.
 unary-operator: one of
     '* & + - ! ~'
 ```
 #### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
+The unary `*` operator performs *indirection*. Its operand shall be a
+prvalue of type “pointer to `T`”, where `T` is an object or function
+type. The operator yields an lvalue of type `T` denoting the object or
+function to which the operand points.
 [*Note 1*:  Indirection through a pointer to an incomplete type (other
 than cv `void`) is valid. The lvalue thus obtained can be used in
 limited ways (to initialize a reference, for example); this lvalue must
 not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
+Each of the following unary operators yields a prvalue.
+The operand of the unary `&` operator shall be an lvalue of some type
+`T`. The result is a prvalue.
 - If the operand is a *qualified-id* naming a non-static or variant
+  member `m` of some class `C`, other than an explicit object member
+ function, the result has type “pointer to member of class `C` of type
+ `T`” and designates `C::m`.
+- Otherwise, the result has type “pointer to `T`” and points to the
+ designated object [[intro.memory]] or function [[basic.compound]]. If
+ the operand names an explicit object member function [[dcl.fct]], the
+ operand shall be a *qualified-id*. \[*Note 2*: In particular, taking
+ the address of a variable of type “cv `T`” yields a pointer of type
+  “pointer to cv `T`”. — *end note*]
 [*Example 1*:
 ``` cpp
 struct A { int i; };
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
+[*Note 5*: The address of an overload set [[over]] can be taken only in
+a context that uniquely determines which function is referred to (see
+[[over.over]]). Since the context can affect whether the operand is a
+static or non-static member function, the context can also affect
+whether the expression has type “pointer to function” or “pointer to
+member function”. — *end note*]
 The operand of the unary `+` operator shall have arithmetic, unscoped
 enumeration, or pointer type and the result is the value of the
 argument. Integral promotion is performed on integral or enumeration
 operands. The type of the result is the type of the promoted operand.
 The operand of the unary `-` operator shall have arithmetic or unscoped
+enumeration type and the result is the negative of its operand. Integral
 promotion is performed on integral or enumeration operands. The negative
 of an unsigned quantity is computed by subtracting its value from 2ⁿ,
 where n is the number of bits in the promoted operand. The type of the
 result is the type of the promoted operand.
+[*Note 6*: The result is the two’s complement of the operand (where
+operand and result are considered as unsigned). — *end note*]
 The operand of the logical negation operator `!` is contextually
 converted to `bool` [[conv]]; its value is `true` if the converted
 operand is `false` and `false` otherwise. The type of the result is
 `bool`.
+The operand of the `~` operator shall have integral or unscoped
+enumeration type. Integral promotions are performed. The type of the
+result is the type of the promoted operand. Given the coefficients `xᵢ`
+of the base-2 representation [[basic.fundamental]] of the promoted
+operand `x`, the coefficient `rᵢ` of the base-2 representation of the
+result `r` is 1 if `xᵢ` is 0, and 0 otherwise.
+[*Note 7*: The result is the ones’ complement of the operand (where
+operand and result are considered as unsigned). — *end note*]
 There is an ambiguity in the grammar when `~` is followed by a
 *type-name* or *decltype-specifier*. The ambiguity is resolved by
+treating `~` as the operator rather than as the start of an
+*unqualified-id* naming a destructor.
+[*Note 8*: Because the grammar does not permit an operator to follow
 the `.`, `->`, or `::` tokens, a `~` followed by a *type-name* or
 *decltype-specifier* in a member access expression or *qualified-id* is
 unambiguously parsed as a destructor name. — *end note*]
 #### Increment and decrement <a id="expr.pre.incr">[[expr.pre.incr]]</a>
 bit-field. The expression `++x` is equivalent to `x+=1`.
 [*Note 1*: See the discussions of addition [[expr.add]] and assignment
 operators [[expr.ass]] for information on conversions. — *end note*]
+The operand of prefix `--` is modified [[defns.access]] by subtracting
+`1`. The requirements on the operand of prefix `--` and the properties
 of its result are otherwise the same as those of prefix `++`.
 [*Note 2*: For postfix increment and decrement, see
 [[expr.post.incr]]. — *end note*]
 ```
 An *await-expression* shall appear only in a potentially-evaluated
 expression within the *compound-statement* of a *function-body* outside
 of a *handler* [[except.pre]]. In a *declaration-statement* or in the
+*simple-declaration* (if any) of an *init-statement*, an
 *await-expression* shall appear only in an *initializer* of that
 *declaration-statement* or *simple-declaration*. An *await-expression*
 shall not appear in a default argument [[dcl.fct.default]]. An
+*await-expression* shall not appear in the initializer of a block
 variable with static or thread storage duration. A context within a
 function where an *await-expression* can appear is called a *suspension
 context* of the function.
 Evaluation of an *await-expression* involves the following auxiliary
 types, expressions, and objects:
 - *p* is an lvalue naming the promise object [[dcl.fct.def.coroutine]]
   of the enclosing coroutine and `P` is the type of that object.
+- Unless the *await-expression* was implicitly produced by a
+  *yield-expression* [[expr.yield]], an initial await expression, or a
+  final await expression [[dcl.fct.def.coroutine]], a search is
+ performed for the name `await_transform` in the scope of `P`
+  [[class.member.lookup]]. If this search is performed and finds at
+  least one declaration, then *a* is
   *p*`.await_transform(`*cast-expression*`)`; otherwise, *a* is the
   *cast-expression*.
 - *o* is determined by enumerating the applicable `operator co_await`
   functions for an argument *a* [[over.match.oper]], and choosing the
   best one through overload resolution [[over.match]]. If overload
 - If the result of *await-ready* is `false`, the coroutine is considered
   suspended. Then:
   - If the type of *await-suspend* is `std::coroutine_handle<Z>`,
     *await-suspend*`.resume()` is evaluated. \[*Note 1*: This resumes
     the coroutine referred to by the result of *await-suspend*. Any
+    number of coroutines can be successively resumed in this fashion,
     eventually returning control flow to the current coroutine caller or
     resumer [[dcl.fct.def.coroutine]]. — *end note*]
   - Otherwise, if the type of *await-suspend* is `bool`, *await-suspend*
     is evaluated, and the coroutine is resumed if the result is `false`.
   - Otherwise, *await-suspend* is evaluated.
   If the evaluation of *await-suspend* exits via an exception, the
   exception is caught, the coroutine is resumed, and the exception is
+  immediately rethrown [[except.throw]]. Otherwise, control flow returns
+  to the current coroutine caller or resumer [[dcl.fct.def.coroutine]]
+  without exiting any scopes [[stmt.jump]]. The point in the coroutine
+  immediately prior to control returning to its caller or resumer is a
+  coroutine *suspend point*.
 - If the result of *await-ready* is `true`, or when the coroutine is
+  resumed other than by rethrowing an exception from *await-suspend*,
+  the *await-resume* expression is evaluated, and its result is the
+  result of the *await-expression*.
+[*Note 2*: With respect to sequencing, an *await-expression* is
+indivisible [[intro.execution]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template <typename T>
 using namespace std::chrono;
 my_future<int> h();
 my_future<void> g() {
+  std::cout << "just about to go to sleep...\n";
   co_await 10ms;
   std::cout << "resumed\n";
   co_await h();
 }
 #### Sizeof <a id="expr.sizeof">[[expr.sizeof]]</a>
 The `sizeof` operator yields the number of bytes occupied by a
 non-potentially-overlapping object of the type of its operand. The
 operand is either an expression, which is an unevaluated operand
+[[term.unevaluated.operand]], or a parenthesized *type-id*. The `sizeof`
+operator shall not be applied to an expression that has function or
+incomplete type, to the parenthesized name of such types, or to a
+glvalue that designates a bit-field. The result of `sizeof` applied to
+any of the narrow character types is `1`. The result of `sizeof` applied
+to any other fundamental type [[basic.fundamental]] is
+*implementation-defined*.
+[*Note 1*:
+In particular, the values of `sizeof(bool)`, `sizeof(char16_t)`,
 `sizeof(char32_t)`, and `sizeof(wchar_t)` are
+implementation-defined.[^21]
+— *end note*]
 [*Note 2*: See  [[intro.memory]] for the definition of byte and
+[[term.object.representation]] for the definition of object
 representation. — *end note*]
 When applied to a reference type, the result is the size of the
 referenced type. When applied to a class, the result is the number of
 bytes in an object of that class including any padding required for
 placing objects of that type in an array. The result of applying
 `sizeof` to a potentially-overlapping subobject is the size of the type,
+not the size of the subobject.[^22]
+When applied to an array, the result is the total number of bytes in the
+array. This implies that the size of an array of n elements is n times
+the size of an element.
 The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are not applied
 to the operand of `sizeof`. If the operand is a prvalue, the temporary
 materialization conversion [[conv.rval]] is applied.
 The result of `sizeof` and `sizeof...` is a prvalue of type
 `std::size_t`.
 [*Note 3*: A `sizeof` expression is an integral constant expression
 [[expr.const]]. The type `std::size_t` is defined in the standard header
+`<cstddef>` [[cstddef.syn]], [[support.types.layout]]. — *end note*]
 #### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 An `alignof` expression yields the alignment requirement of its operand
 type. The operand shall be a *type-id* representing a complete object
 The result is a prvalue of type `std::size_t`.
 [*Note 1*: An `alignof` expression is an integral constant expression
 [[expr.const]]. The type `std::size_t` is defined in the standard header
+`<cstddef>` [[cstddef.syn]], [[support.types.layout]]. — *end note*]
 When `alignof` is applied to a reference type, the result is the
 alignment of the referenced type. When `alignof` is applied to an array
 type, the result is the alignment of the element type.
 #### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
 The `noexcept` operator determines whether the evaluation of its
+operand, which is an unevaluated operand [[term.unevaluated.operand]],
+can throw an exception [[except.throw]].
 ``` bnf
 noexcept-expression:
   noexcept '(' expression ')'
 ```
 #### New <a id="expr.new">[[expr.new]]</a>
 The *new-expression* attempts to create an object of the *type-id*
 [[dcl.name]] or *new-type-id* to which it is applied. The type of that
 object is the *allocated type*. This type shall be a complete object
+type [[term.incomplete.type]], but not an abstract class type
+[[class.abstract]] or array thereof [[intro.object]].
 [*Note 1*: Because references are not objects, references cannot be
 created by *new-expression*s. — *end note*]
+[*Note 2*: The *type-id* can be a cv-qualified type, in which case the
 object created by the *new-expression* has a cv-qualified
 type. — *end note*]
 ``` bnf
 new-expression:
 — *end example*]
 — *end note*]
 The *attribute-specifier-seq* in a *noptr-new-declarator* appertains to
 the associated array type.
 Every *constant-expression* in a *noptr-new-declarator* shall be a
 converted constant expression [[expr.const]] of type `std::size_t` and
 `n` is not a constant expression). — *end example*]
 If the *type-id* or *new-type-id* denotes an array type of unknown bound
 [[dcl.array]], the *new-initializer* shall not be omitted; the allocated
 object is an array with `n` elements, where `n` is determined from the
+number of initial elements supplied in the *new-initializer*
+[[dcl.init.aggr]], [[dcl.init.string]].
 If the *expression* in a *noptr-new-declarator* is present, it is
 implicitly converted to `std::size_t`. The *expression* is erroneous if:
 - the expression is of non-class type and its value before converting to
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
 If the *expression* is erroneous after converting to `std::size_t`:
+- if the *expression* is a potentially-evaluated core constant
+ expression, the program is ill-formed;
 - otherwise, an allocation function is not called; instead
   - if the allocation function that would have been called has a
     non-throwing exception specification [[except.spec]], the value of
     the *new-expression* is the null pointer value of the required
     result type;
     `std::bad_array_new_length` [[new.badlength]].
 When the value of the *expression* is zero, the allocation function is
 called to allocate an array with no elements.
+Objects created by a *new-expression* have dynamic storage duration
+[[basic.stc.dynamic]].
+[*Note 5*:  The lifetime of such an object is not necessarily
+restricted to the scope in which it is created. — *end note*]
+When the allocated type is “array of `N` `T`” (that is, the
+*noptr-new-declarator* syntax is used or the *new-type-id* or *type-id*
+denotes an array type), the *new-expression* yields a prvalue of type
+“pointer to `T`” that points to the initial element (if any) of the
+array. Otherwise, let `T` be the allocated type; the *new-expression* is
+a prvalue of type “pointer to T” that points to the object created.
+[*Note 6*: Both `new int` and `new int[10]` have type `int*` and the
+type of `new int[i][10]` is `int (*)[10]`. — *end note*]
 A *new-expression* may obtain storage for the object by calling an
 allocation function [[basic.stc.dynamic.allocation]]. If the
 *new-expression* terminates by throwing an exception, it may release
 storage by calling a deallocation function
 [[basic.stc.dynamic.deallocation]]. If the allocated type is a non-array
 deallocation function’s name is `operator delete`. If the allocated type
 is an array type, the allocation function’s name is `operator new[]` and
 the deallocation function’s name is `operator delete[]`.
 [*Note 7*: An implementation is required to provide default definitions
+for the global allocation functions
+[[basic.stc.dynamic]], [[new.delete.single]], [[new.delete.array]]. A
+C++ program can provide alternative definitions of these functions
+[[replacement.functions]] and/or class-specific versions [[class.free]].
+The set of allocation and deallocation functions that can be called by a
+*new-expression* can include functions that do not perform allocation or
+deallocation; for example, see [[new.delete.placement]]. — *end note*]
+If the *new-expression* does not begin with a unary `::` operator and
+the allocated type is a class type `T` or array thereof, a search is
+performed for the allocation function’s name in the scope of `T`
+[[class.member.lookup]]. Otherwise, or if nothing is found, the
+allocation function’s name is looked up by searching for it in the
+global scope.
 An implementation is allowed to omit a call to a replaceable global
+allocation function [[new.delete.single]], [[new.delete.array]]. When it
+does so, the storage is instead provided by the implementation or
 provided by extending the allocation of another *new-expression*.
 During an evaluation of a constant expression, a call to an allocation
 function is always omitted.
 — *end example*]
 [*Note 10*: Unless an allocation function has a non-throwing exception
 specification [[except.spec]], it indicates failure to allocate storage
+by throwing a `std::bad_alloc` exception
+[[basic.stc.dynamic.allocation]], [[except]], [[bad.alloc]]; it returns
 a non-null pointer otherwise. If the allocation function has a
 non-throwing exception specification, it returns null to indicate
 failure to allocate storage and a non-null pointer
 otherwise. — *end note*]
 the allocated object is sequenced before the value computation of the
 *new-expression*.
 If the *new-expression* creates an object or an array of objects of
 class type, access and ambiguity control are done for the allocation
+function, the deallocation function [[basic.stc.dynamic.deallocation]],
+and the constructor [[class.ctor]] selected for the initialization (if
+any). If the *new-expression* creates an array of objects of class type,
+the destructor is potentially invoked [[class.dtor]].
+If any part of the object initialization described above[^24]
+terminates by throwing an exception and a suitable deallocation function
+can be found, the deallocation function is called to free the memory in
+which the object was being constructed, after which the exception
+continues to propagate in the context of the *new-expression*. If no
+unambiguous matching deallocation function can be found, propagating the
+exception does not cause the object’s memory to be freed.
 [*Note 13*: This is appropriate when the called allocation function
 does not allocate memory; otherwise, it is likely to result in a memory
 leak. — *end note*]
+If the *new-expression* does not begin with a unary `::` operator and
+the allocated type is a class type `T` or an array thereof, a search is
+performed for the deallocation function’s name in the scope of `T`.
+Otherwise, or if nothing is found, the deallocation function’s name is
+looked up by searching for it in the global scope.
 A declaration of a placement deallocation function matches the
 declaration of a placement allocation function if it has the same number
 of parameters and, after parameter transformations [[dcl.fct]], all
 parameter types except the first are identical. If the lookup finds a
 ```
 The first alternative is a *single-object delete expression*, and the
 second is an *array delete expression*. Whenever the `delete` keyword is
 immediately followed by empty square brackets, it shall be interpreted
+as the second alternative.[^25]
+The operand shall be of pointer to object type or of class type. If of
+class type, the operand is contextually implicitly converted [[conv]] to
+a pointer to object type.[^26]
+The *delete-expression* has type `void`.
 If the operand has a class type, the operand is converted to a pointer
 type by calling the above-mentioned conversion function, and the
 converted operand is used in place of the original operand for the
 remainder of this subclause. In a single-object delete expression, the
 value of the operand of `delete` may be a null pointer value, a pointer
+value that resulted from a previous non-array *new-expression*, or a
+pointer to a base class subobject of an object created by such a
+*new-expression*. If not, the behavior is undefined. In an array delete
+expression, the value of the operand of `delete` may be a null pointer
+value or a pointer value that resulted from a previous array
+*new-expression* whose allocation function was not a non-allocating form
+[[new.delete.placement]].[^27]
+If not, the behavior is undefined.
 [*Note 1*: This means that the syntax of the *delete-expression* must
 match the type of the object allocated by `new`, not the syntax of the
 *new-expression*. — *end note*]
 *delete-expression*; it is not necessary to cast away the constness
 [[expr.const.cast]] of the pointer expression before it is used as the
 operand of the *delete-expression*. — *end note*]
 In a single-object delete expression, if the static type of the object
+to be deleted is not similar [[conv.qual]] to its dynamic type and the
+selected deallocation function (see below) is not a destroying operator
+delete, the static type shall be a base class of the dynamic type of the
+object to be deleted and the static type shall have a virtual destructor
+or the behavior is undefined. In an array delete expression, if the
+dynamic type of the object to be deleted is not similar to its static
+type, the behavior is undefined.
 The *cast-expression* in a *delete-expression* shall be evaluated
 exactly once.
 If the object being deleted has incomplete class type at the point of
 If the value of the operand of the *delete-expression* is a null pointer
 value, it is unspecified whether a deallocation function will be called
 as described above.
+If a deallocation function is called, it is `operator delete` for a
+single-object delete expression or `operator delete[]` for an array
+delete expression.
+[*Note 4*:  An implementation provides default definitions of the
+global deallocation functions
+[[new.delete.single]], [[new.delete.array]]. A C++ program can provide
+alternative definitions of these functions [[replacement.functions]],
+and/or class-specific versions [[class.free]]. — *end note*]
+If the keyword `delete` in a *delete-expression* is not preceded by the
+unary `::` operator and the type of the operand is a pointer to a
+(possibly cv-qualified) class type `T` or (possibly multidimensional)
+array thereof:
+- For a single-object delete expression, if the operand is a pointer to
+  cv `T` and `T` has a virtual destructor, the deallocation function is
+  the one selected at the point of definition of the dynamic type’s
+  virtual destructor [[class.dtor]].
+- Otherwise, a search is performed for the deallocation function’s name
+  in the scope of `T`.
+Otherwise, or if nothing is found, the deallocation function’s name is
+looked up by searching for it in the global scope. In any case, any
+declarations other than of usual deallocation functions
+[[basic.stc.dynamic.deallocation]] are discarded.
+[*Note 5*: If only a placement deallocation function is found in a
+class, the program is ill-formed because the lookup set is empty
+[[basic.lookup]]. — *end note*]
+If more than one deallocation function is found, the function to be
+called is selected as follows:
 - If any of the deallocation functions is a destroying operator delete,
   all deallocation functions that are not destroying operator deletes
   are eliminated from further consideration.
 - If the type has new-extended alignment, a function with a parameter of
   type `std::align_val_t` is preferred; otherwise a function without
   such a parameter is preferred. If any preferred functions are found,
   all non-preferred functions are eliminated from further consideration.
 - If exactly one function remains, that function is selected and the
   selection process terminates.
+- If the deallocation functions belong to a class scope, the one without
+ a parameter of type `std::size_t` is selected.
 - If the type is complete and if, for an array delete expression only,
   the operand is a pointer to a class type with a non-trivial destructor
+  or a (possibly multidimensional) array thereof, the function with a
   parameter of type `std::size_t` is selected.
 - Otherwise, it is unspecified whether a deallocation function with a
   parameter of type `std::size_t` is selected.
 For a single-object delete expression, the deleted object is the object
+A pointed to by the operand if the static type of A does not have a
+virtual destructor, and the most-derived object of A otherwise.
+[*Note 6*: If the deallocation function is not a destroying operator
 delete and the deleted object is not the most derived object in the
 former case, the behavior is undefined, as stated above. — *end note*]
 For an array delete expression, the deleted object is the array object.
 When a *delete-expression* is executed, the selected deallocation
 function shall be called with the address of the deleted object in a
 single-object delete expression, or the address of the deleted object
 suitably adjusted for the array allocation overhead [[expr.new]] in an
 array delete expression, as its first argument.
+[*Note 7*: Any cv-qualifiers in the type of the deleted object are
 ignored when forming this argument. — *end note*]
 If a destroying operator delete is used, an unspecified value is passed
 as the argument corresponding to the parameter of type
 `std::destroying_delete_t`. If a deallocation function with a parameter
 deallocation function with a parameter of type `std::size_t` is used,
 the size of the deleted object in a single-object delete expression, or
 of the array plus allocation overhead in an array delete expression, is
 passed as the corresponding argument.
+[*Note 8*: If this results in a call to a replaceable deallocation
 function, and either the first argument was not the result of a prior
 call to a replaceable allocation function or the second or third
 argument was not the corresponding argument in said call, the behavior
+is undefined [[new.delete.single]], [[new.delete.array]]. — *end note*]
 Access and ambiguity control are done for both the deallocation function
+and the destructor [[class.dtor]], [[class.free]].

Diff to HTML by rtfpessoa