Add namedexpr (aka walrus operator)

Main commit adding it in cpython: 8f59ee01be3d83d5513a9a3f654a237d77d80d9a

But also this one: d4fceaafb8e3f8700d9ec6ab37a51e903392f74f because it's
easier to implement both at the same time.

No support for := in arguments yet.

Author: progval

Diff for: src/ast.rs

@@ -260,6 +260,8 @@ pub enum Expression {
     YieldFrom(Box<Expression>),
     Star(Box<Expression>),
     Lambdef(UntypedArgsList, Box<Expression>),
+    /// Walrus operator: 1 := 2
+    Named(Box<Expression>, Box<Expression>),
 }
 
 /// An import statement.

Diff for: src/expressions.rs

@@ -23,6 +23,24 @@ impl<ANS: AreNewlinesSpaces> ExpressionParser<ANS> {
      * Decorators
      *********************************************************************/
 
+    // namedexpr_test: test [':=' test]
+    named!(pub namedexpr_test<StrSpan, Box<Expression>>,
+      do_parse!(
+        left: call!(Self::test) >>
+        right: opt!(
+          preceded!(
+            ws_auto!(keyword!(":=")),
+            call!(Self::test)
+          )
+        ) >> (
+          match right {
+            None => left,
+            Some(right) => Box::new(Expression::Named(left, right)),
+          }
+        )
+      )
+    );
+
     // test: or_test ['if' or_test 'else' test] | lambdef
     named!(pub test<StrSpan, Box<Expression>>,
       alt!(
@@ -325,11 +343,11 @@ impl<ANS: AreNewlinesSpaces> ExpressionParser<ANS> {
       ), |e| Box::new(e))
     );
 
-    // testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
+    // testlist_comp: (namedexpr_test|star_expr) ( comp_for | (',' (namedexpr_test|star_expr))* [','] )
     named!(testlist_comp<StrSpan, TestlistCompReturn>,
       do_parse!(
         first: ws_auto!(alt!(
-            call!(Self::test) => { |e: Box<_>| SetItem::Unique(*e) }
+            call!(Self::namedexpr_test) => { |e: Box<_>| SetItem::Unique(*e) }
           | preceded!(char!('*'), call!(Self::expr)) => { |e: Box<_>| SetItem::Star(*e) }
           )) >>
         r: alt!(
@@ -338,7 +356,7 @@ impl<ANS: AreNewlinesSpaces> ExpressionParser<ANS> {
             ws_auto!(char!(',')),
             separated_list!(ws_auto!(char!(',')),
               alt!(
-                call!(Self::test) => { |e: Box<_>| SetItem::Unique(*e) }
+                call!(Self::namedexpr_test) => { |e: Box<_>| SetItem::Unique(*e) }
               | preceded!(char!('*'), call!(Self::expr)) => { |e: Box<_>| SetItem::Star(*e) }
               )
             ),
@@ -1913,6 +1931,36 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_namedexpr() {
+        let namedexpr_test = ExpressionParser::<NewlinesAreNotSpaces>::namedexpr_test;
+
+        assert_parse_eq(
+            namedexpr_test(make_strspan("foo := bar")),
+            Ok((
+                make_strspan(""),
+                Box::new(Expression::Named(
+                    Box::new(Expression::Name("foo".to_string())),
+                    Box::new(Expression::Name("bar".to_string())),
+                )),
+            )),
+        );
+
+        assert_parse_eq(
+            namedexpr_test(make_strspan("foo := (bar := baz)")),
+            Ok((
+                make_strspan(""),
+                Box::new(Expression::Named(
+                    Box::new(Expression::Name("foo".to_string())),
+                    Box::new(Expression::Named(
+                        Box::new(Expression::Name("bar".to_string())),
+                        Box::new(Expression::Name("baz".to_string())),
+                    )),
+                )),
+            )),
+        );
+    }
+
     #[test]
     fn test_multibop() {
         let test = ExpressionParser::<NewlinesAreNotSpaces>::test;

Diff for: src/statements.rs

@@ -341,6 +341,7 @@ named_args!(pub block(indent: usize) <StrSpan, Vec<Statement>>,
   | call!(simple_stmt)
   )
 );
+// used to parse `namedexpr_test ':' suite` in if_stmt and while_stmt
 named_args!(cond_and_block(indent: usize) <StrSpan, (Expression, Vec<Statement>)>,
   return_error!(do_parse!(
     spaces_nonl >>
@@ -384,7 +385,7 @@ named_args!(else_block(indent: usize) <StrSpan, Option<Vec<Statement>>>,
   )
 );
 
-// if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+// if_stmt: 'if' namedexpr_test ':' suite ('elif' namedexpr_test ':' suite)* ['else' ':' suite]
 named_args!(if_stmt(indent: usize) <StrSpan, CompoundStatement>,
   do_parse!(
     indent!(indent) >>
@@ -404,7 +405,7 @@ named_args!(if_stmt(indent: usize) <StrSpan, CompoundStatement>,
   )
 );
 
-// while_stmt: 'while' test ':' suite ['else' ':' suite]
+// while_stmt: 'while' namedexpr_test ':' suite ['else' ':' suite]
 named_args!(while_stmt(indent: usize) <StrSpan, CompoundStatement>,
   do_parse!(
     indent!(indent) >>

Diff for: src/visitors/printer.rs

@@ -720,6 +720,9 @@ fn format_expr(e: &Expression) -> String {
             format_untyped_params(params),
             format_expr(body)
         ),
+        Expression::Named(ref name, ref expr) => {
+            format!("{} := ({})", format_expr(name), format_expr(expr),)
+        }
     }
 }
 
@@ -819,4 +822,13 @@ mod tests {
             "[a for a in L if ((f(a)) if (a) else (None))]"
         );
     }
+
+    #[test]
+    fn test_namedexpr() {
+        let e = Expression::Named(
+            Box::new(Expression::Name("foo".to_string())),
+            Box::new(Expression::Name("bar".to_string())),
+        );
+        assert_eq!(&format_expr(&e), "foo := (bar)");
+    }
 }