[expr.prim.lambda.capture] - C++20 → C++23

Files changed (1) hide show

tmp/tmpoex98vh9/{from.md → to.md} +43 -38

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

@@ -37,13 +37,12 @@ simple-capture:
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
-The body of a *lambda-expression* may refer to variables with automatic
-storage duration and the `*this` object (if any) of enclosing block
-scopes by capturing those entities, as described below.
 If a *lambda-capture* includes a *capture-default* that is `&`, no
 identifier in a *simple-capture* of that *lambda-capture* shall be
 preceded by `&`. If a *lambda-capture* includes a *capture-default* that
 is `=`, each *simple-capture* of that *lambda-capture* shall be of the
@@ -76,35 +75,37 @@ A *lambda-expression* shall not have a *capture-default* or
 *simple-capture* in its *lambda-introducer* unless its innermost
 enclosing scope is a block scope [[basic.scope.block]] or it appears
 within a default member initializer and its innermost enclosing scope is
 the corresponding class scope [[basic.scope.class]].
-The *identifier* in a *simple-capture* is looked up using the usual
-rules for unqualified name lookup [[basic.lookup.unqual]]; each such
-lookup shall find a local entity. The *simple-capture*s `this` and
 `* this` denote the local entity `*this`. An entity that is designated
 by a *simple-capture* is said to be *explicitly captured*.
-If an *identifier* in a *simple-capture* appears as the *declarator-id*
-of a parameter of the *lambda-declarator*'s
-*parameter-declaration-clause*, the program is ill-formed.
 [*Example 2*:
 ``` cpp
 void f() {
   int x = 0;
-  auto g = [x](int x) { return 0; };    // error: parameter and simple-capture have the same name
 }
 ```
 — *end example*]
-An *init-capture* without ellipsis behaves as if it declares and
-explicitly captures a variable of the form “`auto` *init-capture* `;`”
-whose declarative region is the *lambda-expression*’s
-*compound-statement*, except that:
 - if the capture is by copy (see below), the non-static data member
   declared for the capture and the variable are treated as two different
   ways of referring to the same object, which has the lifetime of the
   non-static data member, and no additional copy and destruction is
@@ -123,11 +124,14 @@ int x = 4;
 auto y = [&r = x, x = x+1]()->int {
             r += 2;
             return x+2;
          }();                               // Updates ::x to 6, and initializes y to 7.
-auto z = [a = 42](int a) { return 1; };     // error: parameter and local variable have the same name
 ```
 — *end example*]
 For the purposes of lambda capture, an expression potentially references
@@ -141,13 +145,13 @@ local entities as follows:
   *id-expression*. — *end note*]
 - A `this` expression potentially references `*this`.
 - A *lambda-expression* potentially references the local entities named
   by its *simple-capture*s.
-If an expression potentially references a local entity within a
-declarative region in which it is odr-usable, and the expression would
-be potentially evaluated if the effect of any enclosing `typeid`
 expressions [[expr.typeid]] were ignored, the entity is said to be
 *implicitly captured* by each intervening *lambda-expression* with an
 associated *capture-default* that does not explicitly capture it. The
 implicit capture of `*this` is deprecated when the *capture-default* is
 `=`; see [[depr.capture.this]].
@@ -158,38 +162,38 @@ implicit capture of `*this` is deprecated when the *capture-default* is
 void f(int, const int (&)[2] = {});         // #1
 void f(const int&, const int (&)[1]);       // #2
 void test() {
   const int x = 17;
   auto g = [](auto a) {
-    f(x);                       // OK: calls #1, does not capture x
   };
   auto g1 = [=](auto a) {
-    f(x);                       // OK: calls #1, captures x
   };
   auto g2 = [=](auto a) {
     int selector[sizeof(a) == 1 ? 1 : 2]{};
-    f(x, selector);             // OK: captures x, might call #1 or #2
   };
   auto g3 = [=](auto a) {
     typeid(a + x);              // captures x regardless of whether a + x is an unevaluated operand
   };
 }
 ```
