[dcl.fct.def] - C++20 → C++23

Files changed (1) hide show

tmp/tmpccph_bb3/{from.md → to.md} +124 -109

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

@@ -50,11 +50,11 @@ Here `int` is the *decl-specifier-seq*; `max(int` `a,` `int` `b,` `int`
 A *ctor-initializer* is used only in a constructor; see  [[class.ctor]]
 and  [[class.init]].
 [*Note 1*: A *cv-qualifier-seq* affects the type of `this` in the body
-of a member function; see  [[dcl.ref]]. — *end note*]
 [*Note 2*:
 Unused parameters need not be named. For example,
@@ -64,13 +64,12 @@ void print(int a, int) {
 }
 ```
 — *end note*]
-In the *function-body*, a *function-local predefined variable* denotes a
-block-scope object of static storage duration that is implicitly defined
-(see  [[basic.scope.block]]).
 The function-local predefined variable `__func__` is defined as if a
 definition of the form
 ``` cpp
@@ -101,47 +100,50 @@ explicitly defaulted shall
 - be a special member function or a comparison operator function
   [[over.binary]], and
 - not have default arguments.
-The type `T`₁ of an explicitly defaulted special member function `F` is
-allowed to differ from the type `T`₂ it would have had if it were
-implicitly declared, as follows:
-- `T`₁ and `T`₂ may have differing *ref-qualifier*s;
-- `T`₁ and `T`₂ may have differing exception specifications; and
-- if `T`₂ has a parameter of type `const C&`, the corresponding
-  parameter of `T`₁ may be of type `C&`.
-If `T`₁ differs from `T`₂ in any other way, then:
-- if `F` is an assignment operator, and the return type of `T`₁ differs
-  from the return type of `T`₂ or `T`₁’s parameter type is not a
-  reference, the program is ill-formed;
-- otherwise, if `F` is explicitly defaulted on its first declaration, it
-  is defined as deleted;
 - otherwise, the program is ill-formed.
-An explicitly-defaulted function that is not defined as deleted may be
-declared `constexpr` or `consteval` only if it is constexpr-compatible (
-[[special]], [[class.compare.default]]). A function explicitly defaulted
-on its first declaration is implicitly inline [[dcl.inline]], and is
-implicitly constexpr [[dcl.constexpr]] if it is constexpr-compatible.
 [*Example 1*:
 ``` cpp
 struct S {
-  constexpr S() = default;              // error: implicit S() is not constexpr
   S(int a = 0) = default;               // error: default argument
   void operator=(const S&) = default;   // error: non-matching return type
   ~S() noexcept(false) = default;       // OK, despite mismatched exception specification
 private:
   int i;
-  S(S&);                                // OK: private copy constructor
 };
-S::S(S&) = default;                     // OK: defines copy constructor
 struct T {
   T();
   T(T &&) noexcept(false);
 };
@@ -156,21 +158,26 @@ U u2 = static_cast<U&&>(u1);            // OK, calls std::terminate if T::T(T&&)
 — *end example*]
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
-provide implicit definitions for them ([[class.ctor]], [[class.dtor]],
-[[class.copy.ctor]], [[class.copy.assign]]), which might mean defining
-them as deleted. A defaulted prospective destructor [[class.dtor]] that
-is not a destructor is defined as deleted. A defaulted special member
-function that is neither a prospective destructor nor an eligible
-special member function [[special]] is defined as deleted. A function is
-*user-provided* if it is user-declared and not explicitly defaulted or
-deleted on its first declaration. A user-provided explicitly-defaulted
-function (i.e., explicitly defaulted after its first declaration) is
-defined at the point where it is explicitly defaulted; if such a
-function is implicitly defined as deleted, the program is ill-formed.
 [*Note 1*: Declaring a function as defaulted after its first
 declaration can provide efficient execution and concise definition while
 enabling a stable binary interface to an evolving code
 base. — *end note*]
@@ -195,24 +202,25 @@ nontrivial1::nontrivial1() = default;   // not first declaration
 — *end example*]
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
-A function definition whose *function-body* is of the form `= delete ;`
-is called a *deleted definition*. A function with a deleted definition
-is also called a *deleted function*.
 A program that refers to a deleted function implicitly or explicitly,
 other than to declare it, is ill-formed.
 [*Note 1*: This includes calling the function implicitly or explicitly
 and forming a pointer or pointer-to-member to the function. It applies
 even for references in expressions that are not potentially-evaluated.
-If a function is overloaded, it is referenced only if the function is
-selected by overload resolution. The implicit odr-use [[basic.def.odr]]
-of a virtual function does not, by itself, constitute a
-reference. — *end note*]
 [*Example 1*:
 One can prevent default initialization and initialization by
 non-`double`s with
@@ -321,19 +329,21 @@ task<void> g3(int a, ...) {     // error: variable parameter list not allowed
 — *end example*]
 The *promise type* of a coroutine is
 `std::coroutine_traits<R, P₁, …, Pₙ>::promise_type`, where `R` is the
-return type of the function, and `P₁` … `Pₙ` are the sequence of types
-of the function parameters, preceded by the type of the implicit object
-parameter [[over.match.funcs]] 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
-`*this` and `p_i+1` denotes the $i^\textrm{th}$ function parameter for a
-non-static member function, and `pᵢ` denotes the $i^\textrm{th}$
-function parameter otherwise.
 A coroutine behaves as if its *function-body* were replaced by:
 ``` bnf
 '{'
@@ -354,75 +364,81 @@ final-suspend ':'
 ```
 where
 - the *await-expression* containing the call to `initial_suspend` is the
-  *initial suspend point*, and
 - the *await-expression* containing the call to `final_suspend` is the
-  *final suspend point*, and
 - *initial-await-resume-called* is initially `false` and is set to
   `true` immediately before the evaluation of the *await-resume*
-  expression [[expr.await]] of the initial suspend point, and
 - *promise-type* denotes the promise type, and
 - the object denoted by the exposition-only name *`promise`* is the
   *promise object* of the coroutine, and
 - the label denoted by the name *`final-suspend`* is defined for
   exposition only [[stmt.return.coroutine]], and
 - *promise-constructor-arguments* is determined as follows: overload
   resolution is performed on a promise constructor call created by
-  assembling an argument list with lvalues `p₁` … `pₙ`. If a viable
- constructor is found [[over.match.viable]], then
- *promise-constructor-arguments* is `(p₁, …, pₙ)`, otherwise
-  *promise-constructor-arguments* is empty.
-The *unqualified-id*s `return_void` and `return_value` are looked up in
-the scope of the promise type. If both are found, the program is
 ill-formed.
-[*Note 1*: If the *unqualified-id* `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
-glvalue result or prvalue result object of a call to a coroutine. The
-call to `get_return_object` is sequenced before the call to
 `initial_suspend` and is invoked at most once.
 A suspended coroutine can be resumed to continue execution by invoking a
 resumption member function [[coroutine.handle.resumption]] of a
 coroutine handle [[coroutine.handle]] that refers to the coroutine. The
-function that invoked a resumption member function is called the
 *resumer*. Invoking a resumption member function for a coroutine that is
 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 in the scope of the promise type. If this lookup fails, the
-allocation function’s name is looked up in the global scope. If the
-lookup finds an allocation function in the scope of the promise type,
-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`. The lvalues `p₁` … `pₙ` are the
-succeeding 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 an
-argument of type `std::size_t`.
-The *unqualified-id* `get_return_object_on_allocation_failure` is looked
-up in the scope of the promise type by class member access lookup
-[[basic.lookup.classref]]. If any declarations are found, 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-specification*. 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*:
@@ -437,11 +453,11 @@ struct generator {
   struct promise_type {
     int current_value;
     static auto get_return_object_on_allocation_failure() { return generator{nullptr}; }
     auto get_return_object() { return generator{handle::from_promise(*this)}; }
     auto initial_suspend() { return std::suspend_always{}; }
-    auto final_suspend() { return std::suspend_always{}; }
     void unhandled_exception() { std::terminate(); }
     void return_void() {}
     auto yield_value(int value) {
       current_value = value;
       return std::suspend_always{};
@@ -467,30 +483,28 @@ int main() {
 The coroutine state is destroyed when control flows off the end of the
 coroutine or the `destroy` member function
 [[coroutine.handle.resumption]] of a coroutine handle
 [[coroutine.handle]] that refers to the coroutine is invoked. In the
-latter case objects with automatic storage duration that are in scope at
-the suspend point are destroyed in the reverse order of the
-construction. The storage for the coroutine state is released by calling
-a non-array deallocation function [[basic.stc.dynamic.deallocation]]. If
-`destroy` is called for a coroutine that is not suspended, the program
-has undefined behavior.
-The deallocation function’s name is looked up in the scope of the
-promise type. If this lookup fails, the deallocation function’s name is
-looked up in the global scope. If deallocation function lookup finds
-both a usual deallocation function with only a pointer parameter and a
-usual deallocation function with both a pointer parameter and a size
-parameter, then the selected deallocation function shall be the one with
-two parameters. Otherwise, the selected deallocation function shall be
-the function with one parameter. If no 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
@@ -511,10 +525,11 @@ 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()`
 exits via an exception, the coroutine is considered suspended at the
-final suspend point.
 The expression `co_await` `promise.final_suspend()` shall not be
 potentially-throwing [[except.spec]].

 A *ctor-initializer* is used only in a constructor; see  [[class.ctor]]
 and  [[class.init]].
 [*Note 1*: A *cv-qualifier-seq* affects the type of `this` in the body
+of a member function; see  [[expr.prim.this]]. — *end note*]
 [*Note 2*:
 Unused parameters need not be named. For example,
 }
 ```
 — *end note*]
+A *function-local predefined variable* is a variable with static storage
+duration that is implicitly defined in a function parameter scope.
 The function-local predefined variable `__func__` is defined as if a
 definition of the form
 ``` cpp
 - be a special member function or a comparison operator function
   [[over.binary]], and
 - not have default arguments.
+An explicitly defaulted special member function `F₁` is allowed to
+differ from the corresponding special member function `F₂` that would
+have been implicitly declared, as follows:
+- `F₁` and `F₂` may have differing *ref-qualifier*s;
+- if `F₂` has an implicit object parameter of type “reference to `C`”,
+ `F₁` may be an explicit object member function whose explicit object
+  parameter is of type “reference to `C`”, in which case the type of
+  `F₁` would differ from the type of `F₂` in that the type of `F₁` has
+  an additional parameter;
+- `F₁` and `F₂` may have differing exception specifications; and
+- if `F₂` has a non-object parameter of type `const C&`, the
+  corresponding non-object parameter of `F₁` may be of type `C&`.
+If the type of `F₁` differs from the type of `F₂` in a way other than as
+allowed by the preceding rules, then:
+- if `F₁` is an assignment operator, and the return type of `F₁` differs
+  from the return type of `F₂` or `F₁`’s non-object parameter type is
+ not a reference, the program is ill-formed;
+- otherwise, if `F₁` is explicitly defaulted on its first declaration,
+ it is defined as deleted;
 - otherwise, the program is ill-formed.
+A function explicitly defaulted on its first declaration is implicitly
+inline [[dcl.inline]], and is implicitly constexpr [[dcl.constexpr]] if
+it is constexpr-suitable.
 [*Example 1*:
 ``` cpp
 struct S {
   S(int a = 0) = default;               // error: default argument
   void operator=(const S&) = default;   // error: non-matching return type
   ~S() noexcept(false) = default;       // OK, despite mismatched exception specification
 private:
   int i;
+  S(S&);                                // OK, private copy constructor
 };
+S::S(S&) = default;                     // OK, defines copy constructor
 struct T {
   T();
   T(T &&) noexcept(false);
 };
 — *end example*]
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
+provide implicit definitions for them
+[[class.ctor]], [[class.dtor]], [[class.copy.ctor]], [[class.copy.assign]]
+as described below, including possibly defining them as deleted. A
+defaulted prospective destructor [[class.dtor]] that is not a destructor
+is defined as deleted. A defaulted special member function that is
+neither a prospective destructor nor an eligible special member function
+[[special]] is defined as deleted. A function is *user-provided* if it
+is user-declared and not explicitly defaulted or deleted on its first
+declaration. A user-provided explicitly-defaulted function (i.e.,
+explicitly defaulted after its first declaration) is implicitly defined
+at the point where it is explicitly defaulted; if such a function is
+implicitly defined as deleted, the program is ill-formed. A
+non-user-provided defaulted function (i.e., implicitly declared or
+explicitly defaulted in the class) that is not defined as deleted is
+implicitly defined when it is odr-used [[basic.def.odr]] or needed for
+constant evaluation [[expr.const]].
 [*Note 1*: Declaring a function as defaulted after its first
 declaration can provide efficient execution and concise definition while
 enabling a stable binary interface to an evolving code
 base. — *end note*]
 — *end example*]
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
+A *deleted definition* of a function is a function definition whose
+*function-body* is of the form `= delete ;` or an explicitly-defaulted
+definition of the function where the function is defined as deleted. A
+*deleted function* is a function with a deleted definition or a function
+that is implicitly defined as deleted.
 A program that refers to a deleted function implicitly or explicitly,
 other than to declare it, is ill-formed.
 [*Note 1*: This includes calling the function implicitly or explicitly
 and forming a pointer or pointer-to-member to the function. It applies
 even for references in expressions that are not potentially-evaluated.
+For an overload set, only the function selected by overload resolution
+is referenced. The implicit odr-use [[term.odr.use]] of a virtual
+function does not, by itself, constitute a reference. — *end note*]
 [*Example 1*:
 One can prevent default initialization and initialization by
 non-`double`s with
 — *end example*]
 The *promise type* of a coroutine is
 `std::coroutine_traits<R, P₁, …, Pₙ>::promise_type`, where `R` is the
+return type of the function, and `P₁` … `Pₙ` is the sequence of types of
+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
 '{'
 ```
 where
 - the *await-expression* containing the call to `initial_suspend` is the
+  *initial await expression*, and
 - the *await-expression* containing the call to `final_suspend` is the
+  *final await expression*, and
 - *initial-await-resume-called* is initially `false` and is set to
   `true` immediately before the evaluation of the *await-resume*
+  expression [[expr.await]] of the initial await expression, and
 - *promise-type* denotes the promise type, and
 - the object denoted by the exposition-only name *`promise`* is the
   *promise object* of the coroutine, and
 - the label denoted by the name *`final-suspend`* is defined for
   exposition only [[stmt.return.coroutine]], and
 - *promise-constructor-arguments* is determined as follows: overload
   resolution is performed on a promise constructor call created by
+  assembling an argument list `q₁` … `qₙ`. If a viable constructor is
+  found [[over.match.viable]], then *promise-constructor-arguments* is
+  `(q₁, …, qₙ)`, otherwise *promise-constructor-arguments* is empty, and
+- a coroutine is suspended at the *initial suspend point* if it is
+  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
+returned reference or prvalue result object of a call to a coroutine.
+The call to `get_return_object` is sequenced before the call to
 `initial_suspend` and is invoked at most once.
 A suspended coroutine can be resumed to continue execution by invoking a
 resumption member function [[coroutine.handle.resumption]] of a
 coroutine handle [[coroutine.handle]] that refers to the coroutine. The
+evaluation that invoked a resumption member function is called the
 *resumer*. Invoking a resumption member function for a coroutine that is
 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`.
+If a search for the name `get_return_object_on_allocation_failure` in
+the scope of the promise type [[class.member.lookup]] finds any
+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*:
   struct promise_type {
     int current_value;
     static auto get_return_object_on_allocation_failure() { return generator{nullptr}; }
     auto get_return_object() { return generator{handle::from_promise(*this)}; }
     auto initial_suspend() { return std::suspend_always{}; }
+    auto final_suspend() noexcept { return std::suspend_always{}; }
     void unhandled_exception() { std::terminate(); }
     void return_void() {}
     auto yield_value(int value) {
       current_value = value;
       return std::suspend_always{};
 The coroutine state is destroyed when control flows off the end of the
 coroutine or the `destroy` member function
 [[coroutine.handle.resumption]] of a coroutine handle
 [[coroutine.handle]] that refers to the coroutine is invoked. In the
+latter case, control in the coroutine is considered to be transferred
+out of the function [[stmt.dcl]]. The storage for the coroutine state is
+released by calling a non-array deallocation function
+[[basic.stc.dynamic.deallocation]]. If `destroy` is called for a
+coroutine that is not suspended, the program has undefined behavior.
+The deallocation function’s name is looked up by searching for it in the
+scope of the promise type. If nothing is found, a search is performed in
+the global scope. If both a usual deallocation function with only a
+pointer parameter and a usual deallocation function with both a pointer
+parameter and a size parameter are found, then the selected deallocation
+function shall be the one with two parameters. Otherwise, the selected
+deallocation function shall be the function with one parameter. If no
+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
 parameter has ended is likely to result in undefined
 behavior. — *end note*]
 If the evaluation of the expression `promise.unhandled_exception()`
 exits via an exception, the coroutine is considered suspended at the
+final suspend point and the exception propagates to the caller or
+resumer.
 The expression `co_await` `promise.final_suspend()` shall not be
 potentially-throwing [[except.spec]].

Diff to HTML by rtfpessoa