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, method calls, and try shorthand (?).
  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_indent` is the indent to use for
  23 /// blocks in the parent/root/base of the chain (and the rest of the chain's
  24 /// alignment).
  25 /// E.g., `let foo = { aaaa; bbb; ccc }.bar.baz();`, we would layout for the
  26 /// following values of `chain_indent`:
  27 /// Block:
  28 /// ```
  29 /// let foo = {
  30 ///     aaaa;
  31 ///     bbb;
  32 ///     ccc
  33 /// }.bar
  34 ///     .baz();
  35 /// ```
  36 /// Visual:
  37 /// ```
  38 /// let foo = {
  39 ///               aaaa;
  40 ///               bbb;
  41 ///               ccc
  42 ///           }
  43 ///           .bar
  44 ///           .baz();
  45 /// ```
  46 ///
  47 /// If the first item in the chain is a block expression, we align the dots with
  48 /// the braces.
  49 /// Block:
  50 /// ```
  51 /// let a = foo.bar
  52 ///     .baz()
  53 ///     .qux
  54 /// ```
  55 /// Visual:
  56 /// ```
  57 /// let a = foo.bar
  58 ///            .baz()
  59 ///            .qux
  60 /// ```
  61
  62 use shape::Shape;
  63 use config::IndentStyle;
  64 use expr::rewrite_call;
  65 use macros::convert_try_mac;
  66 use rewrite::{Rewrite, RewriteContext};
  67 use utils::{first_line_width, last_line_extendable, last_line_width, mk_sp,
  68             trimmed_last_line_width, wrap_str};
  69
  70 use std::cmp::min;
  71 use std::iter;
  72 use syntax::{ast, ptr};
  73 use syntax::codemap::Span;
  74
  75 pub fn rewrite_chain(expr: &ast::Expr, context: &RewriteContext, shape: Shape) -> Option<String> {
  76     debug!("rewrite_chain {:?}", shape);
  77     let total_span = expr.span;
  78     let (parent, subexpr_list) = make_subexpr_list(expr, context);
  79
  80     // Bail out if the chain is just try sugar, i.e., an expression followed by
  81     // any number of `?`s.
  82     if chain_only_try(&subexpr_list) {
  83         return rewrite_try(&parent, subexpr_list.len(), context, shape);
  84     }
  85     let suffix_try_num = subexpr_list.iter().take_while(|e| is_try(e)).count();
  86     let prefix_try_num = subexpr_list.iter().rev().take_while(|e| is_try(e)).count();
  87
  88     // Parent is the first item in the chain, e.g., `foo` in `foo.bar.baz()`.
  89     let parent_shape = if is_block_expr(context, &parent, "\n") {
  90         match context.config.chain_indent() {
  91             IndentStyle::Visual => shape.visual_indent(0),
  92             IndentStyle::Block => shape,
  93         }
  94     } else {
  95         shape
  96     };
  97     let parent_rewrite = parent
  98         .rewrite(context, parent_shape)
  99         .map(|parent_rw| parent_rw + &repeat_try(prefix_try_num))?;
 100     let parent_rewrite_contains_newline = parent_rewrite.contains('\n');
 101     let is_small_parent = parent_rewrite.len() <= context.config.tab_spaces();
 102
 103     // Decide how to layout the rest of the chain. `extend` is true if we can
 104     // put the first non-parent item on the same line as the parent.
 105     let (nested_shape, extend) = if !parent_rewrite_contains_newline && is_continuable(&parent) {
 106         (
 107             chain_indent(context, shape.add_offset(parent_rewrite.len())),
 108             context.config.chain_indent() == IndentStyle::Visual || is_small_parent,
 109         )
 110     } else if is_block_expr(context, &parent, &parent_rewrite) {
 111         match context.config.chain_indent() {
 112             // Try to put the first child on the same line with parent's last line
 113             IndentStyle::Block => (parent_shape.block_indent(context.config.tab_spaces()), true),
 114             // The parent is a block, so align the rest of the chain with the closing
 115             // brace.
 116             IndentStyle::Visual => (parent_shape, false),
 117         }
 118     } else {
 119         (
 120             chain_indent(context, shape.add_offset(parent_rewrite.len())),
 121             false,
 122         )
 123     };
 124
 125     let other_child_shape = nested_shape.with_max_width(context.config);
 126
 127     let first_child_shape = if extend {
 128         let overhead = last_line_width(&parent_rewrite);
 129         let offset = trimmed_last_line_width(&parent_rewrite) + prefix_try_num;
 130         match context.config.chain_indent() {
 131             IndentStyle::Visual => parent_shape.offset_left(overhead)?,
 132             IndentStyle::Block => parent_shape.block().offset_left(offset)?,
 133         }
 134     } else {
 135         other_child_shape
 136     };
 137     debug!(
 138         "child_shapes {:?} {:?}",
 139         first_child_shape,
 140         other_child_shape
 141     );
 142
 143     let child_shape_iter = Some(first_child_shape)
 144         .into_iter()
 145         .chain(iter::repeat(other_child_shape));
 146     let subexpr_num = subexpr_list.len();
 147     let last_subexpr = &subexpr_list[suffix_try_num];
 148     let subexpr_list = &subexpr_list[suffix_try_num..subexpr_num - prefix_try_num];
 149     let iter = subexpr_list.iter().skip(1).rev().zip(child_shape_iter);
 150     let mut rewrites = iter.map(|(e, shape)| {
 151         rewrite_chain_subexpr(e, total_span, context, shape)
 152     }).collect::<Option<Vec<_>>>()?;
 153
 154     // Total of all items excluding the last.
 155     let extend_last_subexpr = last_line_extendable(&parent_rewrite) && rewrites.is_empty();
 156     let almost_total = if extend_last_subexpr {
 157         last_line_width(&parent_rewrite)
 158     } else {
 159         rewrites.iter().fold(0, |a, b| a + b.len()) + parent_rewrite.len()
 160     } + suffix_try_num;
 161     let one_line_budget = if rewrites.is_empty() && !context.config.chain_split_single_child() {
 162         shape.width
 163     } else {
 164         min(shape.width, context.config.chain_width())
 165     };
 166     let all_in_one_line = !parent_rewrite_contains_newline
 167         && rewrites.iter().all(|s| !s.contains('\n'))
 168         && almost_total < one_line_budget;
 169     let last_shape = {
 170         let last_shape = if rewrites.len() == 0 {
 171             first_child_shape
 172         } else {
 173             other_child_shape
 174         };
 175         match context.config.chain_indent() {
 176             IndentStyle::Visual => last_shape.sub_width(shape.rhs_overhead(context.config))?,
 177             IndentStyle::Block => last_shape,
 178         }
 179     };
 180     let last_shape = last_shape.sub_width(suffix_try_num)?;
 181
 182     // Rewrite the last child. The last child of a chain requires special treatment. We need to
 183     // know whether 'overflowing' the last child make a better formatting:
 184     //
 185     // A chain with overflowing the last child:
 186     // ```
 187     // parent.child1.child2.last_child(
 188     //     a,
 189     //     b,
 190     //     c,
 191     // )
 192     // ```
 193     //
 194     // A chain without overflowing the last child (in vertical layout):
 195     // ```
 196     // parent
 197     //     .child1
 198     //     .child2
 199     //     .last_child(a, b, c)
 200     // ```
 201     //
 202     // In particular, overflowing is effective when the last child is a method with a multi-lined
 203     // block-like argument (e.g. closure):
 204     // ```
 205     // parent.child1.child2.last_child(|a, b, c| {
 206     //     let x = foo(a, b, c);
 207     //     let y = bar(a, b, c);
 208     //
 209     //     // ...
 210     //
 211     //     result
 212     // })
 213     // ```
 214
 215     // `rewrite_last` rewrites the last child on its own line. We use a closure here instead of
 216     // directly calling `rewrite_chain_subexpr()` to avoid exponential blowup.
 217     let rewrite_last = || rewrite_chain_subexpr(last_subexpr, total_span, context, last_shape);
 218     let (last_subexpr_str, fits_single_line) = if all_in_one_line || extend_last_subexpr {
 219         // First we try to 'overflow' the last child and see if it looks better than using
 220         // vertical layout.
 221         parent_shape.offset_left(almost_total).map(|shape| {
 222             if let Some(rw) = rewrite_chain_subexpr(last_subexpr, total_span, context, shape) {
 223                 // We allow overflowing here only if both of the following conditions match:
 224                 // 1. The entire chain fits in a single line expect the last child.
 225                 // 2. `last_child_str.lines().count() >= 5`.
 226                 let line_count = rw.lines().count();
 227                 let fits_single_line = almost_total + first_line_width(&rw) <= one_line_budget;
 228                 if fits_single_line && line_count >= 5 {
 229                     (Some(rw), true)
 230                 } else {
 231                     // We could not know whether overflowing is better than using vertical layout,
 232                     // just by looking at the overflowed rewrite. Now we rewrite the last child
 233                     // on its own line, and compare two rewrites to choose which is better.
 234                     match rewrite_last() {
 235                         Some(ref new_rw) if !fits_single_line => (Some(new_rw.clone()), false),
 236                         Some(ref new_rw) if new_rw.lines().count() >= line_count => {
 237                             (Some(rw), fits_single_line)
 238                         }
 239                         new_rw @ Some(..) => (new_rw, false),
 240                         _ => (Some(rw), fits_single_line),
 241                     }
 242                 }
 243             } else {
 244                 (rewrite_last(), false)
 245             }
 246         })?
 247     } else {
 248         (rewrite_last(), false)
 249     };
 250     rewrites.push(last_subexpr_str?);
 251
 252     let connector = if fits_single_line && !parent_rewrite_contains_newline {
 253         // Yay, we can put everything on one line.
 254         String::new()
 255     } else {
 256         // Use new lines.
 257         if context.force_one_line_chain {
 258             return None;
 259         }
 260         format!("\n{}", nested_shape.indent.to_string(context.config))
 261     };
 262
 263     let first_connector = if is_small_parent || fits_single_line
 264         || last_line_extendable(&parent_rewrite)
 265         || context.config.chain_indent() == IndentStyle::Visual
 266     {
 267         ""
 268     } else {
 269         connector.as_str()
 270     };
 271
 272     let result = if is_small_parent && rewrites.len() > 1 {
 273         let second_connector = if fits_single_line || rewrites[1] == "?"
 274             || last_line_extendable(&rewrites[0])
 275             || context.config.chain_indent() == IndentStyle::Visual
 276         {
 277             ""
 278         } else {
 279             &connector
 280         };
 281         format!(
 282             "{}{}{}{}{}",
 283             parent_rewrite,
 284             first_connector,
 285             rewrites[0],
 286             second_connector,
 287             join_rewrites(&rewrites[1..], &connector)
 288         )
 289     } else {
 290         format!(
 291             "{}{}{}",
 292             parent_rewrite,
 293             first_connector,
 294             join_rewrites(&rewrites, &connector)
 295         )
 296     };
 297     let result = format!("{}{}", result, repeat_try(suffix_try_num));
 298     if context.config.chain_indent() == IndentStyle::Visual {
 299         wrap_str(result, context.config.max_width(), shape)
 300     } else {
 301         Some(result)
 302     }
 303 }
 304
 305 // True if the chain is only `?`s.
 306 fn chain_only_try(exprs: &[ast::Expr]) -> bool {
 307     exprs.iter().all(|e| {
 308         if let ast::ExprKind::Try(_) = e.node {
 309             true
 310         } else {
 311             false
 312         }
 313     })
 314 }
 315
 316 // Try to rewrite and replace the last non-try child. Return `true` if
 317 // replacing succeeds.
 318 fn repeat_try(try_count: usize) -> String {
 319     iter::repeat("?").take(try_count).collect::<String>()
 320 }
 321
 322 fn rewrite_try(
 323     expr: &ast::Expr,
 324     try_count: usize,
 325     context: &RewriteContext,
 326     shape: Shape,
 327 ) -> Option<String> {
 328     let sub_expr = expr.rewrite(context, shape.sub_width(try_count)?)?;
 329     Some(format!("{}{}", sub_expr, repeat_try(try_count)))
 330 }
 331
 332 fn join_rewrites(rewrites: &[String], connector: &str) -> String {
 333     let mut rewrite_iter = rewrites.iter();
 334     let mut result = rewrite_iter.next().unwrap().clone();
 335
 336     for rewrite in rewrite_iter {
 337         if rewrite != "?" {
 338             result.push_str(connector);
 339         }
 340         result.push_str(&rewrite[..]);
 341     }
 342
 343     result
 344 }
 345
 346 // States whether an expression's last line exclusively consists of closing
 347 // parens, braces, and brackets in its idiomatic formatting.
 348 fn is_block_expr(context: &RewriteContext, expr: &ast::Expr, repr: &str) -> bool {
 349     match expr.node {
 350         ast::ExprKind::Mac(..) | ast::ExprKind::Call(..) => {
 351             context.use_block_indent() && repr.contains('\n')
 352         }
 353         ast::ExprKind::Struct(..) |
 354         ast::ExprKind::While(..) |
 355         ast::ExprKind::WhileLet(..) |
 356         ast::ExprKind::If(..) |
 357         ast::ExprKind::IfLet(..) |
 358         ast::ExprKind::Block(..) |
 359         ast::ExprKind::Loop(..) |
 360         ast::ExprKind::ForLoop(..) |
 361         ast::ExprKind::Match(..) => repr.contains('\n'),
 362         ast::ExprKind::Paren(ref expr) |
 363         ast::ExprKind::Binary(_, _, ref expr) |
 364         ast::ExprKind::Index(_, ref expr) |
 365         ast::ExprKind::Unary(_, ref expr) => is_block_expr(context, expr, repr),
 366         _ => false,
 367     }
 368 }
 369
 370 // Returns the root of the chain and a Vec of the prefixes of the rest of the chain.
 371 // E.g., for input `a.b.c` we return (`a`, [`a.b.c`, `a.b`])
 372 fn make_subexpr_list(expr: &ast::Expr, context: &RewriteContext) -> (ast::Expr, Vec<ast::Expr>) {
 373     let mut subexpr_list = vec![expr.clone()];
 374
 375     while let Some(subexpr) = pop_expr_chain(subexpr_list.last().unwrap(), context) {
 376         subexpr_list.push(subexpr.clone());
 377     }
 378
 379     let parent = subexpr_list.pop().unwrap();
 380     (parent, subexpr_list)
 381 }
 382
 383 fn chain_indent(context: &RewriteContext, shape: Shape) -> Shape {
 384     match context.config.chain_indent() {
 385         IndentStyle::Visual => shape.visual_indent(0),
 386         IndentStyle::Block => shape
 387             .block_indent(context.config.tab_spaces())
 388             .with_max_width(context.config),
 389     }
 390 }
 391
 392 // Returns the expression's subexpression, if it exists. When the subexpr
 393 // is a try! macro, we'll convert it to shorthand when the option is set.
 394 fn pop_expr_chain(expr: &ast::Expr, context: &RewriteContext) -> Option<ast::Expr> {
 395     match expr.node {
 396         ast::ExprKind::MethodCall(_, ref expressions) => {
 397             Some(convert_try(&expressions[0], context))
 398         }
 399         ast::ExprKind::TupField(ref subexpr, _) |
 400         ast::ExprKind::Field(ref subexpr, _) |
 401         ast::ExprKind::Try(ref subexpr) => Some(convert_try(subexpr, context)),
 402         _ => None,
 403     }
 404 }
 405
 406 fn convert_try(expr: &ast::Expr, context: &RewriteContext) -> ast::Expr {
 407     match expr.node {
 408         ast::ExprKind::Mac(ref mac) if context.config.use_try_shorthand() => {
 409             if let Some(subexpr) = convert_try_mac(mac, context) {
 410                 subexpr
 411             } else {
 412                 expr.clone()
 413             }
 414         }
 415         _ => expr.clone(),
 416     }
 417 }
 418
 419 // Rewrite the last element in the chain `expr`. E.g., given `a.b.c` we rewrite
 420 // `.c`.
 421 fn rewrite_chain_subexpr(
 422     expr: &ast::Expr,
 423     span: Span,
 424     context: &RewriteContext,
 425     shape: Shape,
 426 ) -> Option<String> {
 427     let rewrite_element = |expr_str: String| if expr_str.len() <= shape.width {
 428         Some(expr_str)
 429     } else {
 430         None
 431     };
 432
 433     match expr.node {
 434         ast::ExprKind::MethodCall(ref segment, ref expressions) => {
 435             let types = match segment.parameters {
 436                 Some(ref params) => match **params {
 437                     ast::PathParameters::AngleBracketed(ref data) => &data.types[..],
 438                     _ => &[],
 439                 },
 440                 _ => &[],
 441             };
 442             rewrite_method_call(segment.identifier, types, expressions, span, context, shape)
 443         }
 444         ast::ExprKind::Field(_, ref field) => rewrite_element(format!(".{}", field.node)),
 445         ast::ExprKind::TupField(ref expr, ref field) => {
 446             let space = match expr.node {
 447                 ast::ExprKind::TupField(..) => " ",
 448                 _ => "",
 449             };
 450             rewrite_element(format!("{}.{}", space, field.node))
 451         }
 452         ast::ExprKind::Try(_) => rewrite_element(String::from("?")),
 453         _ => unreachable!(),
 454     }
 455 }
 456
 457 // Determines if we can continue formatting a given expression on the same line.
 458 fn is_continuable(expr: &ast::Expr) -> bool {
 459     match expr.node {
 460         ast::ExprKind::Path(..) => true,
 461         _ => false,
 462     }
 463 }
 464
 465 fn is_try(expr: &ast::Expr) -> bool {
 466     match expr.node {
 467         ast::ExprKind::Try(..) => true,
 468         _ => false,
 469     }
 470 }
 471
 472 fn rewrite_method_call(
 473     method_name: ast::Ident,
 474     types: &[ptr::P<ast::Ty>],
 475     args: &[ptr::P<ast::Expr>],
 476     span: Span,
 477     context: &RewriteContext,
 478     shape: Shape,
 479 ) -> Option<String> {
 480     let (lo, type_str) = if types.is_empty() {
 481         (args[0].span.hi(), String::new())
 482     } else {
 483         let type_list = types
 484             .iter()
 485             .map(|ty| ty.rewrite(context, shape))
 486             .collect::<Option<Vec<_>>>()?;
 487
 488         let type_str = if context.config.spaces_within_angle_brackets() && !type_list.is_empty() {
 489             format!("::< {} >", type_list.join(", "))
 490         } else {
 491             format!("::<{}>", type_list.join(", "))
 492         };
 493
 494         (types.last().unwrap().span.hi(), type_str)
 495     };
 496
 497     let callee_str = format!(".{}{}", method_name, type_str);
 498     let span = mk_sp(lo, span.hi());
 499
 500     rewrite_call(context, &callee_str, &args[1..], span, shape)
 501 }