Move logic of tuple formatting into lists.rs

This allows re-use (at least for tuple type), maybe for arg lists

Author: cassiersg

src/expr.rs

@@ -10,7 +10,7 @@
 
 use visitor::FmtVisitor;
 use utils::*;
-use lists::{write_list, ListFormatting, SeparatorTactic, ListTactic};
+use lists::{write_list, ListFormatting, SeparatorTactic, ListTactic, rewrite_tuple};
 
 use syntax::{ast, ptr};
 use syntax::codemap::{Pos, Span};
@@ -21,7 +21,7 @@ use MIN_STRING;
 
 impl<'a> FmtVisitor<'a> {
     // TODO NEEDS TESTS
-    fn rewrite_string_lit(&mut self, s: &str, span: Span, width: usize, offset: usize) -> String {
+    fn rewrite_string_lit(&self, s: &str, span: Span, width: usize, offset: usize) -> String {
         // FIXME I bet this stomps unicode escapes in the source string
 
         // Check if there is anything to fix: we always try to fixup multi-line
@@ -84,7 +84,7 @@ impl<'a> FmtVisitor<'a> {
         result
     }
 
-    fn rewrite_call(&mut self,
+    fn rewrite_call(&self,
                     callee: &ast::Expr,
                     args: &[ptr::P<ast::Expr>],
                     width: usize,
@@ -121,7 +121,7 @@ impl<'a> FmtVisitor<'a> {
         format!("{}({})", callee_str, args_str)
     }
 
-    fn rewrite_paren(&mut self, subexpr: &ast::Expr, width: usize, offset: usize) -> String {
+    fn rewrite_paren(&self, subexpr: &ast::Expr, width: usize, offset: usize) -> String {
         debug!("rewrite_paren, width: {}, offset: {}", width, offset);
         // 1 is for opening paren, 2 is for opening+closing, we want to keep the closing
         // paren on the same line as the subexpr
@@ -130,7 +130,7 @@ impl<'a> FmtVisitor<'a> {
         format!("({})", subexpr_str)
     }
 
-    fn rewrite_struct_lit(&mut self,
+    fn rewrite_struct_lit(&self,
                           path: &ast::Path,
                           fields: &[ast::Field],
                           base: Option<&ast::Expr>,
@@ -176,53 +176,20 @@ impl<'a> FmtVisitor<'a> {
         // }
     }
 
-    fn rewrite_field(&mut self, field: &ast::Field, width: usize, offset: usize) -> String {
+    fn rewrite_field(&self, field: &ast::Field, width: usize, offset: usize) -> String {
         let name = &token::get_ident(field.ident.node);
         let overhead = name.len() + 2;
         let expr = self.rewrite_expr(&field.expr, width - overhead, offset + overhead);
         format!("{}: {}", name, expr)
     }
 
-    fn rewrite_tuple_lit(&mut self, items: &[ptr::P<ast::Expr>], width: usize, offset: usize)
-        -> String {
-        // opening paren
-        let indent = offset + 1;
-        // In case of length 1, need a trailing comma
-        if items.len() == 1 {
-            return format!("({},)", self.rewrite_expr(&*items[0], width - 3, indent));
-        }
-        // Only last line has width-1 as budget, other may take max_width
-        let item_strs: Vec<_> =
-            items.iter()
-                 .enumerate()
-                 .map(|(i, item)| self.rewrite_expr(
-                    item,
-                    // last line : given width (minus "("+")"), other lines : max_width
-                    // (minus "("+","))
-                    if i == items.len() - 1 { width - 2 } else { config!(max_width) - indent - 2 },
-                    indent))
-                 .collect();
-        let tactics = if item_strs.iter().any(|s| s.contains('\n')) {
-            ListTactic::Vertical
-        } else {
-            ListTactic::HorizontalVertical
-        };
-        // FIXME handle comments
-        let item_strs: Vec<_> = item_strs.into_iter().map(|s| (s, String::new())).collect();
-        let fmt = ListFormatting {
-            tactic: tactics,
-            separator: ",",
-            trailing_separator: SeparatorTactic::Never,
-            indent: indent,
-            h_width: width - 2,
-            v_width: width - 2,
-        };
-        let item_str = write_list(&item_strs, &fmt);
-        format!("({})", item_str)
+    fn rewrite_tuple_lit(&self, items: &[ptr::P<ast::Expr>], width: usize, offset: usize)
+        -> Option<String>
+    {
+        rewrite_tuple(items, width, offset, &|exp, w, o| self.rewrite_expr(exp, w, o))
     }
 
-
-    pub fn rewrite_expr(&mut self, expr: &ast::Expr, width: usize, offset: usize) -> String {
+    pub fn rewrite_expr(&self, expr: &ast::Expr, width: usize, offset: usize) -> String {
         match expr.node {
             ast::Expr_::ExprLit(ref l) => {
                 match l.node {
@@ -248,7 +215,10 @@ impl<'a> FmtVisitor<'a> {
                                                offset);
             }
             ast::Expr_::ExprTup(ref items) => {
-                return self.rewrite_tuple_lit(items, width, offset);
+                match self.rewrite_tuple_lit(items, width, offset) {
+                    Some(s) => { return s; }
+                    None => {}
+                }
             }
             _ => {}
         }

src/lists.rs

@@ -10,6 +10,7 @@
 
 use utils::make_indent;
 use rustc_serialize::{Decodable, Decoder};
+use std::borrow::Borrow;
 
 #[derive(Eq, PartialEq, Debug, Copy, Clone)]
 pub enum ListTactic {
@@ -163,7 +164,7 @@ fn needs_trailing_separator(separator_tactic: SeparatorTactic, list_tactic: List
     }
 }
 
-fn calculate_width(items:&[(String, String)]) -> usize {
+fn calculate_width(items: &[(String, String)]) -> usize {
     let missed_width = items.iter().map(|&(_, ref s)| {
         let text_len = s.trim().len();
         if text_len > 0 {
@@ -176,3 +177,53 @@ fn calculate_width(items:&[(String, String)]) -> usize {
     let item_width = items.iter().map(|&(ref s, _)| s.len()).fold(0, |a, l| a + l);
     missed_width + item_width
 }
+
+
+/// Format a tuple within given offset and width
+pub fn rewrite_tuple<Item, ItemPtr>(items: &[ItemPtr],
+                                    width: usize,
+                                    offset: usize,
+                                    rewriter: &Fn(&Item, usize, usize) -> String)
+                                    -> Option<String>
+    where ItemPtr: Borrow<Item>
+{
+    debug!("rewrite_tuple: width: {}, offset: {}", width, offset);
+    // opening paren
+    let indent = offset + 1;
+    // In case of length 1, need a trailing comma
+    if items.len() == 1 {
+            // 3 = "(" + ",)"
+            if width <= 3 {
+                return None;
+            } else {
+                return Some(format!("({},)", rewriter(items[0].borrow(), width - 3, indent)));
+            }
+        }
+    // 2 = "(" + ","
+    if width <= 2 {
+            return None;
+        }
+    // Only las line has width - 1 budget, other may take max_width
+    // FIXME handle comments
+    let item_strs: Vec<_> =
+        items.iter()
+             .enumerate()
+             .map(|(i, item)| (rewriter(item.borrow(),
+                                        // last line : width - "(" - ")"
+                                        // other lines : max_widht - "(" - ","
+                                        if i == items.len() - 1 {
+                                            width - 2
+                                        } else {
+                                            config!(max_width) - indent - 2
+                                        },
+                                        indent),
+                               String::new()))
+             .collect();
+    let fmt = ListFormatting { tactic: ListTactic::HorizontalVertical,
+                               separator: ",",
+                               trailing_separator: SeparatorTactic::Never,
+                               indent: indent,
+                               h_width: width - 2,
+                               v_width: width - 2, };
+    Some(format!("({})", write_list(&item_strs, &fmt)))
+}