src/chains.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 /// Formatting of chained expressions, i.e. expressions which are chained by
  12 /// dots: struct and enum field access and method calls.
  13 ///
  14 /// Instead of walking these subexpressions one-by-one, as is our usual strategy
  15 /// for expression formatting, we collect maximal sequences of these expressions
  16 /// and handle them simultaneously.
  17 ///
  18 /// Whenever possible, the entire chain is put on a single line. If that fails,
  19 /// we put each subexpression on a separate, much like the (default) function
  20 /// argument function argument strategy.
  21 ///
  22 /// Depends on config options: `chain_base_indent` is the indent to use for
  23 /// blocks in the parent/root/base of the chain.
  24 /// E.g., `let foo = { aaaa; bbb; ccc }.bar.baz();`, we would layout for the
  25 /// following values of `chain_base_indent`:
  26 /// Visual:
  27 /// ```
  28 /// let foo = {
  29 ///               aaaa;
  30 ///               bbb;
  31 ///               ccc
  32 ///           }
  33 ///           .bar
  34 ///           .baz();
  35 /// ```
  36 /// Inherit:
  37 /// ```
  38 /// let foo = {
  39 ///     aaaa;
  40 ///     bbb;
  41 ///     ccc
  42 /// }
  43 /// .bar
  44 /// .baz();
  45 /// ```
  46 /// Tabbed:
  47 /// ```
  48 /// let foo = {
  49 ///         aaaa;
  50 ///         bbb;
  51 ///         ccc
  52 ///     }
  53 ///     .bar
  54 ///     .baz();
  55 /// ```
  56 ///
  57 /// `chain_indent` dictates how the rest of the chain is aligned. This only seems
  58 /// to have an effect if the first non-root part of the chain is put on a
  59 /// newline, otherwise we align the dots:
  60 /// ```
  61 /// foo.bar
  62 ///    .baz()
  63 /// ```
  64 /// If the first item in the chain is a block expression, we align the dots with
  65 /// the braces.
  66 ///
  67 /// Otherwise:
  68 /// Visual:
  69 /// ```
  70 /// let a = foo(aaa, bbb)
  71 ///             .bar
  72 ///             .baz()
  73 /// ```
  74 /// Visual seems to be a tab indented from the indent of the whole expression.
  75 /// Inherit:
  76 /// ```
  77 /// let a = foo(aaa, bbb)
  78 /// .bar
  79 /// .baz()
  80 /// ```
  81 /// Tabbed:
  82 /// ```
  83 /// let a = foo(aaa, bbb)
  84 ///     .bar
  85 ///     .baz()
  86 /// ```
  87 /// `chains_overflow_last` applies only to chains where the last item is a
  88 /// method call. Usually, any line break in a chain sub-expression causes the
  89 /// whole chain to be split with newlines at each `.`. With `chains_overflow_last`
  90 /// true, then we allow the last method call to spill over multiple lines without
  91 /// forcing the rest of the chain to be split.
  92
  93
  94 use Indent;
  95 use rewrite::{Rewrite, RewriteContext};
  96 use utils::{wrap_str, first_line_width};
  97 use expr::rewrite_call;
  98 use config::BlockIndentStyle;
  99
 100 use syntax::{ast, ptr};
 101 use syntax::codemap::{mk_sp, Span};
 102
 103
 104 pub fn rewrite_chain(expr: &ast::Expr,
 105                      context: &RewriteContext,
 106                      width: usize,
 107                      offset: Indent)
 108                      -> Option<String> {
 109     let total_span = expr.span;
 110     let (parent, subexpr_list) = make_subexpr_list(expr);
 111
 112     // Parent is the first item in the chain, e.g., `foo` in `foo.bar.baz()`.
 113     let parent_block_indent = chain_base_indent(context, offset);
 114     let parent_context = &RewriteContext { block_indent: parent_block_indent, ..*context };
 115     let parent_rewrite = try_opt!(parent.rewrite(parent_context, width, offset));
 116
 117     // Decide how to layout the rest of the chain. `extend` is true if we can
 118     // put the first non-parent item on the same line as the parent.
 119     let (indent, extend) = if !parent_rewrite.contains('\n') && is_continuable(parent) ||
 120                               parent_rewrite.len() <= context.config.tab_spaces {
 121         // Try and put at least the first two items on the same line.
 122         (chain_indent(context, offset + Indent::new(0, parent_rewrite.len())), true)
 123     } else if is_block_expr(parent, &parent_rewrite) {
 124         // The parent is a block, so align the rest of the chain with the closing
 125         // brace.
 126         (parent_block_indent, false)
 127     } else if parent_rewrite.contains('\n') {
 128         (chain_indent(context, parent_block_indent.block_indent(context.config)), false)
 129     } else {
 130         (hacked_chain_indent(context, offset + Indent::new(0, parent_rewrite.len())), false)
 131     };
 132
 133     let max_width = try_opt!((width + offset.width()).checked_sub(indent.width()));
 134     let mut rewrites = try_opt!(subexpr_list.iter()
 135         .rev()
 136         .map(|e| rewrite_chain_subexpr(e, total_span, context, max_width, indent))
 137         .collect::<Option<Vec<_>>>());
 138
 139     // Total of all items excluding the last.
 140     let almost_total = rewrites[..rewrites.len() - 1]
 141         .iter()
 142         .fold(0, |a, b| a + first_line_width(b)) + parent_rewrite.len();
 143     let total_width = almost_total + first_line_width(rewrites.last().unwrap());
 144
 145     let veto_single_line = if context.config.take_source_hints && subexpr_list.len() > 1 {
 146         // Look at the source code. Unless all chain elements start on the same
 147         // line, we won't consider putting them on a single line either.
 148         let last_span = context.snippet(mk_sp(subexpr_list[1].span.hi, total_span.hi));
 149         let first_span = context.snippet(subexpr_list[1].span);
 150         let last_iter = last_span.chars().take_while(|c| c.is_whitespace());
 151
 152         first_span.chars().chain(last_iter).any(|c| c == '\n')
 153     } else {
 154         false
 155     };
 156
 157     let mut fits_single_line = !veto_single_line && total_width <= width;
 158     if fits_single_line {
 159         let len = rewrites.len();
 160         let (init, last) = rewrites.split_at_mut(len - 1);
 161         fits_single_line = init.iter().all(|s| !s.contains('\n'));
 162
 163         if fits_single_line {
 164             fits_single_line = match expr.node {
 165                 ref e @ ast::ExprKind::MethodCall(..) if context.config.chains_overflow_last => {
 166                     rewrite_method_call_with_overflow(e,
 167                                                       &mut last[0],
 168                                                       almost_total,
 169                                                       width,
 170                                                       total_span,
 171                                                       context,
 172                                                       offset)
 173                 }
 174                 _ => !last[0].contains('\n'),
 175             }
 176         }
 177     }
 178
 179     let connector = if fits_single_line && !parent_rewrite.contains('\n') {
 180         // Yay, we can put everything on one line.
 181         String::new()
 182     } else {
 183         // Use new lines.
 184         format!("\n{}", indent.to_string(context.config))
 185     };
 186
 187     let first_connector = if extend {
 188         ""
 189     } else {
 190         &connector
 191     };
 192
 193     wrap_str(format!("{}{}{}",
 194                      parent_rewrite,
 195                      first_connector,
 196                      rewrites.join(&connector)),
 197              context.config.max_width,
 198              width,
 199              offset)
 200 }
 201
 202 // States whether an expression's last line exclusively consists of closing
 203 // parens, braces, and brackets in its idiomatic formatting.
 204 fn is_block_expr(expr: &ast::Expr, repr: &str) -> bool {
 205     match expr.node {
 206         ast::ExprKind::Struct(..) |
 207         ast::ExprKind::While(..) |
 208         ast::ExprKind::WhileLet(..) |
 209         ast::ExprKind::If(..) |
 210         ast::ExprKind::IfLet(..) |
 211         ast::ExprKind::Block(..) |
 212         ast::ExprKind::Loop(..) |
 213         ast::ExprKind::ForLoop(..) |
 214         ast::ExprKind::Match(..) => repr.contains('\n'),
 215         ast::ExprKind::Paren(ref expr) |
 216         ast::ExprKind::Binary(_, _, ref expr) |
 217         ast::ExprKind::Index(_, ref expr) |
 218         ast::ExprKind::Unary(_, ref expr) => is_block_expr(expr, repr),
 219         _ => false,
 220     }
 221 }
 222
 223 // Returns the root of the chain and a Vec of the prefixes of the rest of the chain.
 224 // E.g., for input `a.b.c` we return (`a`, [`a.b.c`, `a.b`])
 225 fn make_subexpr_list(mut expr: &ast::Expr) -> (&ast::Expr, Vec<&ast::Expr>) {
 226     fn pop_expr_chain(expr: &ast::Expr) -> Option<&ast::Expr> {
 227         match expr.node {
 228             ast::ExprKind::MethodCall(_, _, ref expressions) => Some(&expressions[0]),
 229             ast::ExprKind::TupField(ref subexpr, _) |
 230             ast::ExprKind::Field(ref subexpr, _) => Some(subexpr),
 231             _ => None,
 232         }
 233     }
 234
 235     let mut subexpr_list = vec![expr];
 236
 237     while let Some(subexpr) = pop_expr_chain(expr) {
 238         subexpr_list.push(subexpr);
 239         expr = subexpr;
 240     }
 241
 242     let parent = subexpr_list.pop().unwrap();
 243     (parent, subexpr_list)
 244 }
 245
 246 fn chain_base_indent(context: &RewriteContext, offset: Indent) -> Indent {
 247     match context.config.chain_base_indent {
 248         BlockIndentStyle::Visual => offset,
 249         BlockIndentStyle::Inherit => context.block_indent,
 250         BlockIndentStyle::Tabbed => context.block_indent.block_indent(context.config),
 251     }
 252 }
 253
 254 fn chain_indent(context: &RewriteContext, offset: Indent) -> Indent {
 255     match context.config.chain_indent {
 256         BlockIndentStyle::Visual => offset,
 257         BlockIndentStyle::Inherit => context.block_indent,
 258         BlockIndentStyle::Tabbed => context.block_indent.block_indent(context.config),
 259     }
 260 }
 261
 262 // Temporary hack - ignores visual indenting because this function should be
 263 // called where it is not possible to use visual indentation.
 264 fn hacked_chain_indent(context: &RewriteContext, _offset: Indent) -> Indent {
 265     match context.config.chain_indent {
 266         BlockIndentStyle::Inherit => context.block_indent,
 267         BlockIndentStyle::Visual | BlockIndentStyle::Tabbed => {
 268             context.block_indent.block_indent(context.config)
 269         }
 270     }
 271 }
 272
 273 fn rewrite_method_call_with_overflow(expr_kind: &ast::ExprKind,
 274                                      last: &mut String,
 275                                      almost_total: usize,
 276                                      width: usize,
 277                                      total_span: Span,
 278                                      context: &RewriteContext,
 279                                      offset: Indent)
 280                                      -> bool {
 281     if let &ast::ExprKind::MethodCall(ref method_name, ref types, ref expressions) = expr_kind {
 282         let budget = match width.checked_sub(almost_total) {
 283             Some(b) => b,
 284             None => return false,
 285         };
 286         let mut last_rewrite = rewrite_method_call(method_name.node,
 287                                                    types,
 288                                                    expressions,
 289                                                    total_span,
 290                                                    context,
 291                                                    budget,
 292                                                    offset + almost_total);
 293
 294         if let Some(ref mut s) = last_rewrite {
 295             ::std::mem::swap(s, last);
 296             true
 297         } else {
 298             false
 299         }
 300     } else {
 301         unreachable!();
 302     }
 303 }
 304
 305 // Rewrite the last element in the chain `expr`. E.g., given `a.b.c` we rewrite
 306 // `.c`.
 307 fn rewrite_chain_subexpr(expr: &ast::Expr,
 308                          span: Span,
 309                          context: &RewriteContext,
 310                          width: usize,
 311                          offset: Indent)
 312                          -> Option<String> {
 313     match expr.node {
 314         ast::ExprKind::MethodCall(ref method_name, ref types, ref expressions) => {
 315             let inner = &RewriteContext { block_indent: offset, ..*context };
 316             rewrite_method_call(method_name.node,
 317                                 types,
 318                                 expressions,
 319                                 span,
 320                                 inner,
 321                                 width,
 322                                 offset)
 323         }
 324         ast::ExprKind::Field(_, ref field) => {
 325             let s = format!(".{}", field.node);
 326             if s.len() <= width {
 327                 Some(s)
 328             } else {
 329                 None
 330             }
 331         }
 332         ast::ExprKind::TupField(_, ref field) => {
 333             let s = format!(".{}", field.node);
 334             if s.len() <= width {
 335                 Some(s)
 336             } else {
 337                 None
 338             }
 339         }
 340         _ => unreachable!(),
 341     }
 342 }
 343
 344 // Determines if we can continue formatting a given expression on the same line.
 345 fn is_continuable(expr: &ast::Expr) -> bool {
 346     match expr.node {
 347         ast::ExprKind::Path(..) => true,
 348         _ => false,
 349     }
 350 }
 351
 352 fn rewrite_method_call(method_name: ast::Ident,
 353                        types: &[ptr::P<ast::Ty>],
 354                        args: &[ptr::P<ast::Expr>],
 355                        span: Span,
 356                        context: &RewriteContext,
 357                        width: usize,
 358                        offset: Indent)
 359                        -> Option<String> {
 360     let (lo, type_str) = if types.is_empty() {
 361         (args[0].span.hi, String::new())
 362     } else {
 363         let type_list: Vec<_> = try_opt!(types.iter()
 364             .map(|ty| ty.rewrite(context, width, offset))
 365             .collect());
 366
 367         (types.last().unwrap().span.hi, format!("::<{}>", type_list.join(", ")))
 368     };
 369
 370     let callee_str = format!(".{}{}", method_name, type_str);
 371     let span = mk_sp(lo, span.hi);
 372
 373     rewrite_call(context, &callee_str, &args[1..], span, width, offset)
 374 }