[expr.call] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpv725dnkb/{from.md → to.md} +72 -49

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

@@ -2,20 +2,20 @@
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
-[*Note 1*: If the postfix expression is a function or member function
-name, the appropriate function and the validity of the call are
-determined according to the rules in  [[over.match]]. — *end note*]
 The postfix expression shall have function type or function pointer
 type. For a call to a non-member function or to a static member
-function, the postfix expression shall either be an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
-[[conv.func]] is suppressed on the postfix expression), or have function
-pointer type.
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
@@ -24,14 +24,13 @@ type of the object expression is called; such a call is referred to as a
 [*Note 2*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
-[*Note 3*: If a function or member function name is used, and name
-lookup [[basic.lookup]] does not find a declaration of that name, the
-program is ill-formed. No function is implicitly declared by such a
-call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
@@ -40,41 +39,44 @@ different. If the *postfix-expression* names a pseudo-destructor (in
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
 denoted by the object expression of the class member access
 [[expr.ref]], [[basic.life]].
-Calling a function through an expression whose function type `E` is
-different from the function type `F` of the called function’s definition
-results in undefined behavior unless the type “pointer to `F`” can be
-converted to the type “pointer to `E`” via a function pointer conversion
-[[conv.fctptr]].
-[*Note 4*: The exception applies when the expression has the type of a
-potentially-throwing function, but the called function has a
 non-throwing exception specification, and the function types are
 otherwise the same. — *end note*]
 When a function is called, each parameter [[dcl.fct]] is initialized
-[[dcl.init]], [[class.copy.ctor]] with its corresponding argument. If
-the function is an explicit object member function and there is an
-implied object argument [[over.call.func]], the list of provided
-arguments is preceded by the implied object argument for the purposes of
-this correspondence. If there is no corresponding argument, the default
-argument for the parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
-If the function is an implicit object member function, the `this`
-parameter of the function [[expr.prim.this]] is initialized with a
-pointer to the object of the call, converted as if by an explicit type
 conversion [[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
@@ -85,28 +87,37 @@ class type that is either incomplete or abstract.
 [*Note 6*: This still allows a parameter to be a pointer or reference
 to such a type. However, it prevents a passed-by-value parameter to have
 an incomplete or abstract class type. — *end note*]
-It is *implementation-defined* whether the lifetime of a parameter ends
-when the function in which it is defined returns or at the end of the
-enclosing full-expression. The initialization and destruction of each
-parameter occurs within the context of the calling function.
-[*Example 2*: The access of the constructor, conversion functions or
-destructor is checked at the point of call in the calling function. If a
-constructor or destructor for a function parameter throws an exception,
-the search for a handler starts in the calling function; in particular,
-if the function called has a *function-try-block* [[except.pre]] with a
-handler that can handle the exception, this handler is not
 considered. — *end example*]
 The *postfix-expression* is sequenced before each *expression* in the
 *expression-list* and any default argument. The initialization of a
-parameter, including every associated value computation and side effect,
-is indeterminately sequenced with respect to that of any other
-parameter.
 [*Note 7*: All side effects of argument evaluations are sequenced
 before the function is entered (see
 [[intro.execution]]). — *end note*]
@@ -150,17 +161,26 @@ control out of the called function (if any), except in a virtual
 function call if the return type of the final overrider is different
 from the return type of the statically chosen function, the value
 returned from the final overrider is converted to the return type of the
 statically chosen function.
 [*Note 9*:  A function can change the values of its non-const
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
-reference is to a const-qualified type, `const_cast` is required to be
-used to cast away the constness in order to modify the argument’s value.
-Where a parameter is of `const` reference type a temporary object is
-introduced if needed
 [[dcl.type]], [[lex.literal]], [[lex.string]], [[dcl.array]], [[class.temporary]].
 In addition, it is possible to modify the values of non-constant objects
 through pointer parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
@@ -186,15 +206,16 @@ The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are performed on
 the argument expression. An argument that has type cv `std::nullptr_t`
 is converted to type `void*` [[conv.ptr]]. After these conversions, if
 the argument does not have arithmetic, enumeration, pointer,
 pointer-to-member, or class type, the program is ill-formed. Passing a
-potentially-evaluated argument of a scoped enumeration type or of a
-class type [[class]] having an eligible non-trivial copy constructor, an
-eligible non-trivial move constructor, or a non-trivial destructor
-[[special]], with no corresponding parameter, is conditionally-supported
-with *implementation-defined* semantics. If the argument has integral or
 enumeration type that is subject to the integral promotions
 [[conv.prom]], or a floating-point type that is subject to the
 floating-point promotion [[conv.fpprom]], the value of the argument is
 converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
@@ -202,7 +223,9 @@ referred to as the *default argument promotions*.
 Recursive calls are permitted, except to the `main` function
 [[basic.start.main]].
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
-type is an rvalue reference to object type, and a prvalue otherwise.

 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
+[*Note 1*: If the postfix expression is a function name, the
+appropriate function and the validity of the call are determined
+according to the rules in  [[over.match]]. — *end note*]
 The postfix expression shall have function type or function pointer
 type. For a call to a non-member function or to a static member
+function, the postfix expression shall be either an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
+[[conv.func]] is suppressed on the postfix expression), or a prvalue of
+function pointer type.
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
 [*Note 2*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
+[*Note 3*: If a function name is used, and name lookup [[basic.lookup]]
+does not find a declaration of that name, the program is ill-formed. No
+function is implicitly declared by such a call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
 denoted by the object expression of the class member access
 [[expr.ref]], [[basic.life]].
+A type `T`_call is *call-compatible* with a function type `T`_func if
+`T`_call is the same type as `T`_func or if the type “pointer to
+`T`_func” can be converted to type “pointer to `T`_call” via a function
+pointer conversion [[conv.fctptr]]. Calling a function through an
+expression whose function type is not call-compatible with the type of
+the called function’s definition results in undefined behavior.
+[*Note 4*: This requirement allows the case when the expression has the
+type of a potentially-throwing function, but the called function has a
 non-throwing exception specification, and the function types are
 otherwise the same. — *end note*]
 When a function is called, each parameter [[dcl.fct]] is initialized
+[[dcl.init]], [[class.copy.ctor]] with its corresponding argument, and
+each precondition assertion of the function is evaluated
+[[dcl.contract.func]]. If the function is an explicit object member
+function and there is an implied object argument [[over.call.func]], the
+list of provided arguments is preceded by the implied object argument
+for the purposes of this correspondence. If there is no corresponding
+argument, the default argument for the parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
+If the function is an implicit object member function, the object
+expression of the class member access shall be a glvalue and the
+implicit object parameter of the function [[over.match.funcs]] is
+initialized with that glvalue, converted as if by an explicit type
 conversion [[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
 [*Note 6*: This still allows a parameter to be a pointer or reference
 to such a type. However, it prevents a passed-by-value parameter to have
 an incomplete or abstract class type. — *end note*]
+It is *implementation-defined* whether a parameter is destroyed when the
+function in which it is defined exits
+[[stmt.return]], [[except.ctor]], [[expr.await]] or at the end of the
+enclosing full-expression; parameters are always destroyed in the
+reverse order of their construction. The initialization and destruction
+of each parameter occurs within the context of the full-expression
+[[intro.execution]] where the function call appears.
+[*Example 2*: The access [[class.access.general]] of the constructor,
+conversion functions, or destructor is checked at the point of call. If
+a constructor or destructor for a function parameter throws an
+exception, any *function-try-block* [[except.pre]] of the called
+function with a handler that can handle the exception is not
 considered. — *end example*]
 The *postfix-expression* is sequenced before each *expression* in the
 *expression-list* and any default argument. The initialization of a
+parameter or, if the implementation introduces any temporary objects to
+hold the values of function parameters [[class.temporary]], the
+initialization of those temporaries, including every associated value
+computation and side effect, is indeterminately sequenced with respect
+to that of any other parameter. These evaluations are sequenced before
+the evaluation of the precondition assertions of the function, which are
+evaluated in sequence [[dcl.contract.func]]. For any temporaries
+introduced to hold the values of function parameters, the initialization
+of the parameter objects from those temporaries is indeterminately
+sequenced with respect to the evaluation of each precondition assertion.
 [*Note 7*: All side effects of argument evaluations are sequenced
 before the function is entered (see
 [[intro.execution]]). — *end note*]
 function call if the return type of the final overrider is different
 from the return type of the statically chosen function, the value
 returned from the final overrider is converted to the return type of the
 statically chosen function.
+When the called function exits normally [[stmt.return]], [[expr.await]],
+all postcondition assertions of the function are evaluated in sequence
+[[dcl.contract.func]]. If the implementation introduces any temporary
+objects to hold the result value as specified in [[class.temporary]],
+the evaluation of each postcondition assertion is indeterminately
+sequenced with respect to the initialization of any of those temporaries
+or the result object. These evaluations, in turn, are sequenced before
+the destruction of any function parameters.
 [*Note 9*:  A function can change the values of its non-const
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
+reference is to a const-qualified type, `const_cast` needs to be used to
+cast away the constness in order to modify the argument’s value. Where a
+parameter is of `const` reference type a temporary object is introduced
+if needed
 [[dcl.type]], [[lex.literal]], [[lex.string]], [[dcl.array]], [[class.temporary]].
 In addition, it is possible to modify the values of non-constant objects
 through pointer parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
 function-to-pointer [[conv.func]] standard conversions are performed on
 the argument expression. An argument that has type cv `std::nullptr_t`
 is converted to type `void*` [[conv.ptr]]. After these conversions, if
 the argument does not have arithmetic, enumeration, pointer,
 pointer-to-member, or class type, the program is ill-formed. Passing a
+potentially-evaluated argument of a scoped enumeration type [[dcl.enum]]
+or of a class type [[class]] having an eligible non-trivial copy
+constructor [[special]], [[class.copy.ctor]], an eligible non-trivial
+move constructor, or a non-trivial destructor [[class.dtor]], with no
+corresponding parameter, is conditionally-supported with
+*implementation-defined* semantics. If the argument has integral or
 enumeration type that is subject to the integral promotions
 [[conv.prom]], or a floating-point type that is subject to the
 floating-point promotion [[conv.fpprom]], the value of the argument is
 converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
 Recursive calls are permitted, except to the `main` function
 [[basic.start.main]].
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
+type is an rvalue reference to object type, and a prvalue otherwise. If
+it is a non-void prvalue, the type of the function call expression shall
+be complete, except as specified in [[dcl.type.decltype]].

Diff to HTML by rtfpessoa