-Within `g1`, an implementation might optimize away the capture of `x` as
 it is not odr-used.
 — *end example*]
 [*Note 4*:
 The set of captured entities is determined syntactically, and entities
-might be implicitly captured even if the expression denoting a local
-entity is within a discarded statement [[stmt.if]].
 [*Example 5*:
 ``` cpp
 template<bool B>
@@ -205,12 +209,12 @@ void f(int n) {
 — *end example*]
 — *end note*]
 An entity is *captured* if it is captured explicitly or implicitly. An
-entity captured by a *lambda-expression* is odr-used [[basic.def.odr]]
-in the scope containing the *lambda-expression*.
 [*Note 5*: As a consequence, if a *lambda-expression* explicitly
 captures an entity that is not odr-usable, the program is ill-formed
 [[basic.def.odr]]. — *end note*]
@@ -220,26 +224,26 @@ captures an entity that is not odr-usable, the program is ill-formed
 void f1(int i) {
   int const N = 20;
   auto m1 = [=]{
     int const M = 30;
     auto m2 = [i]{
-      int x[N][M];              // OK: N and M are not odr-used
-      x[0][0] = i;              // OK: i is explicitly captured by m2 and implicitly captured by m1
     };
   };
   struct s1 {
     int f;
     void work(int n) {
       int m = n*n;
       int j = 40;
       auto m3 = [this,m] {
         auto m4 = [&,j] {       // error: j not odr-usable due to intervening lambda m3
           int x = n;            // error: n is odr-used but not odr-usable due to intervening lambda m3
-          x += m;               // OK: m implicitly captured by m4 and explicitly captured by m3
           x += i;               // error: i is odr-used but not odr-usable
                                 // due to intervening function and class scopes
-          x += f;               // OK: this captured implicitly by m4 and explicitly by m3
         };
       };
     }
   };
 }
@@ -302,11 +306,11 @@ the entity is a reference to an object, an lvalue reference to the
 referenced function type if the entity is a reference to a function, or
 the type of the corresponding captured entity otherwise. A member of an
 anonymous union shall not be captured by copy.
 Every *id-expression* within the *compound-statement* of a
-*lambda-expression* that is an odr-use [[basic.def.odr]] of an entity
 captured by copy is transformed into an access to the corresponding
 unnamed data member of the closure type.
 [*Note 7*: An *id-expression* that is not an odr-use refers to the
 original entity, never to a member of the closure type. However, such an
@@ -322,12 +326,12 @@ the closure type.
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
-    int arr[N];     // OK: not an odr-use, refers to automatic variable
-    f(&N);          // OK: causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```
@@ -375,13 +379,15 @@ auto h(int &r) {
 If a *lambda-expression* `m2` captures an entity and that entity is
 captured by an immediately enclosing *lambda-expression* `m1`, then
 `m2`’s capture is transformed as follows:
-- if `m1` captures the entity by copy, `m2` captures the corresponding
-  non-static data member of `m1`’s closure type;
-- if `m1` captures the entity by reference, `m2` captures the same
   entity captured by `m1`.
 [*Example 11*:
 The nested *lambda-expression*s and invocations below will output
@@ -422,12 +428,11 @@ captured by reference, invoking the function call operator of the
 corresponding *lambda-expression* after the lifetime of the entity has
 ended is likely to result in undefined behavior. — *end note*]
 A *simple-capture* containing an ellipsis is a pack expansion
 [[temp.variadic]]. An *init-capture* containing an ellipsis is a pack
-expansion that introduces an *init-capture* pack [[temp.variadic]] whose
-declarative region is the *lambda-expression*’s *compound-statement*.
 [*Example 12*:
 ``` cpp
 template<class... Args>

 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
+The body of a *lambda-expression* may refer to local entities of
+enclosing block scopes by capturing those entities, as described below.
 If a *lambda-capture* includes a *capture-default* that is `&`, no
 identifier in a *simple-capture* of that *lambda-capture* shall be
 preceded by `&`. If a *lambda-capture* includes a *capture-default* that
 is `=`, each *simple-capture* of that *lambda-capture* shall be of the
 *simple-capture* in its *lambda-introducer* unless its innermost
 enclosing scope is a block scope [[basic.scope.block]] or it appears
 within a default member initializer and its innermost enclosing scope is
 the corresponding class scope [[basic.scope.class]].
+The *identifier* in a *simple-capture* shall denote a local entity
+[[basic.lookup.unqual]], [[basic.pre]]. The *simple-capture*s `this` and
 `* this` denote the local entity `*this`. An entity that is designated
 by a *simple-capture* is said to be *explicitly captured*.
+If an *identifier* in a *capture* appears as the *declarator-id* of a
+parameter of the *lambda-declarator*’s *parameter-declaration-clause* or
+as the name of a template parameter of the *lambda-expression*’s
+*template-parameter-list*, the program is ill-formed.
 [*Example 2*:
 ``` cpp
 void f() {
   int x = 0;
+  auto g = [x](int x) { return 0; };    // error: parameter and capture have the same name
+  auto h = [y = 0]<typename y>(y) { return 0; };    // error: template parameter and capture
+                                                    // have the same name
 }
 ```
 — *end example*]
+An *init-capture* inhabits the lambda scope [[basic.scope.lambda]] of
+the *lambda-expression*. An *init-capture* without ellipsis behaves as
+if it declares and explicitly captures a variable of the form “`auto`
+*init-capture* `;`”, except that:
 - if the capture is by copy (see below), the non-static data member
   declared for the capture and the variable are treated as two different
   ways of referring to the same object, which has the lifetime of the
   non-static data member, and no additional copy and destruction is
 auto y = [&r = x, x = x+1]()->int {
             r += 2;
             return x+2;
          }();                               // Updates ::x to 6, and initializes y to 7.
+auto z = [a = 42](int a) { return 1; };     // error: parameter and conceptual local variable have the same name
+auto counter = [i=0]() mutable -> decltype(i) {     // OK, returns int
+  return i++;
+};
 ```
 — *end example*]
 For the purposes of lambda capture, an expression potentially references
   *id-expression*. — *end note*]
 - A `this` expression potentially references `*this`.
 - A *lambda-expression* potentially references the local entities named
   by its *simple-capture*s.
+If an expression potentially references a local entity within a scope in
+which it is odr-usable [[basic.def.odr]], and the expression would be
+potentially evaluated if the effect of any enclosing `typeid`
 expressions [[expr.typeid]] were ignored, the entity is said to be
 *implicitly captured* by each intervening *lambda-expression* with an
 associated *capture-default* that does not explicitly capture it. The
 implicit capture of `*this` is deprecated when the *capture-default* is
 `=`; see [[depr.capture.this]].
 void f(int, const int (&)[2] = {});         // #1
 void f(const int&, const int (&)[1]);       // #2
 void test() {
   const int x = 17;
   auto g = [](auto a) {
+    f(x);                       // OK, calls #1, does not capture x
   };
   auto g1 = [=](auto a) {
+    f(x);                       // OK, calls #1, captures x
   };
   auto g2 = [=](auto a) {
     int selector[sizeof(a) == 1 ? 1 : 2]{};
+    f(x, selector);             // OK, captures x, can call #1 or #2
   };
   auto g3 = [=](auto a) {
     typeid(a + x);              // captures x regardless of whether a + x is an unevaluated operand
   };
 }
 ```
+Within `g1`, an implementation can optimize away the capture of `x` as
 it is not odr-used.
 — *end example*]
 [*Note 4*:
 The set of captured entities is determined syntactically, and entities
+are implicitly captured even if the expression denoting a local entity
+is within a discarded statement [[stmt.if]].
 [*Example 5*:
 ``` cpp
 template<bool B>
 — *end example*]
 — *end note*]
 An entity is *captured* if it is captured explicitly or implicitly. An
