bpo-42316: Allow unparenthesized walrus operator in indexes (GH-23317)

lysnikolaou · web-flow · commit cae60187cf7a · 2020-11-17T01:09:35.000+02:00
diff --git a/Grammar/python.gram b/Grammar/python.gram
@@ -491,7 +491,7 @@ slices[expr_ty]:
     | a[asdl_expr_seq*]=','.slice+ [','] { _Py_Tuple(a, Load, EXTRA) }
 slice[expr_ty]:
     | a=[expression] ':' b=[expression] c=[':' d=[expression] { d }] { _Py_Slice(a, b, c, EXTRA) }
-    | a=expression { a }
+    | a=named_expression { a }
 atom[expr_ty]:
     | NAME
     | 'True' { _Py_Constant(Py_True, NULL, EXTRA) }
diff --git a/Lib/test/test_named_expressions.py b/Lib/test/test_named_expressions.py
@@ -271,6 +271,27 @@ def test_named_expression_assignment_16(self):
         fib = {(c := a): (a := b) + (b := a + c) - b for __ in range(6)}
         self.assertEqual(fib, {1: 2, 2: 3, 3: 5, 5: 8, 8: 13, 13: 21})
 
+    def test_named_expression_assignment_17(self):
+        a = [1]
+        element = a[b:=0]
+        self.assertEqual(b, 0)
+        self.assertEqual(element, a[0])
+
+    def test_named_expression_assignment_18(self):
+        class TwoDimensionalList:
+            def __init__(self, two_dimensional_list):
+                self.two_dimensional_list = two_dimensional_list
+
+            def __getitem__(self, index):
+                return self.two_dimensional_list[index[0]][index[1]]
+
+        a = TwoDimensionalList([[1], [2]])
+        element = a[b:=0, c:=0]
+        self.assertEqual(b, 0)
+        self.assertEqual(c, 0)
+        self.assertEqual(element, a.two_dimensional_list[b][c])
+
+
 
 class NamedExpressionScopeTest(unittest.TestCase):
 
diff --git a/Misc/NEWS.d/next/Core and Builtins/2020-11-16-17-30-03.bpo-42316._DdmpQ.rst b/Misc/NEWS.d/next/Core and Builtins/2020-11-16-17-30-03.bpo-42316._DdmpQ.rst
@@ -0,0 +1 @@
+Allow an unparenthesized walrus in subscript indexes.
diff --git a/Parser/parser.c b/Parser/parser.c
@@ -10639,7 +10639,7 @@ slices_rule(Parser *p)
     return _res;
 }
 
-// slice: expression? ':' expression? [':' expression?] | expression
+// slice: expression? ':' expression? [':' expression?] | named_expression
 static expr_ty
 slice_rule(Parser *p)
 {
@@ -10701,18 +10701,18 @@ slice_rule(Parser *p)
         D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?]"));
     }
-    { // expression
+    { // named_expression
         if (p->error_indicator) {
             D(p->level--);
             return NULL;
         }
-        D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
+        D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
         expr_ty a;
         if (
-            (a = expression_rule(p))  // expression
+            (a = named_expression_rule(p))  // named_expression
         )
         {
-            D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
+            D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
             _res = a;
             if (_res == NULL && PyErr_Occurred()) {
                 p->error_indicator = 1;
@@ -10723,7 +10723,7 @@ slice_rule(Parser *p)
         }
         p->mark = _mark;
         D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
     }
     _res = NULL;
   done:

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+Allow an unparenthesized walrus in subscript indexes.`
Original file line number	Diff line number	Diff line change
`@@ -10639,7 +10639,7 @@ slices_rule(Parser *p)`
`10639`	`10639`	`return _res;`
`10640`	`10640`	`}`
`10641`	`10641`
`10642`		`-// slice: expression? ':' expression? [':' expression?] \| expression`
	`10642`	`+// slice: expression? ':' expression? [':' expression?] \| named_expression`
`10643`	`10643`	`static expr_ty`
`10644`	`10644`	`slice_rule(Parser *p)`
`10645`	`10645`	`{`
`@@ -10701,18 +10701,18 @@ slice_rule(Parser *p)`
`10701`	`10701`	`D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',`
`10702`	`10702`	`p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?]"));`
`10703`	`10703`	`}`
`10704`		`- { // expression`
	`10704`	`+ { // named_expression`
`10705`	`10705`	`if (p->error_indicator) {`
`10706`	`10706`	`D(p->level--);`
`10707`	`10707`	`return NULL;`
`10708`	`10708`	`}`
`10709`		`- D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));`
	`10709`	`+ D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));`
`10710`	`10710`	`expr_ty a;`
`10711`	`10711`	`if (`
`10712`		`- (a = expression_rule(p)) // expression`
	`10712`	`+ (a = named_expression_rule(p)) // named_expression`
`10713`	`10713`	`)`
`10714`	`10714`	`{`
`10715`		`- D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));`
	`10715`	`+ D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));`
`10716`	`10716`	`_res = a;`
`10717`	`10717`	`if (_res == NULL && PyErr_Occurred()) {`
`10718`	`10718`	`p->error_indicator = 1;`
`@@ -10723,7 +10723,7 @@ slice_rule(Parser *p)`
`10723`	`10723`	`}`
`10724`	`10724`	`p->mark = _mark;`
`10725`	`10725`	`D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',`
`10726`		`- p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));`
	`10726`	`+ p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));`
`10727`	`10727`	`}`
`10728`	`10728`	`_res = NULL;`
`10729`	`10729`	`done:`