Add support for expressions like 'a <= b < c' + fixes in the printer.

progval · progval · commit 190fc41ec037 · 2018-06-10T16:57:59.000+02:00
diff --git a/src/ast.rs b/src/ast.rs
@@ -240,8 +240,12 @@ pub enum Expression {
     Attribute(Box<Expression>, Name),
     /// Unary operator
     Uop(Uop, Box<Expression>),
-    /// Binary operator
+    /// Binary operator. A simplified version of `MultiBop`, when the
+    /// expressivity of MultiBop is not needed.
     Bop(Bop, Box<Expression>, Box<Expression>),
+    /// Binary operator... but may be applied on more than one expr
+    /// (eg. `a <= b < c`)
+    MultiBop(Box<Expression>, Vec<(Bop, Expression)>),
     /// 1 if 2 else 3
     Ternary(Box<Expression>, Box<Expression>, Box<Expression>),
     Yield(Vec<Expression>),
diff --git a/src/expressions.rs b/src/expressions.rs
@@ -111,11 +111,19 @@ macro_rules! bop {
                 delimited!(spaces!(), $tag!($($args)*), spaces!()),
                 $child
               ),
-              first,
-              |acc, (op, f)| Box::new(Expression::Bop(op, acc, f))
-            ) >> (
-            r
-            )
+              (first, Vec::new()),
+              |(first, mut acc):(_,Vec<_>), (op, f):(_,Box<_>)| { acc.push((op, *f)); (first, acc) }
+            ) >> ({
+              let (first, rest) = r;
+              match rest.len() {
+                  0 => first,
+                  1 => {
+                      let (op, ref rhs) = rest[0];
+                      Box::new(Expression::Bop(op, first, Box::new(rhs.clone())))
+                  }
+                  _ => Box::new(Expression::MultiBop(first, rest))
+              }
+            })
           )
         );
     }
@@ -1674,4 +1682,20 @@ mod tests {
             ))
         )));
     }
+
+    #[test]
+    fn test_multibop() {
+        let test = ExpressionParser::<NewlinesAreNotSpaces>::test;
+
+        assert_parse_eq(test(make_strspan("a <= b < c")), Ok((make_strspan(""),
+            Box::new(Expression::MultiBop(
+                Box::new(Expression::Name("a".to_string())),
+                vec![
+                    (Bop::Leq, Expression::Name("b".to_string())),
+                    (Bop::Lt, Expression::Name("c".to_string())),
+                ]
+            ))
+        )));
+    }
+
 }
diff --git a/src/visitors/printer.rs b/src/visitors/printer.rs
@@ -218,7 +218,7 @@ fn format_compound_statement(indent: usize, stmt: &CompoundStatement) -> String
             }
             if finally_block.len() > 0 {
                 push_indent(indent, &mut s);
-                s.push_str("finally_block:\n");
+                s.push_str("finally:\n");
                 s.push_str(&format_block(indent+4, finally_block));
             }
             s
@@ -364,9 +364,11 @@ fn format_typed_params(param: &TypedArgsList) -> String {
         StarParams::No => (),
         StarParams::Anonymous => s.push_str("*, "),
         StarParams::Named((ref name, None)) => {
+            s.push_str("*");
             s.push_str(name);
         },
         StarParams::Named((ref name, Some(ref typed))) => {
+            s.push_str("*");
             s.push_str(name);
             s.push_str(":");
             s.push_str(&format_expr(typed));
@@ -561,6 +563,20 @@ fn format_expr(e: &Expression) -> String {
             };
             format!("{}{}{}", f(e1), op, f(e2))
         },
+        Expression::MultiBop(ref first, ref rest) => {
+            let mut s = String::new();
+            s.push_str("(");
+            s.push_str(&format_expr(first));
+            s.push_str(")");
+            for (op, e) in rest {
+                s.push_str(" ");
+                s.push_str(&op.to_string());
+                s.push_str(" (");
+                s.push_str(&format_expr(e));
+                s.push_str(")");
+            }
+            s
+        },
         Expression::Ternary(e1, e2, e3) =>
             format!("({}) if ({}) else ({})", format_expr(e1), format_expr(e2), format_expr(e3)),
         Expression::Star(ref e) =>
@@ -598,13 +614,15 @@ fn format_import(imp: &Import) -> String {
             }
             s.push_str(&format_dotted_name(path));
             s.push_str(" import ");
-            for (name, as_name) in names {
-                s.push_str(name);
+            s.push_str(&comma_join(names.iter().map(|(name, as_name)| {
+                let mut s2 = String::new();
+                s2.push_str(name);
                 if let Some(as_name) = as_name {
-                    s.push_str(" as ");
-                    s.push_str(as_name);
+                    s2.push_str(" as ");
+                    s2.push_str(as_name);
                 }
-            }
+                s2
+            })));
         },
         Import::Import { ref names } => {
             s.push_str("import ");