+entity captured by a *lambda-expression* is odr-used [[term.odr.use]] by
+the *lambda-expression*.
 [*Note 5*: As a consequence, if a *lambda-expression* explicitly
 captures an entity that is not odr-usable, the program is ill-formed
 [[basic.def.odr]]. — *end note*]
 void f1(int i) {
   int const N = 20;
   auto m1 = [=]{
     int const M = 30;
     auto m2 = [i]{
+      int x[N][M];              // OK, N and M are not odr-used
+      x[0][0] = i;              // OK, i is explicitly captured by m2 and implicitly captured by m1
     };
   };
   struct s1 {
     int f;
     void work(int n) {
       int m = n*n;
       int j = 40;
       auto m3 = [this,m] {
         auto m4 = [&,j] {       // error: j not odr-usable due to intervening lambda m3
           int x = n;            // error: n is odr-used but not odr-usable due to intervening lambda m3
+          x += m;               // OK, m implicitly captured by m4 and explicitly captured by m3
           x += i;               // error: i is odr-used but not odr-usable
                                 // due to intervening function and class scopes
+          x += f;               // OK, this captured implicitly by m4 and explicitly by m3
         };
       };
     }
   };
 }
 referenced function type if the entity is a reference to a function, or
 the type of the corresponding captured entity otherwise. A member of an
 anonymous union shall not be captured by copy.
 Every *id-expression* within the *compound-statement* of a
+*lambda-expression* that is an odr-use [[term.odr.use]] of an entity
 captured by copy is transformed into an access to the corresponding
 unnamed data member of the closure type.
 [*Note 7*: An *id-expression* that is not an odr-use refers to the
 original entity, never to a member of the closure type. However, such an
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
+    int arr[N];     // OK, not an odr-use, refers to automatic variable
+    f(&N);          // OK, causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```
 If a *lambda-expression* `m2` captures an entity and that entity is
 captured by an immediately enclosing *lambda-expression* `m1`, then
 `m2`’s capture is transformed as follows:
+- If `m1` captures the entity by copy, `m2` captures the corresponding
+  non-static data member of `m1`’s closure type; if `m1` is not
+ `mutable`, the non-static data member is considered to be
+  const-qualified.
+- If `m1` captures the entity by reference, `m2` captures the same
   entity captured by `m1`.
 [*Example 11*:
 The nested *lambda-expression*s and invocations below will output
 corresponding *lambda-expression* after the lifetime of the entity has
 ended is likely to result in undefined behavior. — *end note*]
 A *simple-capture* containing an ellipsis is a pack expansion
 [[temp.variadic]]. An *init-capture* containing an ellipsis is a pack
+expansion that declares an *init-capture* pack [[temp.variadic]].
 [*Example 12*:
 ``` cpp
 template<class... Args>

Diff to HTML by rtfpessoa