Preserve parenthesization in the AST

Maintain explicit "paren" nodes in the AST so we can pretty-print
without having to guess where parens should go. We may revisit this
in the future.

r=graydon

6 files changed, 80 insertions, 177 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 60f22f1b844..a3e57716d17 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -744,7 +744,10 @@ enum expr_ {
     expr_struct(@path, ~[field], Option<@expr>),
 
     // A vector literal constructed from one repeated element.
-    expr_repeat(@expr /* element */, @expr /* count */, mutability)
+    expr_repeat(@expr /* element */, @expr /* count */, mutability),
+
+    // No-op: used solely so we can pretty-print faithfully
+    expr_paren(@expr)
 }
 
 #[auto_serialize]
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index e2b6e6daa2f..5fe3c8feea6 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -494,7 +494,8 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
             expr_struct(fld.fold_path(path),
                         vec::map(fields, |x| fold_field(*x)),
                         option::map(&maybe_expr, |x| fld.fold_expr(*x)))
-          }
+          },
+          expr_paren(ex) => expr_paren(fld.fold_expr(ex))
         }
 }
 
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index ff3abb5379e..2f3e29bd90f 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -36,39 +36,3 @@ fn stmt_ends_with_semi(stmt: ast::stmt) -> bool {
       }
     }
 }
