Explicitly disallow assignment expressions to a name inside parenthes…

…es, 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
python · emilyemorehouse · Jan 24, 2019 · Jul 21, 2018 · Jul 22, 2018 · Jul 22, 2018
commit 051ad8c998ed48d25d0b246181801a02d60e843d
diff --git a/Lib/test/test_named_expressions.py b/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):

diff --git a/Python/ast.c b/Python/ast.c
@@ -1741,8 +1741,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;