Preserve parenthesis when necessary.

Author: maciejhirsz

core/src/codegen.rs

@@ -439,7 +439,9 @@ impl Code for Expression {
                 ref right,
                 ..
             } => {
-                if left.binding_power() < self.binding_power() {
+                let bp = self.binding_power();
+
+                if left.binding_power() < bp {
                     gen.write_byte(b'(');
                     gen.write(left);
                     gen.write_byte(b')');
@@ -449,7 +451,14 @@ impl Code for Expression {
                 gen.write_min(b" ", b"");
                 gen.write(operator);
                 gen.write_min(b" ", b"");
-                gen.write(right);
+
+                if right.needs_parens(bp) {
+                    gen.write_byte(b'(');
+                    gen.write(right);
+                    gen.write_byte(b')');
+                } else {
+                    gen.write(right);
+                }
             },
 
             Expression::Prefix {

core/src/grammar.rs

@@ -343,6 +343,30 @@ impl Expression {
             arguments: arguments,
         }
     }
+
+    #[inline]
+    pub fn parenthesize(mut self) -> Expression {
+        if let Expression::Binary {
+            ref mut parenthesized,
+            ..
+        } = self {
+            *parenthesized = true;
+        }
+
+        self
+    }
+
+    #[inline]
+    pub fn needs_parens(&self, bp: u8) -> bool {
+        match *self {
+            Expression::Binary {
+                ref parenthesized,
+                ref operator,
+                ..
+            } => *parenthesized && bp >= operator.binding_power(),
+            _ => false
+        }
+    }
 }
 
 impl From<&'static str> for Expression {

core/src/parser.rs

@@ -453,7 +453,7 @@ impl<'a> Parser<'a> {
 
                 expect!(self, ParenClose);
 
-                Ok(expression)
+                Ok(expression.parenthesize())
             }
         }
     }

core/src/transformer.rs

@@ -344,7 +344,7 @@ impl Transformable for Expression {
                         left = Expression::binary(
                             left,
                             Addition,
-                            expression
+                            expression.parenthesize()
                         );
 
                         if quasi.len() == 0 {

core/tests/codegen.rs

@@ -39,10 +39,22 @@ fn template_strings_plain() {
     assert_compile!("`foo\nbar`;", "\"foo\\nbar\";");
 }
 
+#[test]
+fn operator_precedence_and_parens() {
+    // Preserve parens when necessary
+    assert_compile!("'foo'+(1+2);", r#"'foo'+(1+2);"#);
+
+    // Should strip parens when not necessary
+    assert_compile!("(1+2)+'foo';", r#"1+2+'foo';"#);
+    assert_compile!("'foo'+(1*2);", r#"'foo'+1*2;"#);
+    assert_compile!("(1*2)+'foo';", r#"1*2+'foo';"#);
+}
+
 #[test]
 fn template_strings_interpolation() {
     assert_compile!("`foo${1}bar`;", r#""foo"+1+"bar";"#);
     assert_compile!("`foo${1+2}bar`;", r#""foo"+(1+2)+"bar";"#);
+    assert_compile!("`foo${1*2}bar`;", r#""foo"+1*2+"bar";"#);
     assert_compile!("`foo${1}${2**2}bar`;", r#""foo"+1+Math.pow(2,2)+"bar";"#);
     assert_compile!("`foo${1}bar${2**2}`;", r#""foo"+1+"bar"+Math.pow(2,2);"#);
 }