Explicitly disallow assignment expressions to a name inside parentheses, e.g.: ((x) := 0)

- Add check for LHS types to detect a parenthesis then a name (see note)
- Add test for this scenario
- Update tests for changed error message for named assignment to a tuple
(also, see note)

Note: This caused issues with the previous error handling for named assignment
to a LHS that contained an expression, such as a tuple. Thus, the check
for the LHS of a named expression must be changed to be more specific if
we wish to maintain the previous error messages

Author: emilyemorehouse

Lib/test/test_named_expressions.py

@@ -10,6 +10,13 @@ def test_named_expression_invalid_01(self):
         with self.assertRaisesRegex(SyntaxError, "invalid syntax"):
             exec(code, {}, {})
 
+    def test_named_expression_invalid_01(self):
+        code = """((x) := 0)"""
+
+        with self.assertRaisesRegex(SyntaxError,
+            "can't use named assignment with expression"):
+            exec(code, {}, {})
+
     def test_named_expression_invalid_02(self):
         code = """x = y := 0"""
 
@@ -28,10 +35,16 @@ def test_named_expression_invalid_04(self):
         with self.assertRaisesRegex(SyntaxError, "invalid syntax"):
             exec(code, {}, {})
 
+    # XXX this error message now follows the error message you get with
+    # keyword args:
+    # >>> spam((1,2)=1)
+    # File "<stdin>", line 1
+    # SyntaxError: keyword can't be an expression
     def test_named_expression_invalid_06(self):
         code = """((a, b) := (1, 2))"""
 
-        with self.assertRaisesRegex(SyntaxError, "can't use named assignment with tuple"):
+        with self.assertRaisesRegex(SyntaxError,
+            "can't use named assignment with expression"):
             exec(code, {}, {})
 
     def test_named_expression_invalid_07(self):

Python/ast.c

@@ -1715,8 +1715,51 @@ ast_for_namedexpr(struct compiling *c, const node *n)
             '*' test )
     */
     expr_ty target, value;
+    node *ch = CHILD(n, 0);
+
+    // To remain LL(1), the grammar accepts any test (basically, any
+    // expression) in the keyword slot of a call site.  So, we need
+    // to manually enforce that the keyword is a NAME here.
+    static const int name_tree[] = {
+        namedexpr_test,
+        test,
+        or_test,
+        and_test,
+        not_test,
+        comparison,
+        expr,
+        xor_expr,
+        and_expr,
+        shift_expr,
+        arith_expr,
+        term,
+        factor,
+        power,
+        atom_expr,
+        atom,
+    };
+
+    node *expr_node = ch;
+    for (int i = 1; name_tree[i]; i++) {
+        if (TYPE(expr_node) != name_tree[i])
+            break;
+        if (TYPE(expr_node) == atom && expr_node->n_nchildren == 3) {
+            node *expr_node_ch = CHILD(CHILD(expr_node, 1), 0);
+            for (int i = 0; name_tree[i]; i++) {
+                if (TYPE(expr_node_ch) != name_tree[i])
+                    break;
+                expr_node_ch = CHILD(expr_node_ch, 0);
+            }
+            if (TYPE(expr_node_ch) == NAME) {
+                ast_error(c, ch,
+                            "can't use named assignment with expression");
+                return NULL;
+            }
+        }
+        expr_node = CHILD(expr_node, 0);
+    }
 
-    target = ast_for_expr(c, CHILD(n, 0));
+    target = ast_for_expr(c, ch);
     if (!target)
         return NULL;