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

Files changed (1) hide show

tmp/tmps6vx5yfd/{from.md → to.md} +438 -281

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

@@ -1,60 +1,57 @@
-## Unary expressions <a id="expr.unary">[[expr.unary]]</a>
 Expressions with unary operators group right-to-left.
 ``` bnf
 unary-expression:
     postfix-expression
     '++' cast-expression
     '-{-}' cast-expression
- unary-operator cast-expression
- 'sizeof' unary-expression
- 'sizeof (' type-id ')'
- 'sizeof ...' '(' identifier ')'
- 'alignof (' type-id ')'
     noexcept-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. The
-operand shall be an lvalue or a *qualified-id*. 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 type
-of the expression is `T`, the result has type “pointer to `T`” and is a
-prvalue that is the address of the designated object ([[intro.memory]])
-or a pointer to the designated function.
-[*Note 2*: In particular, the address of an object of type “cv `T`” is
-“pointer to cv `T`”, with the same cv-qualification. — *end note*]
-For purposes of pointer arithmetic ([[expr.add]]) and comparison (
-[[expr.rel]], [[expr.eq]]), an object that is not an array element whose
-address is taken in this way is considered to belong to an array with
-one element of type `T`.
 [*Example 1*:
 ``` cpp
 struct A { int i; };
@@ -67,38 +64,37 @@ 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]]). Nor is `&unqualified-id` a pointer to member, even
-within the scope of 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.
-The address of an overloaded function (Clause  [[over]]) can be taken
 only in a context that uniquely determines which version of the
