P2579R0 Mitigation strategies for P2036 "Changing scope for lambda trailing-return-type"

Author: jensmaurer

source/basic.tex

@@ -1286,6 +1286,12 @@
 its scope extends to the end of the \grammarterm{deduction-guide}.
 \end{itemize}
 
+\rSec2[basic.scope.lambda]{Lambda scope}
+
+A \grammarterm{lambda-expression} \tcode{E} introduces a \defnadj{lambda}{scope}
+that starts immediately after the \grammarterm{lambda-introducer} of \tcode{E}
+and extends to the end of the \grammarterm{compound-statement} of \tcode{E}.
+
 \rSec2[basic.scope.namespace]{Namespace scope}
 
 \pnum

source/expressions.tex

@@ -1473,10 +1473,11 @@
 If naming the entity from outside of an unevaluated operand within $S$
 would refer to an entity
 captured by copy in some intervening \grammarterm{lambda-expression},
-then let $E$ be the innermost such \grammarterm{lambda-expression}, and:
+then let $E$ be the innermost such \grammarterm{lambda-expression}.
 \begin{itemize}
 \item
-If $P$ is in $E$'s function parameter scope
+If there is such a \grammarterm{lambda-expression} and
+if $P$ is in $E$'s function parameter scope
 but not its \grammarterm{parameter-declaration-clause}, then
 the type of the expression is
 the type of a class member access expression\iref{expr.ref}
@@ -1488,11 +1489,11 @@
 the type of such an identifier will typically be \keyword{const} qualified.
 \end{note}
 \item
-Otherwise (if $P$ either precedes $E$'s function parameter scope or
+Otherwise (if there is no such \grammarterm{lambda-expression} or
+if $P$ either precedes $E$'s function parameter scope or
 is in $E$'s \grammarterm{parameter-declaration-clause}),
-the program is ill-formed.
+the type of the expression is the type of the result.
 \end{itemize}
-Otherwise, the type of the expression is the type of the result.
 \begin{note}
 If the entity is a template parameter object for
 a template parameter of type \tcode{T}\iref{temp.param},
@@ -1521,15 +1522,14 @@
     return y2;
   };
 
-  [=]<decltype(x) P>{};         // error: \tcode{x} refers to local entity but precedes the
-                                // lambda's function parameter scope
-  [=](decltype((x)) y){};       // error: \tcode{x} refers to local entity but is in the lambda's
-                                // \grammarterm{parameter-declaration-clause}
+  [=](decltype((x)) y){
+    decltype((x)) z = x;        // OK, \tcode{y} has type \tcode{float\&}, \tcode{z} has type \tcode{float const\&}
+  };
   [=]{
-      []<decltype(x) P>{};      // OK, \tcode{x} is in the outer lambda's function parameter scope
       [](decltype((x)) y){};    // OK, lambda takes a parameter of type \tcode{float const\&}
-      [x=1](decltype((x)) z){}; // error: \tcode{x} refers to \grammarterm{init-capture} but is in the lambda's
-                                // \grammarterm{parameter-declaration-clause}
+      [x=1](decltype((x)) z){
+        decltype((x)) z = x;    // OK, \tcode{y} has type \tcode{int\&}, \tcode{z} has type \tcode{int const\&}
+      };
   };
 }
 \end{codeblock}
@@ -2310,22 +2310,26 @@
 is said to be \defn{explicitly captured}.
 
 \pnum
-If an \grammarterm{identifier} in a \grammarterm{simple-capture} appears
+If an \grammarterm{identifier} in a \grammarterm{capture} appears
 as the \grammarterm{declarator-id} of a parameter of
-the \grammarterm{lambda-declarator}{'s} \grammarterm{parameter-declaration-clause},
+the \grammarterm{lambda-declarator}'s \grammarterm{parameter-declaration-clause}
+or as the name of a template parameter of
+the \grammarterm{lambda-expression}'s \grammarterm{template-parameter-list},
 the program is ill-formed.
 \begin{example}
 \begin{codeblock}
 void f() {
   int x = 0;
-  auto g = [x](int x) { return 0; };    // error: parameter and \grammarterm{simple-capture} have the same name
+  auto g = [x](int x) { return 0; };    // error: parameter and \grammarterm{capture} have the same name
+  auto h = [y = 0]<typename y>(y) { return 0; };    // error: template parameter and \grammarterm{capture}
+                                                    // have the same name
 }
 \end{codeblock}
 \end{example}
 
 \pnum
-An \grammarterm{init-capture} inhabits the function parameter scope of
-the \grammarterm{lambda-expression}'s \grammarterm{parameter-declaration-clause}.
+An \grammarterm{init-capture} inhabits
+the lambda scope of the \grammarterm{lambda-expression}.
 An \grammarterm{init-capture} without ellipsis
 behaves as if it declares and explicitly captures a variable of
 the form ``\keyword{auto} \grammarterm{init-capture} \tcode{;}'', except that: