[expr.prim.lambda.closure] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpba2gqdv7/{from.md → to.md} +111 -55

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

@@ -2,38 +2,46 @@
 The type of a *lambda-expression* (which is also the type of the closure
 object) is a unique, unnamed non-union class type, called the *closure
 type*, whose properties are described below.
 The closure type is declared in the smallest block scope, class scope,
 or namespace scope that contains the corresponding *lambda-expression*.
 [*Note 1*: This determines the set of namespaces and classes associated
 with the closure type [[basic.lookup.argdep]]. The parameter types of a
 *lambda-declarator* do not affect these associated namespaces and
 classes. — *end note*]
-The closure type is not an aggregate type [[dcl.init.aggr]]. An
-implementation may define the closure type differently from what is
-described below provided this does not alter the observable behavior of
-the program other than by changing:
 - the size and/or alignment of the closure type,
-- whether the closure type is trivially copyable [[class.prop]], or
 - whether the closure type is a standard-layout class [[class.prop]].
 An implementation shall not add members of rvalue reference type to the
 closure type.
 The closure type for a *lambda-expression* has a public inline function
 call operator (for a non-generic lambda) or function call operator
 template (for a generic lambda) [[over.call]] whose parameters and
-return type are described by the *lambda-expression*’s
 *parameter-declaration-clause* and *trailing-return-type* respectively,
 and whose *template-parameter-list* consists of the specified
-*template-parameter-list*, if any. The *requires-clause* of the function
-call operator template is the *requires-clause* immediately following
 `<` *template-parameter-list* `>`, if any. The trailing
 *requires-clause* of the function call operator or operator template is
 the *requires-clause* of the *lambda-declarator*, if any.
 [*Note 2*: The function call operator template for a generic lambda can
@@ -70,11 +78,12 @@ std::cout << fact(5);                                           // OK, outputs 1
 Given a lambda with a *lambda-capture*, the type of the explicit object
 parameter, if any, of the lambda’s function call operator (possibly
 instantiated from a function call operator template) shall be either:
 - the closure type,
-- a class type derived from the closure type, or
 - a reference to a possibly cv-qualified such type.
 [*Example 2*:
 ``` cpp
@@ -98,13 +107,14 @@ function or static member function template [[class.static.mfct]] if the
 `static`. Otherwise, it is a non-static member function or member
 function template [[class.mfct.non.static]] that is declared `const`
 [[class.mfct.non.static]] if and only if the *lambda-expression*’s
 *parameter-declaration-clause* is not followed by `mutable` and the
 *lambda-declarator* does not contain an explicit object parameter. It is
-neither virtual nor declared `volatile`. Any *noexcept-specifier*
-specified on a *lambda-expression* applies to the corresponding function
-call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-declarator* appertains to the type of the corresponding function
 call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-expression* preceding a *lambda-declarator* appertains to the
 corresponding function call operator or operator template. The function
 call operator or any given operator template specialization is a
@@ -183,35 +193,80 @@ auto f = []<typename T1, C1 T2> requires C2<sizeof(T1) + sizeof(T2)>
 — *end example*]
 — *end note*]
 The closure type for a non-generic *lambda-expression* with no
-*lambda-capture* whose constraints (if any) are satisfied has a
-conversion function to pointer to function with C++ language linkage
-[[dcl.link]] having the same parameter and return types as the closure
-type’s function call operator. The conversion is to “pointer to
-`noexcept` function” if the function call operator has a non-throwing
-exception specification. If the function call operator is a static
-member function, then the value returned by this conversion function is
-the address of the function call operator. Otherwise, the value returned
-by this conversion function is the address of a function `F` that, when
-invoked, has the same effect as invoking the closure type’s function
-call operator on a default-constructed instance of the closure type. `F`
-is a constexpr function if the function call operator is a constexpr
-function and is an immediate function if the function call operator is
-an immediate function.
-For a generic lambda with no *lambda-capture*, the closure type has a
-conversion function template to pointer to function. The conversion
-function template has the same invented template parameter list, and the
-pointer to function has the same parameter types, as the function call
-operator template. The return type of the pointer to function shall
-behave as if it were a *decltype-specifier* denoting the return type of
-the corresponding function call operator template specialization.
-[*Note 4*:
 If the generic lambda has no *trailing-return-type* or the
 *trailing-return-type* contains a placeholder type, return type
 deduction of the corresponding function call operator template
 specialization has to be done. The corresponding specialization is that
@@ -243,11 +298,11 @@ struct Closure {
 };
 ```
 — *end note*]
-[*Example 6*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
@@ -267,27 +322,26 @@ int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; };        // OK
 — *end example*]
 If the function call operator template is a static member function
 template, then the value returned by any given specialization of this
