Review

Author: StanFromIreland

peps/pep-0679.rst

@@ -15,16 +15,15 @@ Abstract
 
 This PEP proposes allowing parentheses in the two-argument form of :keyword:`assert`.
 The interpreter will reinterpret ``assert (expr, msg)`` as ``assert expr, msg``,
-eliminating the common `footgun <https://en.wiktionary.org/wiki/footgun>`_
-where such code was previously treated as asserting a two-element :class:`tuple`,
-which is always truthy.
+eliminating the common pitfall where such code was previously treated as
+asserting a two-element :class:`tuple`, which is always truthy.
 
 
 Motivation
 ==========
 
 It is a common user mistake when using the form of the :keyword:`assert`
-statement that includes the error message to surround it with parentheses [#SO1]_.
+statement that includes the error message to surround it with parentheses [#SO1]_ [#RD]_.
 This is because many beginners assume :keyword:`!assert` is a function.
 The prominent :mod:`unittest` methods, particularly :meth:`~unittest.TestCase.assertTrue`,
 also require parentheses around the assertion and message.
@@ -43,7 +42,7 @@ Additionally, some other statements in the language allow parenthesized forms
 in one way or another, for example, ``import`` statements
 (``from x import (a,b,c)``) or ``del`` statements (``del (a,b,c)``).
 
-Allowing parentheses not only will remove the footgun but also will allow
+Allowing parentheses not only will remove the pitfall but also will allow
 users and auto-formatters to format long assert statements over multiple lines
 in what the authors of this document believe will be a more natural way.
 Although it is possible to currently format long :keyword:`assert` statements
@@ -99,13 +98,17 @@ Specification
 
 The formal grammar of the :keyword:`assert` statement will change to:
 
-.. code-block:: bnf
+.. code-block::
 
-    assert_stmt ::= "assert" expression [',' expression]
-                    | "assert" '(' expression [',' expression] [','] ')'
+    | 'assert' '(' expression ',' expression [','] ')' &(NEWLINE | ';')
+    | 'assert' a=expression [',' expression ]
 
 
-The second case will raise a :exc:`SyntaxWarning` till 3.17.
+Where the first line is the new form of the assert statement that allows
+parentheses and will raise a :exc:`SyntaxWarning` till 3.17..
+The lookahead is needed so statements like ``assert (a, b) <= c, "something"``
+are still parsed correctly and to prevent the parser to eagerly capture the
+tuple as the full statement.
 
 Optionally, a new "invalid" grammar rule can be added to the parser to
 promote the current :exc:`SyntaxWarning` to a :exc:`SyntaxError` in the
@@ -147,6 +150,8 @@ with a ``paren_syntax`` flag::
                 msg=Constant(value='Error message'),
                 paren_syntax=1)])
 
+The flag would be removed in 3.18 along with the :exc:`SyntaxWarning`.
+
 
 Implementing in the compiler
 ----------------------------
@@ -175,10 +180,9 @@ On the other hand, assert statements of this kind always pass, so they are
 effectively not doing anything in user code. The authors of this document think
 that this backwards incompatibility nature is beneficial, as it will highlight
 these cases in user code while before they will have passed unnoticed. This case
-has already raised a :exc:`SyntaxWarning` since Python 3.10, therefore these
-cases are expected to be rare, as they require users to ignore existing
-syntax warnings. The continued raising of a :exc:`!SyntaxWarning` should
-mitigate surprises.
+has already raised a :exc:`SyntaxWarning` since Python 3.10, so there has been
+a deprecation period of over 5 years.
+The continued raising of a :exc:`!SyntaxWarning` should mitigate surprises.
 
 The change will also result in changes to the AST of ``assert (x,y)``,
 which currently is:
@@ -263,7 +267,7 @@ the case where they appear in parentheses, which already raises a
 :exc:`SyntaxWarning`.
 
 The authors of this PEP believe that adding a completely new syntax will,
-first and foremost, not solve the common beginner footgun that this PEP aims to
+first and foremost, not solve the common beginner pitfall that this PEP aims to
 patch, and will not improve the formatting of assert statements across multiple
 lines, which the authors believe the proposed syntax improves.
 
@@ -286,6 +290,7 @@ Footnotes
 =========
 
 .. [#SO1] `StackOverflow: "'assert' statement with or without parentheses" <https://stackoverflow.com/questions/3112171/assert-statement-with-or-without-parentheses>`_
+.. [#RD] `/r/python: "Rant: use that second expression in assert! " <https://www.reddit.com/r/Python/comments/1n87g91/rant_use_that_second_expression_in_assert/>`_
 .. [#fl8] `flake8: Rule F631 <https://flake8.pycqa.org/en/latest/user/error-codes.html>`_
 .. [#pylint] `pylint: assert-on-tuple (W0199) <https://pylint.pycqa.org/en/latest/user_guide/checkers/features.html>`_
 .. [#previmp] For the previous parser implementation, see :cpython-pr:`30247`