-
-fn need_parens(expr: @ast::expr, outer_prec: uint) -> bool {
-    match expr.node {
-      ast::expr_binary(op, _, _) => operator_prec(op) < outer_prec,
-      ast::expr_cast(_, _) => parse::prec::as_prec < outer_prec,
-      // This may be too conservative in some cases
-      ast::expr_assign(_, _) => true,
-      ast::expr_swap(_, _) => true,
-      ast::expr_assign_op(_, _, _) => true,
-      ast::expr_ret(_) => true,
-      ast::expr_assert(_) => true,
-      ast::expr_log(_, _, _) => true,
-      _ => !parse::classify::expr_requires_semi_to_be_stmt(expr)
-    }
-}
-
-fn ends_in_lit_int(ex: @ast::expr) -> bool {
-    match ex.node {
-      ast::expr_lit(node) => match node {
-        @{node: ast::lit_int(_, ast::ty_i), _}
-        | @{node: ast::lit_int_unsuffixed(_), _} => true,
-        _ => false
-      },
-      ast::expr_binary(_, _, sub) | ast::expr_unary(_, sub) |
-      ast::expr_copy(sub) | ast::expr_assign(_, sub) |
-      ast::expr_assign_op(_, _, sub) | ast::expr_swap(_, sub) |
-      ast::expr_log(_, _, sub) | ast::expr_assert(sub) => {
-        ends_in_lit_int(sub)
-      }
-      ast::expr_fail(osub) | ast::expr_ret(osub) => match osub {
-        Some(ex) => ends_in_lit_int(ex),
-        _ => false
-      },
-      _ => false
-    }
-}
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index b9a71667012..a5bc5013c17 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -36,11 +36,11 @@ use ast::{_mod, add, arg, arm, attribute,
              expr_call, expr_cast, expr_copy, expr_do_body, expr_fail,
              expr_field, expr_fn, expr_fn_block, expr_if, expr_index,
              expr_lit, expr_log, expr_loop, expr_loop_body, expr_mac,
-             expr_path, expr_rec, expr_repeat, expr_ret, expr_swap,
-             expr_struct, expr_tup, expr_unary, expr_unary_move, expr_vec,
-             expr_vstore, expr_while, extern_fn, field, fn_decl, foreign_item,
-             foreign_item_const, foreign_item_fn, foreign_mod, ident,
-             impure_fn, infer, inherited,
+             expr_paren, expr_path, expr_rec, expr_repeat, expr_ret,
+             expr_swap, expr_struct, expr_tup, expr_unary, expr_unary_move,
+             expr_vec, expr_vstore, expr_while, extern_fn, field, fn_decl,
+             foreign_item, foreign_item_const, foreign_item_fn, foreign_mod,
+             ident, impure_fn, infer, inherited,
              item, item_, item_class, item_const, item_enum, item_fn,
              item_foreign_mod, item_impl, item_mac, item_mod, item_trait,
              item_ty, lit, lit_, lit_bool, lit_float, lit_int,
@@ -94,18 +94,6 @@ enum restriction {
 
 enum file_type { CRATE_FILE, SOURCE_FILE, }
 
-
-// We don't allow single-entry tuples in the true AST; that indicates a
-// parenthesized expression.  However, we preserve them temporarily while
-// parsing because `(while{...})+3` parses differently from `while{...}+3`.
-//
-// To reflect the fact that the @expr is not a true expr that should be
-// part of the AST, we wrap such expressions in the pexpr enum.  They
-// can then be converted to true expressions by a call to `to_expr()`.
-enum pexpr {
-    pexpr(@expr),
-}
-
 enum class_member {
     field_member(@struct_field),
     method_member(@method)
@@ -141,11 +129,11 @@ macro_rules! maybe_whole_expr (
     ($p:expr) => { match copy $p.token {
       INTERPOLATED(token::nt_expr(e)) => {
         $p.bump();
-        return pexpr(e);
+        return e;
       }
       INTERPOLATED(token::nt_path(pt)) => {
         $p.bump();
-        return $p.mk_pexpr($p.span.lo, $p.span.lo,
+        return $p.mk_expr($p.span.lo, $p.span.lo,
                        expr_path(pt));
       }
       _ => ()
@@ -850,18 +838,7 @@ impl Parser {
               node: expr_lit(lv_lit), span: span};
     }
 
-    fn mk_pexpr(lo: uint, hi: uint, node: expr_) -> pexpr {
-        return pexpr(self.mk_expr(lo, hi, node));
-    }
-
-    fn to_expr(e: pexpr) -> @expr {
-        match e.node {
-          expr_tup(es) if vec::len(es) == 1u => es[0u],
-          _ => *e
-        }
-    }
-
-    fn parse_bottom_expr() -> pexpr {
+    fn parse_bottom_expr() -> @expr {
         maybe_whole_expr!(self);
         let lo = self.span.lo;
         let mut hi = self.span.hi;
@@ -869,7 +846,7 @@ impl Parser {
         let mut ex: expr_;
 
         match self.maybe_parse_dollar_mac() {
-          Some(x) => return pexpr(self.mk_mac_expr(lo, self.span.hi, x)),
+          Some(x) => return self.mk_mac_expr(lo, self.span.hi, x),
           _ => ()
         }
 
@@ -879,7 +856,7 @@ impl Parser {
                 hi = self.span.hi;
                 self.bump();
                 let lit = @spanned(lo, hi, lit_nil);
-                return self.mk_pexpr(lo, hi, expr_lit(lit));
+                return self.mk_expr(lo, hi, expr_lit(lit));
             }
             let mut es = ~[self.parse_expr()];
             while self.token == token::COMMA {
@@ -888,12 +865,12 @@ impl Parser {
             hi = self.span.hi;
             self.expect(token::RPAREN);
 
-            // Note: we retain the expr_tup() even for simple
-            // parenthesized expressions, but only for a "little while".
-            // This is so that wrappers around parse_bottom_expr()
-            // can tell whether the expression was parenthesized or not,
-            // which affects expr_is_complete().
-            return self.mk_pexpr(lo, hi, expr_tup(es));
+            return if es.len() == 1 {
+                self.mk_expr(lo, self.span.hi, expr_paren(es[0]))
+            }
+            else {
+                self.mk_expr(lo, hi, expr_tup(es))
+            }
         } else if self.token == token::LBRACE {
             if self.looking_at_record_literal() {
                 ex = self.parse_record_literal();
@@ -901,32 +878,32 @@ impl Parser {
             } else {
                 self.bump();
                 let blk = self.parse_block_tail(lo, default_blk);
-                return self.mk_pexpr(blk.span.lo, blk.span.hi,
+                return self.mk_expr(blk.span.lo, blk.span.hi,
                                      expr_block(blk));
             }
         } else if token::is_bar(self.token) {
-            return pexpr(self.parse_lambda_expr());
+            return self.parse_lambda_expr();
         } else if self.eat_keyword(~"if") {
-            return pexpr(self.parse_if_expr());
+            return self.parse_if_expr();
         } else if self.eat_keyword(~"for") {
-            return pexpr(self.parse_sugary_call_expr(~"for", expr_loop_body));
+            return self.parse_sugary_call_expr(~"for", expr_loop_body);
         } else if self.eat_keyword(~"do") {
-            return pexpr(self.parse_sugary_call_expr(~"do", expr_do_body));
+            return self.parse_sugary_call_expr(~"do", expr_do_body);
         } else if self.eat_keyword(~"while") {
-            return pexpr(self.parse_while_expr());
+            return self.parse_while_expr();
         } else if self.eat_keyword(~"loop") {
-            return pexpr(self.parse_loop_expr());
+            return self.parse_loop_expr();
         } else if self.eat_keyword(~"match") {
-            return pexpr(self.parse_alt_expr());
+            return self.parse_alt_expr();
         } else if self.eat_keyword(~"fn") {
             let proto = self.parse_fn_ty_proto();
             match proto {
               proto_bare => self.fatal(~"fn expr are deprecated, use fn@"),
               _ => { /* fallthrough */ }
             }
-            return pexpr(self.parse_fn_expr(proto));
+            return self.parse_fn_expr(proto);
         } else if self.eat_keyword(~"unsafe") {
-            return pexpr(self.parse_block_expr(lo, unsafe_blk));
+            return self.parse_block_expr(lo, unsafe_blk);
         } else if self.token == token::LBRACKET {
             self.bump();
             let mutbl = self.parse_mutability();
@@ -962,7 +939,7 @@ impl Parser {
             hi = self.span.hi;
         } else if self.token == token::ELLIPSIS {
             self.bump();
-            return pexpr(self.mk_mac_expr(lo, self.span.hi, mac_ellipsis));
+            return self.mk_mac_expr(lo, self.span.hi, mac_ellipsis);
         } else if self.token == token::POUND {
             let ex_ext = self.parse_syntax_ext();
             hi = ex_ext.span.hi;
@@ -1020,8 +997,8 @@ impl Parser {
 
                 let hi = self.span.hi;
 
-                return pexpr(self.mk_mac_expr(
-                    lo, hi, mac_invoc_tt(pth, tts)));
+                return self.mk_mac_expr(
+                    lo, hi, mac_invoc_tt(pth, tts));
             } else if self.token == token::LBRACE {
                 // This might be a struct literal.
                 if self.looking_at_record_literal() {
@@ -1053,7 +1030,7 @@ impl Parser {
                     hi = pth.span.hi;
                     self.expect(token::RBRACE);
                     ex = expr_struct(pth, fields, base);
-                    return self.mk_pexpr(lo, hi, ex);
+                    return self.mk_expr(lo, hi, ex);
                 }
             }
 
@@ -1068,7 +1045,7 @@ impl Parser {
         let (hi, ex) =
             self.try_convert_expr_to_obsolete_fixed_length_vstore(lo, hi, ex);
 
-        return self.mk_pexpr(lo, hi, ex);
+        return self.mk_expr(lo, hi, ex);
     }
 
     fn parse_block_expr(lo: uint, blk_mode: blk_check_mode) -> @expr {
@@ -1125,7 +1102,7 @@ impl Parser {
         return self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b));
     }
 
-    fn parse_dot_or_call_expr() -> pexpr {
+    fn parse_dot_or_call_expr() -> @expr {
         let b = self.parse_bottom_expr();
         self.parse_dot_or_call_expr_with(b)
     }
@@ -1134,7 +1111,7 @@ impl Parser {
         return self.restriction != RESTRICT_NO_CALL_EXPRS;
     }
 
-    fn parse_dot_or_call_expr_with(e0: pexpr) -> pexpr {
+    fn parse_dot_or_call_expr_with(e0: @expr) -> @expr {
         let mut e = e0;
         let lo = e.span.lo;
         let mut hi;
@@ -1150,8 +1127,7 @@ impl Parser {
                         self.parse_seq_to_gt(Some(token::COMMA),
                                              |p| p.parse_ty(false))
                     } else { ~[] };
-                    e = self.mk_pexpr(lo, hi, expr_field(self.to_expr(e), i,
-                                                         tys));
+                    e = self.mk_expr(lo, hi, expr_field(e, i, tys));
                   }
                   _ => self.unexpected()
                 }
@@ -1167,8 +1143,8 @@ impl Parser {
                     |p| p.parse_expr());
                 hi = self.span.hi;
 
-                let nd = expr_call(self.to_expr(e), es, false);
-                e = self.mk_pexpr(lo, hi, nd);
+                let nd = expr_call(e, es, false);
+                e = self.mk_expr(lo, hi, nd);
               }
 
               // expr[...]
@@ -1177,7 +1153,7 @@ impl Parser {
                 let ix = self.parse_expr();
                 hi = ix.span.hi;
                 self.expect(token::RBRACKET);
-                e = self.mk_pexpr(lo, hi, expr_index(self.to_expr(e), ix));
+                e = self.mk_expr(lo, hi, expr_index(e, ix));
               }
 
               _ => return e
@@ -1326,7 +1302,7 @@ impl Parser {
     }
 
 
-    fn parse_prefix_expr() -> pexpr {
+    fn parse_prefix_expr() -> @expr {
         let lo = self.span.lo;
         let mut hi;
 
@@ -1334,7 +1310,7 @@ impl Parser {
         match copy self.token {
           token::NOT => {
             self.bump();
-            let e = self.to_expr(self.parse_prefix_expr());
+            let e = self.parse_prefix_expr();
             hi = e.span.hi;
             self.get_id(); // see ast_util::op_expr_callee_id
             ex = expr_unary(not, e);
@@ -1343,21 +1319,21 @@ impl Parser {
             match b {
               token::MINUS => {
                 self.bump();
-                let e = self.to_expr(self.parse_prefix_expr());
+                let e = self.parse_prefix_expr();
                 hi = e.span.hi;
                 self.get_id(); // see ast_util::op_expr_callee_id
                 ex = expr_unary(neg, e);
               }
               token::STAR => {
                 self.bump();
-                let e = self.to_expr(self.parse_prefix_expr());
+                let e = self.parse_prefix_expr();
                 hi = e.span.hi;
                 ex = expr_unary(deref, e);
               }
               token::AND => {
                 self.bump();
                 let m = self.parse_mutability();
-                let e = self.to_expr(self.parse_prefix_expr());
+                let e = self.parse_prefix_expr();
                 hi = e.span.hi;
                 // HACK: turn &[...] into a &-evec
                 ex = match e.node {
@@ -1374,7 +1350,7 @@ impl Parser {
           token::AT => {
             self.bump();
             let m = self.parse_mutability();
-            let e = self.to_expr(self.parse_prefix_expr());
+            let e = self.parse_prefix_expr();
             hi = e.span.hi;
             // HACK: turn @[...] into a @-evec
             ex = match e.node {
@@ -1386,7 +1362,7 @@ impl Parser {
           token::TILDE => {
             self.bump();
             let m = self.parse_mutability();
-            let e = self.to_expr(self.parse_prefix_expr());
+            let e = self.parse_prefix_expr();
             hi = e.span.hi;
             // HACK: turn ~[...] into a ~-evec
             ex = match e.node {
@@ -1397,18 +1373,17 @@ impl Parser {
           }
           _ => return self.parse_dot_or_call_expr()
         }
-        return self.mk_pexpr(lo, hi, ex);
+        return self.mk_expr(lo, hi, ex);
     }
 
 
     fn parse_binops() -> @expr {
-        return self.parse_more_binops(self.parse_prefix_expr(), 0u);
+        return self.parse_more_binops(self.parse_prefix_expr(), 0);
     }
 
-    fn parse_more_binops(plhs: pexpr, min_prec: uint) ->
+    fn parse_more_binops(lhs: @expr, min_prec: uint) ->
         @expr {
-        let lhs = self.to_expr(plhs);
-        if self.expr_is_complete(plhs) { return lhs; }
+        if self.expr_is_complete(lhs) { return lhs; }
         let peeked = self.token;
         if peeked == token::BINOP(token::OR) &&
             (self.restriction == RESTRICT_NO_BAR_OP ||
@@ -1428,7 +1403,7 @@ impl Parser {
                 let expr = self.parse_prefix_expr();
                 let rhs = self.parse_more_binops(expr, cur_prec);
                 self.get_id(); // see ast_util::op_expr_callee_id
-                let bin = self.mk_pexpr(lhs.span.lo, rhs.span.hi,
+                let bin = self.mk_expr(lhs.span.lo, rhs.span.hi,
                                         expr_binary(cur_op, lhs, rhs));
                 return self.parse_more_binops(bin, min_prec);
             }
@@ -1438,7 +1413,7 @@ impl Parser {
         if as_prec > min_prec && self.eat_keyword(~"as") {
             let rhs = self.parse_ty(true);
             let _as =
-                self.mk_pexpr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs));
+                self.mk_expr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs));
             return self.parse_more_binops(_as, min_prec);
         }
         return lhs;
@@ -2173,9 +2148,9 @@ impl Parser {
         }
     }
 
-    fn expr_is_complete(e: pexpr) -> bool {
+    fn expr_is_complete(e: @expr) -> bool {
         return self.restriction == RESTRICT_STMT_EXPR &&
-            !classify::expr_requires_semi_to_be_stmt(*e);
+            !classify::expr_requires_semi_to_be_stmt(e);
     }
 
     fn parse_block() -> blk {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 82db3aaa4b3..3836c21ff24 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -773,7 +773,7 @@ fn print_variant(s: ps, v: ast::variant) {
     match v.node.kind {
         ast::tuple_variant_kind(args) => {
             print_ident(s, v.node.name);
-            if vec::len(args) > 0u {
+            if args.is_not_empty() {
                 popen(s);
                 fn print_variant_arg(s: ps, arg: ast::variant_arg) {
                     print_type(s, arg.ty);
@@ -951,25 +951,11 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
     s.ann.post(ann_node);
 }
 
-// return and fail, without arguments cannot appear is the discriminant of if,
-// alt, do, & while unambiguously without being parenthesized
-fn print_maybe_parens_discrim(s: ps, e: @ast::expr) {
-    let disambig = match e.node {
-      ast::expr_ret(None)
-      | ast::expr_fail(None)
-      | ast::expr_again(*) => true,
-      _ => false
-    };
-    if disambig { popen(s); }
-    print_expr(s, e);
-    if disambig { pclose(s); }
-}
-
 fn print_if(s: ps, test: @ast::expr, blk: ast::blk,
             elseopt: Option<@ast::expr>, chk: bool) {
     head(s, ~"if");
     if chk { word_nbsp(s, ~"check"); }
-    print_maybe_parens_discrim(s, test);
+    print_expr(s, test);
     space(s.s);
     print_block(s, blk);
     fn do_else(s: ps, els: Option<@ast::expr>) {
@@ -981,7 +967,7 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk,
                 cbox(s, indent_unit - 1u);
                 ibox(s, 0u);
                 word(s.s, ~" else if ");
-                print_maybe_parens_discrim(s, i);
+                print_expr(s, i);
                 space(s.s);
                 print_block(s, t);
                 do_else(s, e);
@@ -1154,8 +1140,8 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
             }
             Some(blk_arg)
         } else { None };
-        print_expr_parens_if_not_bot(s, func);
-        if !has_block || vec::len(base_args) > 0u {
+        print_expr(s, func);
+        if !has_block || base_args.is_not_empty() {
             popen(s);
             commasep_exprs(s, inconsistent, base_args);
             pclose(s);
@@ -1178,15 +1164,14 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         }
       }
       ast::expr_binary(op, lhs, rhs) => {
-        let prec = operator_prec(op);
-        print_op_maybe_parens(s, lhs, prec);
+        print_expr(s, lhs);
         space(s.s);
         word_space(s, ast_util::binop_to_str(op));
-        print_op_maybe_parens(s, rhs, prec + 1u);
+        print_expr(s, rhs);
       }
       ast::expr_unary(op, expr) => {
         word(s.s, ast_util::unop_to_str(op));
-        print_op_maybe_parens(s, expr, parse::prec::unop_prec);
+        print_expr(s, expr);
       }
       ast::expr_addr_of(m, expr) => {
         word(s.s, ~"&");
@@ -1195,7 +1180,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
       }
       ast::expr_lit(lit) => print_literal(s, lit),
       ast::expr_cast(expr, ty) => {
-        print_op_maybe_parens(s, expr, parse::prec::as_prec);
+        print_expr(s, expr);
         space(s.s);
         word_space(s, ~"as");
         print_type_ex(s, ty, true);
@@ -1205,7 +1190,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
       }
       ast::expr_while(test, blk) => {
         head(s, ~"while");
-        print_maybe_parens_discrim(s, test);
+        print_expr(s, test);
         space(s.s);
         print_block(s, blk);
       }
@@ -1220,9 +1205,9 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
       }
       ast::expr_match(expr, arms) => {
         cbox(s, alt_indent_unit);
-        ibox(s, 4u);
+        ibox(s, 4);
         word_nbsp(s, ~"match");
-        print_maybe_parens_discrim(s, expr);
+        print_expr(s, expr);
         space(s.s);
         bopen(s);
         let len = arms.len();
@@ -1335,12 +1320,9 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         print_block(s, blk);
       }
       ast::expr_copy(e) => { word_space(s, ~"copy"); print_expr(s, e); }
-        // shouldn't parenthesize unless it's needed
       ast::expr_unary_move(e) => {
-          popen(s);
           word_space(s, ~"move");
           print_expr(s, e);
-          pclose(s);
       }
       ast::expr_assign(lhs, rhs) => {
         print_expr(s, lhs);
@@ -1362,12 +1344,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         print_expr(s, rhs);
       }
       ast::expr_field(expr, id, tys) => {
-        // Deal with '10.x'
-        if ends_in_lit_int(expr) {
-            popen(s); print_expr(s, expr); pclose(s);
-        } else {
-            print_expr_parens_if_not_bot(s, expr);
-        }
+        print_expr(s, expr);
         word(s.s, ~".");
         print_ident(s, id);
         if vec::len(tys) > 0u {
@@ -1377,7 +1354,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         }
       }
       ast::expr_index(expr, index) => {
-        print_expr_parens_if_not_bot(s, expr);
+        print_expr(s, expr);
         word(s.s, ~"[");
         print_expr(s, index);
         word(s.s, ~"]");
@@ -1427,27 +1404,16 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         print_expr(s, expr);
       }
       ast::expr_mac(m) => print_mac(s, m),
+      ast::expr_paren(e) => {
+          popen(s);
+          print_expr(s, e);
+          pclose(s);
+      }
     }
     s.ann.post(ann_node);
     end(s);
 }
 
-fn print_expr_parens_if_not_bot(s: ps, ex: @ast::expr) {
-    let parens = match ex.node {
-      ast::expr_fail(_) | ast::expr_ret(_) |
-      ast::expr_binary(_, _, _) | ast::expr_unary(_, _) |
-      ast::expr_copy(_) | ast::expr_assign(_, _) |
-      ast::expr_assign_op(_, _, _) | ast::expr_swap(_, _) |
-      ast::expr_log(_, _, _) | ast::expr_assert(_) |
-      ast::expr_call(_, _, true) |
-      ast::expr_vstore(_, _) => true,
-      _ => false
-    };
-    if parens { popen(s); }
-    print_expr(s, ex);
-    if parens { pclose(s); }
-}
-
 fn print_local_decl(s: ps, loc: @ast::local) {
     print_pat(s, loc.node.pat);
     match loc.node.ty.node {
@@ -1557,7 +1523,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
         match args_ {
           None => word(s.s, ~"(*)"),
           Some(args) => {
-            if vec::len(args) > 0u {
+            if args.is_not_empty() {
               popen(s);
               commasep(s, inconsistent, args, print_pat);
               pclose(s);
@@ -1813,7 +1779,7 @@ fn print_view_item(s: ps, item: @ast::view_item) {
       ast::view_item_use(id, mta, _) => {
         head(s, ~"extern mod");
         print_ident(s, id);
-        if vec::len(mta) > 0u {
+        if mta.is_not_empty() {
             popen(s);
             commasep(s, consistent, mta, print_meta_item);
             pclose(s);
@@ -1835,13 +1801,6 @@ fn print_view_item(s: ps, item: @ast::view_item) {
     end(s); // end outer head-block
 }
 
-fn print_op_maybe_parens(s: ps, expr: @ast::expr, outer_prec: uint) {
-    let add_them = need_parens(expr, outer_prec);
-    if add_them { popen(s); }
-    print_expr(s, expr);
-    if add_them { pclose(s); }
-}
-
 fn print_mutability(s: ps, mutbl: ast::mutability) {
     match mutbl {
       ast::m_mutbl => word_nbsp(s, ~"mut"),
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index e4eabfabf2f..2dbe2b16044 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -462,6 +462,7 @@ fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
         v.visit_expr(x, e, v);
       }
       expr_mac(mac) => visit_mac(mac, e, v),
+      expr_paren(x) => v.visit_expr(x, e, v),
     }
     v.visit_expr_post(ex, e, v);
 }