-conversion function template is the address of the corresponding
-function call operator template specialization. Otherwise, the value
-returned by any given specialization of this conversion function
-template is the address of a function `F` that, when invoked, has the
-same effect as invoking the generic lambda’s corresponding function call
-operator template specialization on a default-constructed instance of
-the closure type. `F` is a constexpr function if the corresponding
-specialization is a constexpr function and `F` is an immediate function
-if the function call operator template specialization is an immediate
-function.
-[*Note 5*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
-parameter types are required to match the return type and parameter
-types of the pointer to function. — *end note*]
-[*Example 7*:
 ``` cpp
 auto GL = [](auto a) { std::cout << a; return a; };
 int (*GL_int)(int) = GL;        // OK, through conversion function template
 GL_int(3);                      // OK, same as GL(3)
@@ -297,11 +351,11 @@ GL_int(3);                      // OK, same as GL(3)
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing
 exception specification [[except.spec]].
-[*Example 8*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
@@ -316,11 +370,11 @@ static_assert(Fwd(NC,3) == 3);  // error
 The *lambda-expression*’s *compound-statement* yields the
 *function-body* [[dcl.fct.def]] of the function call operator, but it is
 not within the scope of the closure type.
-[*Example 9*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
@@ -333,23 +387,25 @@ struct S1 {
 };
 ```
 — *end example*]
-Further, a variable `__func__` is implicitly defined at the beginning of
-the *compound-statement* of the *lambda-expression*, with semantics as
-described in  [[dcl.fct.def.general]].
 The closure type associated with a *lambda-expression* has no default
 constructor if the *lambda-expression* has a *lambda-capture* and a
 defaulted default constructor otherwise. It has a defaulted copy
 constructor and a defaulted move constructor [[class.copy.ctor]]. It has
 a deleted copy assignment operator if the *lambda-expression* has a
 *lambda-capture* and defaulted copy and move assignment operators
 otherwise [[class.copy.assign]].
-[*Note 6*: These special member functions are implicitly defined as
 usual, which can result in them being defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].

 The type of a *lambda-expression* (which is also the type of the closure
 object) is a unique, unnamed non-union class type, called the *closure
 type*, whose properties are described below.
+The closure type is incomplete until the end of its corresponding
+*compound-statement*.
 The closure type is declared in the smallest block scope, class scope,
 or namespace scope that contains the corresponding *lambda-expression*.
 [*Note 1*: This determines the set of namespaces and classes associated
 with the closure type [[basic.lookup.argdep]]. The parameter types of a
 *lambda-declarator* do not affect these associated namespaces and
 classes. — *end note*]
+The closure type is not an aggregate type [[dcl.init.aggr]]; it is a
+structural type [[term.structural.type]] if and only if the lambda has
+no *lambda-capture*. An implementation may define the closure type
+differently from what is described below provided this does not alter
+the observable behavior of the program other than by changing:
 - the size and/or alignment of the closure type,
+- whether the closure type is trivially copyable [[class.prop]],
+- whether the closure type is trivially relocatable [[class.prop]],
+- whether the closure type is replaceable [[class.prop]], or
 - whether the closure type is a standard-layout class [[class.prop]].
 An implementation shall not add members of rvalue reference type to the
 closure type.
 The closure type for a *lambda-expression* has a public inline function
 call operator (for a non-generic lambda) or function call operator
 template (for a generic lambda) [[over.call]] whose parameters and
+return type are those of the *lambda-expression*'s
 *parameter-declaration-clause* and *trailing-return-type* respectively,
 and whose *template-parameter-list* consists of the specified