-overloaded function is referred to (see  [[over.over]]).
-[*Note 5*: 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.
@@ -109,90 +105,207 @@ 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` (Clause  [[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
-*class-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 *class-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 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. 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 `\dcr` is modified 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*]
-### Sizeof <a id="expr.sizeof">[[expr.sizeof]]</a>
-The `sizeof` operator yields the number of bytes in the object
-representation of its operand. The operand is either an expression,
-which is an unevaluated operand (Clause  [[expr]]), 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. `sizeof(char)`,
-`sizeof(signed char)` and `sizeof(unsigned char)` are `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.[^16] — *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 or 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 size of a
-most derived class shall be greater than zero ([[intro.object]]). The
-result of applying `sizeof` to a base class subobject is the size of the
-base class type.[^17] 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 `sizeof` operator can be applied to a pointer to a function, but
-shall not be applied directly to a function.
-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 parameter pack.
-The `sizeof...` operator yields the number of arguments provided for the
-parameter pack *identifier*. A `sizeof...` expression is a pack
-expansion ([[temp.variadic]]).
 [*Example 1*:
 ``` cpp
 template<class... Types>
@@ -201,35 +314,71 @@ struct count {
 };
 ```
 — *end example*]
-The result of `sizeof` and `sizeof...` is a constant of type
 `std::size_t`.
-[*Note 3*: `std::size_t` is defined in the standard header
 `<cstddef>` ([[cstddef.syn]], [[support.types.layout]]). — *end note*]
-### 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:
-    '::'ₒₚₜ 'new' new-placementₒₚₜ new-type-id new-initializerₒₚₜ
-    '::'ₒₚₜ 'new' new-placementₒₚₜ '(' type-id ')' new-initializerₒₚₜ
 ```
 ``` bnf
 new-placement:
     '(' expression-list ')'
@@ -246,37 +395,27 @@ new-declarator:
     noptr-new-declarator
 ```
 ``` bnf
 noptr-new-declarator:
-    '[' expression ']' attribute-specifier-seqₒₚₜ
     noptr-new-declarator '[' constant-expression ']' attribute-specifier-seqₒₚₜ
 ```
 ``` bnf
 new-initializer:
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
-Entities created by a *new-expression* have dynamic storage duration (
-[[basic.stc.dynamic]]).
-[*Note 3*:  The lifetime of such an entity is not necessarily
-restricted to the scope in which it is created. — *end note*]
-If the entity is a non-array object, the *new-expression* returns a
-pointer to the object created. If it is an array, the *new-expression*
-returns a pointer to the initial element of the array.
-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 ;
 ```
@@ -293,11 +432,11 @@ auto y = new A{1, 2};           // allocated type is A<int>
 — *end example*]
 The *new-type-id* in a *new-expression* is the longest possible sequence
 of *new-declarator*s.
-[*Note 4*: This prevents ambiguities between the declarator operators
 `&`, `&&`, `*`, and `[]` and their expression
 counterparts. — *end note*]
 [*Example 2*:
@@ -307,11 +446,11 @@ new int * i;                    // syntax error: parsed as (new int*) i, not as
 The `*` is the pointer declarator and not the multiplication operator.
 — *end example*]
-[*Note 5*:
 Parentheses in a *new-type-id* of a *new-expression* can have surprising
 effects.
 [*Example 3*:
@@ -325,11 +464,11 @@ is ill-formed because the binding is
 ``` cpp
 (new int) (*[10])();            // error
 ```
 Instead, the explicitly parenthesized version of the `new` operator can
-be used to create objects of compound types ([[basic.compound]]):
 ``` cpp
 new (int (*[10])());
 ```
@@ -338,10 +477,19 @@ returning `int`).
 — *end example*]
 — *end note*]
 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.
@@ -350,65 +498,71 @@ 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 shall evaluate to a strictly positive value. The *expression* in a
-*noptr-new-declarator* is implicitly converted to `std::size_t`.
 [*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*]
-The *expression* in a *noptr-new-declarator* 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]])[^18] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
-  the *implementation-defined* limit (Annex  [[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 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;
   - otherwise, the *new-expression* terminates by throwing an exception
-    of a type that would match a handler ([[except.handle]]) of 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.
 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 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 shall 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,
@@ -418,13 +572,21 @@ 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*. 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:
 - the evaluation of `e1` is sequenced before the evaluation of `e2`, and
 - `e2` is evaluated whenever `e1` obtains storage, and
 - both `e1` and `e2` invoke the same replaceable global allocation
@@ -439,20 +601,20 @@ true were the allocation not extended:
   `e1`.
 [*Example 5*:
 ``` cpp
- void mergeable(int x) {
   // These allocations are safe for merging:
   std::unique_ptr<char[]> a{new (std::nothrow) char[8]};
   std::unique_ptr<char[]> b{new (std::nothrow) char[8]};
   std::unique_ptr<char[]> c{new (std::nothrow) char[x]};
   g(a.get(), b.get(), c.get());
 }
- void unmergeable(int x) {
   std::unique_ptr<char[]> a{new char[8]};
   try {
     // Merging this allocation would change its catch handler.
     std::unique_ptr<char[]> b{new char[x]};
   } catch (const std::bad_alloc& e) {
@@ -467,18 +629,19 @@ true were the allocation not extended:
 When a *new-expression* calls an allocation function and that allocation
 has not been extended, the *new-expression* passes the amount of space
 requested to the allocation function as the first argument of type
 `std::size_t`. That argument shall be no less than the size of the
 object being created; it may be greater than the size of the object
-being created only if the object is an array. For arrays of `char`,
-`unsigned char`, and `std::byte`, the difference between the result of
-the *new-expression* and the address returned by the allocation function
-shall be an integral multiple of the strictest fundamental alignment
-requirement ([[basic.align]]) of any object type whose size is no
-greater than the size of the array being created.
-[*Note 8*:  Because allocation functions are assumed to return pointers
 to storage that is appropriately aligned for objects of any type with
 fundamental alignment, this constraint on array allocation overhead
 permits the common idiom of allocating character arrays into which
 objects of other types will later be placed. — *end note*]
@@ -497,14 +660,19 @@ Overload resolution is performed on a function call created by
 assembling an argument list. The first argument is the amount of space
 requested, and has type `std::size_t`. If the type of the allocated
 object has new-extended alignment, the next argument is the type’s
 alignment, and has type `std::align_val_t`. If the *new-placement*
 syntax is used, the *initializer-clause*s in its *expression-list* are
-the succeeding arguments. If no matching function is found and the
-allocated object type has new-extended alignment, the alignment argument
-is removed from the argument list, and overload resolution is performed
-again.
 [*Example 6*:
 - `new T` results in one of the following calls:
   ``` cpp
@@ -529,69 +697,69 @@ again.
 Here, each instance of `x` is a non-negative unspecified value
 representing array allocation overhead; the result of the
 *new-expression* will be offset by this amount from the value returned
 by `operator new[]`. This overhead may be applied in all array
-*new-expression*s, including those referencing the library function
-`operator new[](std::size_t, void*)` and other placement allocation
-functions. The amount of overhead may vary from one invocation of `new`
-to another.
 — *end example*]
-[*Note 9*: 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]], Clause  [[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*]
-If the allocation function is a non-allocating form (
-[[new.delete.placement]]) that returns null, the behavior is undefined.
 Otherwise, if the allocation function returns null, initialization shall
 not be done, the deallocation function shall not be called, and the
 value of the *new-expression* shall be null.
-[*Note 10*: 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 ([[dcl.init]]). \[*Note 11*: If no initialization
- is performed, the object has an indeterminate value. — *end note*]
 - Otherwise, the *new-initializer* is interpreted according to the
   initialization rules of  [[dcl.init]] for direct-initialization.
 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 ([[class.free]]), and the
-constructor ([[class.ctor]]). 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[^19] 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 12*: 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.
@@ -601,20 +769,19 @@ thereof, the deallocation function’s name is looked up in the scope of
 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
 single matching deallocation function, that function will be called;
 otherwise, no deallocation function will be called. If the lookup finds
-a usual deallocation function with a parameter of type `std::size_t` (
-[[basic.stc.dynamic.deallocation]]) 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 {
@@ -623,74 +790,72 @@ struct S {
   // Usual (non-placement) deallocation function:
   static void operator delete(void*, std::size_t);
 };
-S* p = new (0) S;   // ill-formed: non-placement deallocation function matches
                     // placement allocation function
 ```
 — *end example*]
 If a *new-expression* calls a deallocation function, it passes the value
 returned from the allocation function call as the first argument of type
 `void*`. If a placement deallocation function is called, it is passed
 the same additional arguments as were passed to the placement allocation
 function, that is, the same arguments as those specified with the
-*new-placement* syntax. If the implementation is allowed to make a copy
-of any argument as part of the call to the allocation function, it is
-allowed to make a copy (of the same original value) as part of the call
-to the deallocation function or to reuse the copy made as part of the
-call to the allocation function. If the copy is elided in one place, it
-need not be elided in the other.
-### Delete <a id="expr.delete">[[expr.delete]]</a>
-The *delete-expression* operator destroys a most derived object (
-[[intro.object]]) or array created by a *new-expression*.
 ``` bnf
 delete-expression:
-    '::'ₒₚₜ 'delete' cast-expression
-    '::'ₒₚₜ 'delete [ ]' cast-expression
 ```
-The first alternative is for non-array objects, and the second is for
-arrays. Whenever the `delete` keyword is immediately followed by empty
-square brackets, it shall be interpreted as the second alternative.[^20]
-The operand shall be of pointer to object type or of class type. If of
-class type, the operand is contextually implicitly converted (Clause
-[[conv]]) to a pointer to object type.[^21] 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 section. In the first alternative (*delete object*),
-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 (Clause  [[class.derived]]). If not, the behavior is
-undefined. In the second alternative (*delete array*), 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*.[^22] 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*]
 [*Note 2*: A pointer to a `const` type can be the operand of a
-*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 the first alternative (*delete object*), if the static type of the
-object to be deleted is different from its dynamic type, 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 the second alternative (*delete array*) 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.
@@ -698,25 +863,26 @@ 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, 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
-  deleted was not omitted and the allocation was not extended (
-  [[expr.new]]), the *delete-expression* shall call a deallocation
-  function ([[basic.stc.dynamic.deallocation]]). The value returned
- from the allocation call of the *new-expression* shall be passed as
- the first argument to the deallocation function.
 - Otherwise, if the allocation was extended or was provided by extending
   the allocation of another *new-expression*, and the
   *delete-expression* for every other pointer value produced by a
   *new-expression* that had storage provided by the extended
   *new-expression* has been evaluated, the *delete-expression* shall
@@ -733,86 +899,77 @@ 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 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 exactly one preferred function is
- found, that function is selected and the selection process terminates.
- If more than one preferred function is found, all non-preferred
- functions are eliminated from further consideration.
 - 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 the second alternative (delete
- array) 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.
 When a *delete-expression* is executed, the selected deallocation
-function shall be called with the address of the most-derived object in
-the *delete object* case, or the address of the object suitably adjusted
-for the array allocation overhead ([[expr.new]]) in the *delete array*
-case, as its first argument. If a deallocation function with a parameter
 of type `std::align_val_t` is used, the alignment of the type of the
-object to be deleted is passed as the corresponding argument. If a
 deallocation function with a parameter of type `std::size_t` is used,
-the size of the most-derived type, or of the array plus allocation
-overhead, respectively, is passed as the corresponding argument. [^23]
-[*Note 5*: If this results in a call to a usual deallocation function,
-and either the first argument was not the result of a prior call to a
-usual allocation function or the second 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]]).
-### 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 an integral constant of type `std::size_t`.
-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 (Clause  [[expr]]), can throw
-an exception ([[except.throw]]).
-``` bnf
-noexcept-expression:
-  'noexcept' '(' expression ')'
-```
-The result of the `noexcept` operator is a constant of type `bool` and
-is a prvalue.
-The result of the `noexcept` operator is `true` unless the *expression*
-is potentially-throwing ([[except.spec]]).

+### 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 ')'
     noexcept-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; };
 ```
 — *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]].
+Nor is `&unqualified-id` a pointer to member, even within the scope of
+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.
 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>
+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 `\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*]
+#### 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 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
+  resolution is ambiguous, the program is ill-formed. If no viable
+  functions are found, *o* is *a*. Otherwise, *o* is a call to the
+  selected function with the argument *a*. If *o* would be a prvalue,
+  the temporary materialization conversion [[conv.rval]] is applied.
+- *e* is an lvalue referring to the result of evaluating the
+  (possibly-converted) *o*.
+- *h* is an object of type `std::coroutine_handle<P>` referring to the
+  enclosing coroutine.
+- *await-ready* is the expression *e*`.await_ready()`, contextually
+  converted to `bool`.
+- *await-suspend* is the expression *e*`.await_suspend(`*h*`)`, which
+  shall be a prvalue of type `void`, `bool`, or
+  `std::coroutine_handle<Z>` for some type `Z`.
+- *await-resume* is the expression *e*`.await_resume()`.
+The *await-expression* has the same type and value category as the
+*await-resume* expression.
+The *await-expression* evaluates the (possibly-converted) *o* expression
+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>
+struct my_future {
+  ...
+  bool await_ready();
+  void await_suspend(std::coroutine_handle<>);
+  T await_resume();
+};
+template <class Rep, class Period>
+auto operator co_await(std::chrono::duration<Rep, Period> d) {
+  struct awaiter {
+    std::chrono::system_clock::duration duration;
+    ...
+    awaiter(std::chrono::system_clock::duration d) : duration(d) {}
+    bool await_ready() const { return duration.count() <= 0; }
+    void await_resume() {}
+    void await_suspend(std::coroutine_handle<> h) { ... }
+  };
+  return awaiter{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();
+}
+auto f(int x = co_await h());   // error: await-expression outside of function suspension context
+int a[] = { co_await h() };     // error: await-expression outside of function suspension context
+```
+— *end example*]
+#### 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.
+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>
 };
 ```
 — *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 [[expr.prop]], 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, 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:
+    '::'ₒₚₜ new new-placementₒₚₜ new-type-id new-initializerₒₚₜ
+    '::'ₒₚₜ new new-placementₒₚₜ '(' type-id ')' new-initializerₒₚₜ
 ```
 ``` bnf
 new-placement:
     '(' expression-list ')'
     noptr-new-declarator
 ```
 ``` bnf
 noptr-new-declarator:
+    '[' expressionₒₚₜ ']' attribute-specifier-seqₒₚₜ
     noptr-new-declarator '[' constant-expression ']' attribute-specifier-seqₒₚₜ
 ```
 ``` bnf
 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 ;
 ```
 — *end example*]
 The *new-type-id* in a *new-expression* is the longest possible sequence
 of *new-declarator*s.
+[*Note 3*: This prevents ambiguities between the declarator operators
 `&`, `&&`, `*`, and `[]` and their expression
 counterparts. — *end note*]
 [*Example 2*:
 The `*` is the pointer declarator and not the multiplication operator.
 — *end example*]
+[*Note 4*:
 Parentheses in a *new-type-id* of a *new-expression* can have surprising
 effects.
 [*Example 3*:
 ``` cpp
 (new int) (*[10])();            // error
 ```
 Instead, the explicitly parenthesized version of the `new` operator can
+be used to create objects of compound types [[basic.compound]]:
 ``` cpp
 new (int (*[10])());
 ```
 — *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.
 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
+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 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;
   - otherwise, the *new-expression* terminates by throwing an exception
+    of a type that would match a handler [[except.handle]] of 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.
 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
+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,
 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.
+[*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:
 - the evaluation of `e1` is sequenced before the evaluation of `e2`, and
 - `e2` is evaluated whenever `e1` obtains storage, and
 - both `e1` and `e2` invoke the same replaceable global allocation
   `e1`.
 [*Example 5*:
 ``` cpp
+void can_merge(int x) {
   // These allocations are safe for merging:
   std::unique_ptr<char[]> a{new (std::nothrow) char[8]};
   std::unique_ptr<char[]> b{new (std::nothrow) char[8]};
   std::unique_ptr<char[]> c{new (std::nothrow) char[x]};
   g(a.get(), b.get(), c.get());
 }
+void cannot_merge(int x) {
   std::unique_ptr<char[]> a{new char[8]};
   try {
     // Merging this allocation would change its catch handler.
     std::unique_ptr<char[]> b{new char[x]};
   } catch (const std::bad_alloc& e) {
 When a *new-expression* calls an allocation function and that allocation
 has not been extended, the *new-expression* passes the amount of space
 requested to the allocation function as the first argument of type
 `std::size_t`. That argument shall be no less than the size of the
 object being created; it may be greater than the size of the object
+being created only if the object is an array and the allocation function
+is not a non-allocating form [[new.delete.placement]]. For arrays of
+`char`, `unsigned char`, and `std::byte`, the difference between the
+result of the *new-expression* and the address returned by the
+allocation function shall be an integral multiple of the strictest
+fundamental alignment requirement [[basic.align]] of any object type
+whose size is no greater than the size of the array being created.
+[*Note 9*:  Because allocation functions are assumed to return pointers
 to storage that is appropriately aligned for objects of any type with
 fundamental alignment, this constraint on array allocation overhead
 permits the common idiom of allocating character arrays into which
 objects of other types will later be placed. — *end note*]
 assembling an argument list. The first argument is the amount of space
 requested, and has type `std::size_t`. If the type of the allocated
 object has new-extended alignment, the next argument is the type’s
 alignment, and has type `std::align_val_t`. If the *new-placement*
 syntax is used, the *initializer-clause*s in its *expression-list* are
+the succeeding arguments. If no matching function is found then
+- if the allocated object type has new-extended alignment, the alignment
+  argument is removed from the argument list;
+- otherwise, an argument that is the type’s alignment and has type
+  `std::align_val_t` is added into the argument list immediately after
+  the first argument;
+and then overload resolution is performed again.
 [*Example 6*:
 - `new T` results in one of the following calls:
   ``` cpp
 Here, each instance of `x` is a non-negative unspecified value
 representing array allocation overhead; the result of the
 *new-expression* will be offset by this amount from the value returned
 by `operator new[]`. This overhead may be applied in all array
+*new-expression*s, including those referencing a placement allocation
+function, except when referencing the library function
+`operator new[](std::size_t, void*)`. The amount of overhead may vary
+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*]
+If the allocation function is a non-allocating form
+[[new.delete.placement]] that returns null, the behavior is undefined.
 Otherwise, if the allocation function returns null, initialization shall
 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
+  [[dcl.init]]. \[*Note 12*: If no initialization is performed, the
+  object has an indeterminate value. — *end note*]
 - Otherwise, the *new-initializer* is interpreted according to the
   initialization rules of  [[dcl.init]] for direct-initialization.
 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 [[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.
 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
 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 {
   // Usual (non-placement) deallocation function:
   static void operator delete(void*, std::size_t);
 };
+S* p = new (0) S;   // error: non-placement deallocation function matches
                     // placement allocation function
 ```
 — *end example*]
 If a *new-expression* calls a deallocation function, it passes the value
 returned from the allocation function call as the first argument of type
 `void*`. If a placement deallocation function is called, it is passed
 the same additional arguments as were passed to the placement allocation
 function, that is, the same arguments as those specified with the
+*new-placement* syntax. If the implementation is allowed to introduce a
+temporary object or make a copy of any argument as part of the call to
+the allocation function, it is unspecified whether the same object is
+used in the call to both the allocation and deallocation functions.
+#### Delete <a id="expr.delete">[[expr.delete]]</a>
+The *delete-expression* operator destroys a most derived object
+[[intro.object]] or array created by a *new-expression*.
 ``` bnf
 delete-expression:
+    '::'ₒₚₜ delete cast-expression
+    '::'ₒₚₜ delete '[' ']' cast-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*]
 [*Note 2*: A pointer to a `const` type can be the operand of a
+*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
 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
+  deleted was not omitted and the allocation was not extended
+  [[expr.new]], the *delete-expression* shall call a deallocation
+  function [[basic.stc.dynamic.deallocation]]. The value returned from
+  the allocation call of the *new-expression* shall be passed as the
+  first argument to the deallocation function.
 - Otherwise, if the allocation was extended or was provided by extending
   the allocation of another *new-expression*, and the
   *delete-expression* for every other pointer value produced by a
   *new-expression* that had storage provided by the extended
   *new-expression* has been evaluated, the *delete-expression* shall
 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
 of type `std::align_val_t` is used, the alignment of the type of the
+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]]).

Diff to HTML by rtfpessoa