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

Files changed (1) hide show

tmp/tmpud7b8a28/{from.md → to.md} +109 -44

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

@@ -1,30 +1,42 @@
 ## Function definitions <a id="dcl.fct.def">[[dcl.fct.def]]</a>
-### In general <a id="dcl.fct.def.general">[[dcl.fct.def.general]]</a>
 Function definitions have the form
 ``` bnf
 function-definition:
-    attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ function-body
-    attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator requires-clause function-body
 ```
 ``` bnf
 function-body:
     ctor-initializerₒₚₜ compound-statement
     function-try-block
     '=' default ';'
     '=' delete ';'
 ```
 Any informal reference to the body of a function should be interpreted
-as a reference to the non-terminal *function-body*. The optional
 *attribute-specifier-seq* in a *function-definition* appertains to the
-function. A *virt-specifier-seq* can be part of a *function-definition*
-only if it is a *member-declaration* [[class.mem]].
 In a *function-definition*, either `void` *declarator* `;` or
 *declarator* `;` shall be a well-formed function declaration as
 described in  [[dcl.fct]]. A function shall be defined only in namespace
 or class scope. The type of a parameter or the return type for a
@@ -96,24 +108,24 @@ void f(const char* s = __func__);   // error: __func__ is undeclared
 A function definition whose *function-body* is of the form `= default ;`
 is called an *explicitly-defaulted* definition. A function that is
 explicitly defaulted shall
-- 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
@@ -128,10 +140,13 @@ allowed by the preceding rules, then:
 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
@@ -169,21 +184,25 @@ 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*]
 [*Example 2*:
 ``` cpp
 struct trivial {
   trivial() = default;
@@ -203,24 +222,30 @@ nontrivial1::nontrivial1() = default;   // not first declaration
 — *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
@@ -336,16 +361,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()' ';'
@@ -386,15 +415,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
@@ -410,20 +443,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`.
@@ -433,12 +468,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*:
@@ -502,27 +537,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()`
@@ -531,5 +571,30 @@ 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]].

 ## Function definitions <a id="dcl.fct.def">[[dcl.fct.def]]</a>
+### General <a id="dcl.fct.def.general">[[dcl.fct.def.general]]</a>
 Function definitions have the form
 ``` bnf
 function-definition:
+    attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ
+       function-contract-specifier-seqₒₚₜ function-body
+    attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator requires-clause
+       function-contract-specifier-seqₒₚₜ function-body
 ```
 ``` bnf
 function-body:
     ctor-initializerₒₚₜ compound-statement
     function-try-block
     '=' default ';'
+    deleted-function-body
+```
+``` bnf
+deleted-function-body:
     '=' delete ';'
+    '=' delete '(' unevaluated-string ')' ';'
 ```
 Any informal reference to the body of a function should be interpreted
+as a reference to the non-terminal *function-body*, including, for a
+constructor, default member initializers or default initialization used
+to initialize a base or member subobject in the absence of a
+*mem-initializer-id* [[class.base.init]]. The optional
 *attribute-specifier-seq* in a *function-definition* appertains to the
+function. A *function-definition* with a *virt-specifier-seq* shall be a
+*member-declaration* [[class.mem]]. A *function-definition* with a
+*requires-clause* shall define a templated function.
 In a *function-definition*, either `void` *declarator* `;` or
 *declarator* `;` shall be a well-formed function declaration as
 described in  [[dcl.fct]]. A function shall be defined only in namespace
 or class scope. The type of a parameter or the return type for a
 A function definition whose *function-body* is of the form `= default ;`
 is called an *explicitly-defaulted* definition. A function that is
 explicitly defaulted shall
+- be a special member function [[special]] or a comparison operator
+ function [[over.binary]], [[class.compare.default]], and
+- not have default arguments [[dcl.fct.default]].
 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 (possibly different) 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
 A function explicitly defaulted on its first declaration is implicitly
 inline [[dcl.inline]], and is implicitly constexpr [[dcl.constexpr]] if
 it is constexpr-suitable.
+[*Note 1*: Other defaulted functions are not implicitly
+constexpr. — *end note*]
 [*Example 1*:
 ``` cpp
 struct S {
   S(int a = 0) = default;               // error: default argument
 [[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.
+[*Note 2*: 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*]
+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 3*: The implicit definition of a non-user-provided defaulted
+function does not bind any names. — *end note*]
 [*Example 2*:
 ``` cpp
 struct trivial {
   trivial() = default;
 — *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 a *deleted-function-body* 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 construct that designates a deleted function implicitly or explicitly,
+other than to declare it or to appear as the operand of a
+*reflect-expression* [[expr.reflect]], is ill-formed.
+*Recommended practice:* The resulting diagnostic message should include
+the text of the *unevaluated-string*, if one is supplied.
 [*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. The
+*unevaluated-string*, if present, can be used to explain the rationale
+for deletion and/or to suggest an alternative. — *end note*]
 [*Example 1*:
 One can prevent default initialization and initialization by
 non-`double`s with
 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()`
 resumer.
 The expression `co_await` `promise.final_suspend()` shall not be
 potentially-throwing [[except.spec]].
+### Replaceable function definitions <a id="dcl.fct.def.replace">[[dcl.fct.def.replace]]</a>
+Certain functions for which a definition is supplied by the
+implementation are *replaceable*. A C++ program may provide a definition
+with the signature of a replaceable function, called a
+*replacement function*. The replacement function is used instead of the
+default version supplied by the implementation. Such replacement occurs
+prior to program startup [[basic.def.odr]], [[basic.start]]. A
+declaration of the replacement function
+- shall not be inline,
+- shall be attached to the global module,
+- shall have C++ language linkage,
+- shall have the same return type as the replaceable function, and
+- if the function is declared in a standard library header, shall be
+  such that it would be valid as a redeclaration of the declaration in
+  that header;
+no diagnostic is required.
+[*Note 1*: The one-definition rule [[basic.def.odr]] applies to the
+definitions of a replaceable function provided by the program. The
+implementation-supplied function definition is an otherwise-unnamed
+function with no linkage. — *end note*]

Diff to HTML by rtfpessoa