[dcl.fct.def.coroutine] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpkszp_lku/{from.md → to.md} +37 -22

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

@@ -38,16 +38,20 @@ the non-object function parameters, preceded by the type of the object
 parameter [[dcl.fct]] if the coroutine is a non-static member function.
 The promise type shall be a class type.
 In the following, `pᵢ` is an lvalue of type `Pᵢ`, where `p₁` denotes the
 object parameter and `p_i+1` denotes the iᵗʰ non-object function
-parameter for a non-static member function, and `pᵢ` denotes the iᵗʰ
-function parameter otherwise. For a non-static member function, `q₁` is
-an lvalue that denotes `*this`; any other `qᵢ` is an lvalue that denotes
-the parameter copy corresponding to `pᵢ`, as described below.
-A coroutine behaves as if its *function-body* were replaced by:
 ``` bnf
 '{'
    *promise-type* promise *promise-constructor-arguments* ';'
 % FIXME: promise'.get_return_object()' ';'
@@ -88,15 +92,19 @@ where
   suspended at the initial await expression, and
 - a coroutine is suspended at a *final suspend point* if it is suspended
   - at a final await expression or
   - due to an exception exiting from `unhandled_exception()`.
 If searches for the names `return_void` and `return_value` in the scope
 of the promise type each find any declarations, the program is
 ill-formed.
-[*Note 1*: If `return_void` is found, flowing off the end of a
 coroutine is equivalent to a `co_return` with no operand. Otherwise,
 flowing off the end of a coroutine results in undefined behavior
 [[stmt.return.coroutine]]. — *end note*]
 The expression `promise.get_return_object()` is used to initialize the
@@ -112,20 +120,22 @@ evaluation that invoked a resumption member function is called the
 not suspended results in undefined behavior.
 An implementation may need to allocate additional storage for a
 coroutine. This storage is known as the *coroutine state* and is
 obtained by calling a non-array allocation function
-[[basic.stc.dynamic.allocation]]. The allocation function’s name is
-looked up by searching for it in the scope of the promise type.
 - If the search finds any declarations, overload resolution is performed
   on a function call created by assembling an argument list. The first
   argument is the amount of space requested, and is a prvalue of type
-  `std::size_t`. The lvalues `p₁` … `pₙ` are the successive arguments.
- If no viable function is found [[over.match.viable]], overload
- resolution is performed again on a function call created by passing
- just the amount of space required as a prvalue of type `std::size_t`.
 - If the search finds no declarations, a search is performed in the
   global scope. Overload resolution is performed on a function call
   created by passing the amount of space required as a prvalue of type
   `std::size_t`.
@@ -135,12 +145,12 @@ declarations, then the result of a call to an allocation function used
 to obtain storage for the coroutine state is assumed to return `nullptr`
 if it fails to obtain storage, and if a global allocation function is
 selected, the `::operator new(size_t, nothrow_t)` form is used. The
 allocation function used in this case shall have a non-throwing
 *noexcept-specifier*. If the allocation function returns `nullptr`, the
-coroutine returns control to the caller of the coroutine and the return
-value is obtained by a call to
 `T::get_return_object_on_allocation_failure()`, where `T` is the promise
 type.
 [*Example 2*:
@@ -204,27 +214,32 @@ usual deallocation function is found, the program is ill-formed. The
 selected deallocation function shall be called with the address of the
 block of storage to be reclaimed as its first argument. If a
 deallocation function with a parameter of type `std::size_t` is used,
 the size of the block is passed as the corresponding argument.
-When a coroutine is invoked, after initializing its parameters
-[[expr.call]], a copy is created for each coroutine parameter. For a
-parameter of type cv `T`, the copy is a variable of type cv `T` with
-automatic storage duration that is direct-initialized from an xvalue of
-type `T` referring to the parameter.
-[*Note 2*: An original parameter object is never a const or volatile
-object [[basic.type.qualifier]]. — *end note*]
 The initialization and destruction of each parameter copy occurs in the
 context of the called coroutine. Initializations of parameter copies are
 sequenced before the call to the coroutine promise constructor and
 indeterminately sequenced with respect to each other. The lifetime of
 parameter copies ends immediately after the lifetime of the coroutine
 promise object ends.
-[*Note 3*: If a coroutine has a parameter passed by reference, resuming
 the coroutine after the lifetime of the entity referred to by that
 parameter has ended is likely to result in undefined
 behavior. — *end note*]
 If the evaluation of the expression `promise.unhandled_exception()`

 parameter [[dcl.fct]] if the coroutine is a non-static member function.
 The promise type shall be a class type.
 In the following, `pᵢ` is an lvalue of type `Pᵢ`, where `p₁` denotes the
 object parameter and `p_i+1` denotes the iᵗʰ non-object function
+parameter for an implicit object member function, and `pᵢ` denotes the
+iᵗʰ function parameter otherwise. For an implicit object member
+function, `q₁` is an lvalue that denotes `*this`; any other `qᵢ` is an
+lvalue that denotes the parameter copy corresponding to `pᵢ`, as
+described below.
+A coroutine behaves as if the top-level cv-qualifiers in all
+*parameter-declaration*s in the declarator of its *function-definition*
+were removed and its *function-body* were replaced by the following
+*replacement body*:
 ``` bnf
 '{'
    *promise-type* promise *promise-constructor-arguments* ';'
 % FIXME: promise'.get_return_object()' ';'
   suspended at the initial await expression, and
 - a coroutine is suspended at a *final suspend point* if it is suspended
   - at a final await expression or
   - due to an exception exiting from `unhandled_exception()`.