+*template-parameter-list*, if any. The function call operator or the
+function call operator template are direct members of the closure type.
+The *requires-clause* of the function call operator template is the
+*requires-clause* immediately following
 `<` *template-parameter-list* `>`, if any. The trailing
 *requires-clause* of the function call operator or operator template is
 the *requires-clause* of the *lambda-declarator*, if any.
 [*Note 2*: The function call operator template for a generic lambda can
 Given a lambda with a *lambda-capture*, the type of the explicit object
 parameter, if any, of the lambda’s function call operator (possibly
 instantiated from a function call operator template) shall be either:
 - the closure type,
+- a class type publicly and unambiguously derived from the closure type,
+  or
 - a reference to a possibly cv-qualified such type.
 [*Example 2*:
 ``` cpp
 `static`. Otherwise, it is a non-static member function or member
 function template [[class.mfct.non.static]] that is declared `const`
 [[class.mfct.non.static]] if and only if the *lambda-expression*’s
 *parameter-declaration-clause* is not followed by `mutable` and the
 *lambda-declarator* does not contain an explicit object parameter. It is
+neither virtual nor declared `volatile`. Any *noexcept-specifier* or
+*function-contract-specifier* [[dcl.contract.func]] specified on a
+*lambda-expression* applies to the corresponding function call operator
+or operator template. An *attribute-specifier-seq* in a
 *lambda-declarator* appertains to the type of the corresponding function
 call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-expression* preceding a *lambda-declarator* appertains to the
 corresponding function call operator or operator template. The function
 call operator or any given operator template specialization is a
 — *end example*]
 — *end note*]
+If all potential references to a local entity implicitly captured by a
+*lambda-expression* L occur within the function contract assertions
+[[dcl.contract.func]] of the call operator or operator template of L or
+within *assertion-statement*s [[stmt.contract.assert]] within the body
+of L, the program is ill-formed.
+[*Note 4*: Adding a contract assertion to an existing C++ program
+cannot cause additional captures. — *end note*]
+[*Example 6*:
+``` cpp
+static int i = 0;
+void test() {
+  auto f1 = [=] pre(i > 0) {};  // OK, no local entities are captured.
+  int i = 1;
+  auto f2 = [=] pre(i > 0) {};  // error: cannot implicitly capture i here
+  auto f3 = [i] pre(i > 0) {};  // OK, i is captured explicitly.
+  auto f4 = [=] {
+    contract_assert(i > 0);     // error: cannot implicitly capture i here
+  };
+  auto f5 = [=] {
+    contract_assert(i > 0);     // OK, i is referenced elsewhere.
+    (void)i;
+  };
+  auto f6 = [=] pre(                // #1
+    []{
+      bool x = true;
+      return [=]{ return x; }();    // OK, #1 captures nothing.
+    }()) {};
+  bool y = true;
+  auto f7 = [=] pre([=]{ return y; }());    // error: outer capture of y is invalid.
+}
+```
+— *end example*]
 The closure type for a non-generic *lambda-expression* with no
+*lambda-capture* and no explicit object parameter [[dcl.fct]] whose
+constraints (if any) are satisfied has a conversion function to pointer
+to function with C++ language linkage [[dcl.link]] having the same
+parameter and return types as the closure type’s function call operator.
+The conversion is to “pointer to `noexcept` function” if the function
+call operator has a non-throwing exception specification. If the
+function call operator is a static member function, then the value
+returned by this conversion function is a pointer to the function call
+operator. Otherwise, the value returned by this conversion function is a
+pointer to a function `F` that, when invoked, has the same effect as
+invoking the closure type’s function call operator on a
+default-constructed instance of the closure type. `F` is a constexpr
+function if the function call operator is a constexpr function and is an
+immediate function if the function call operator is an immediate
+function.
+For a generic lambda with no *lambda-capture* and no explicit object
+parameter [[dcl.fct]], the closure type has a conversion function
+template to pointer to function. The conversion function template has
+the same invented template parameter list, and the pointer to function
+has the same parameter types, as the function call operator template.
+The return type of the pointer to function shall behave as if it were a
+*decltype-specifier* denoting the return type of the corresponding
+function call operator template specialization.
+[*Note 5*:
 If the generic lambda has no *trailing-return-type* or the
 *trailing-return-type* contains a placeholder type, return type
 deduction of the corresponding function call operator template
 specialization has to be done. The corresponding specialization is that
 };
 ```
 — *end note*]
+[*Example 7*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 — *end example*]
 If the function call operator template is a static member function
 template, then the value returned by any given specialization of this
+conversion function template is a pointer to the corresponding function
+call operator template specialization. Otherwise, the value returned by
+any given specialization of this conversion function template is a
+pointer to a function `F` that, when invoked, has the same effect as
+invoking the generic lambda’s corresponding function call operator
+template specialization on a default-constructed instance of the closure
+type. `F` is a constexpr function if the corresponding specialization is
+a constexpr function and `F` is an immediate function if the function
+call operator template specialization is an immediate function.
+[*Note 6*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
+parameter types need to match the return type and parameter types of the
+pointer to function. — *end note*]
+[*Example 8*:
 ``` cpp
 auto GL = [](auto a) { std::cout << a; return a; };
 int (*GL_int)(int) = GL;        // OK, through conversion function template
 GL_int(3);                      // OK, same as GL(3)
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing
 exception specification [[except.spec]].
+[*Example 9*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
 The *lambda-expression*’s *compound-statement* yields the
 *function-body* [[dcl.fct.def]] of the function call operator, but it is
 not within the scope of the closure type.
+[*Example 10*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
 };
 ```
 — *end example*]
+Unless the *compound-statement* is that of a
+*consteval-block-declaration* [[dcl.pre]], a variable `__func__` is
+implicitly defined at the beginning of the *compound-statement* of the
+*lambda-expression*, with semantics as described in
+[[dcl.fct.def.general]].
 The closure type associated with a *lambda-expression* has no default
 constructor if the *lambda-expression* has a *lambda-capture* and a
 defaulted default constructor otherwise. It has a defaulted copy
 constructor and a defaulted move constructor [[class.copy.ctor]]. It has
 a deleted copy assignment operator if the *lambda-expression* has a
 *lambda-capture* and defaulted copy and move assignment operators
 otherwise [[class.copy.assign]].
+[*Note 7*: These special member functions are implicitly defined as
 usual, which can result in them being defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].

Diff to HTML by rtfpessoa