+[*Note 1*: An odr-use of a non-reference parameter in a postcondition
+assertion of a coroutine is ill-formed
+[[dcl.contract.func]]. — *end note*]
 If searches for the names `return_void` and `return_value` in the scope
 of the promise type each find any declarations, the program is
 ill-formed.
+[*Note 2*: If `return_void` is found, flowing off the end of a
 coroutine is equivalent to a `co_return` with no operand. Otherwise,
 flowing off the end of a coroutine results in undefined behavior
 [[stmt.return.coroutine]]. — *end note*]
 The expression `promise.get_return_object()` is used to initialize the
 not suspended results in undefined behavior.
 An implementation may need to allocate additional storage for a
 coroutine. This storage is known as the *coroutine state* and is
 obtained by calling a non-array allocation function
+[[basic.stc.dynamic.allocation]] as part of the replacement body. The
+allocation function’s name is looked up by searching for it in the scope
+of the promise type.
 - If the search finds any declarations, overload resolution is performed
   on a function call created by assembling an argument list. The first
   argument is the amount of space requested, and is a prvalue of type
+  `std::size_t`. The lvalues `p₁` … `pₙ` with their original types
+ (including cv-qualifiers) are the successive arguments. If no viable
+ function is found [[over.match.viable]], overload resolution is
+ performed again on a function call created by passing just the amount
+  of space required as a prvalue of type `std::size_t`.
 - If the search finds no declarations, a search is performed in the
   global scope. Overload resolution is performed on a function call
   created by passing the amount of space required as a prvalue of type
   `std::size_t`.
 to obtain storage for the coroutine state is assumed to return `nullptr`
 if it fails to obtain storage, and if a global allocation function is
 selected, the `::operator new(size_t, nothrow_t)` form is used. The
 allocation function used in this case shall have a non-throwing
 *noexcept-specifier*. If the allocation function returns `nullptr`, the
+coroutine transfers control to the caller of the coroutine and the
+return value is obtained by a call to
 `T::get_return_object_on_allocation_failure()`, where `T` is the promise
 type.
 [*Example 2*:
 selected deallocation function shall be called with the address of the
 block of storage to be reclaimed as its first argument. If a
 deallocation function with a parameter of type `std::size_t` is used,
 the size of the block is passed as the corresponding argument.
+When a coroutine is invoked, a copy is created for each coroutine
+parameter at the beginning of the replacement body. For a parameter
+whose original declaration specified the type cv `T`,
+- if `T` is a reference type, the copy is a reference of type cv `T`
+  bound to the same object as a parameter;
+- otherwise, the copy is a variable of type cv `T` with automatic
+  storage duration that is direct-initialized from an xvalue of type `T`
+  referring to the parameter.
+[*Note 3*: An identifier in the *function-body* that names one of these
+parameters refers to the created copy, not the original parameter
+[[expr.prim.id.unqual]]. — *end note*]
 The initialization and destruction of each parameter copy occurs in the
 context of the called coroutine. Initializations of parameter copies are
 sequenced before the call to the coroutine promise constructor and
 indeterminately sequenced with respect to each other. The lifetime of
 parameter copies ends immediately after the lifetime of the coroutine
 promise object ends.
+[*Note 4*: If a coroutine has a parameter passed by reference, resuming
 the coroutine after the lifetime of the entity referred to by that
 parameter has ended is likely to result in undefined
 behavior. — *end note*]
 If the evaluation of the expression `promise.unhandled_exception()`

Diff to HTML by rtfpessoa