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);
 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_subexr = last_line_extendable(&parent_rewrite) && rewrites.is_empty();
 156     let almost_total = if extend_last_subexr {
 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_one_line_max())
 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 = match context.config.chain_indent() {
 170         IndentStyle::Visual => other_child_shape.sub_width(shape.rhs_overhead(context.config))?,
 171         IndentStyle::Block => other_child_shape,
 172     };
 173     let last_shape = last_shape.sub_width(suffix_try_num)?;
 174
 175     // Rewrite the last child. The last child of a chain requires special treatment. We need to
 176     // know whether 'overflowing' the last child make a better formatting:
 177     //
 178     // A chain with overflowing the last child:
 179     // ```
 180     // parent.child1.child2.last_child(
 181     //     a,
 182     //     b,
 183     //     c,
 184     // )
 185     // ```
 186     //
 187     // A chain without overflowing the last child (in vertical layout):
 188     // ```
 189     // parent
 190     //     .child1
 191     //     .child2
 192     //     .last_child(a, b, c)
 193     // ```
 194     //
 195     // In particular, overflowing is effective when the last child is a method with a multi-lined
 196     // block-like argument (e.g. closure):
 197     // ```
 198     // parent.child1.chlid2.last_child(|a, b, c| {
 199     //     let x = foo(a, b, c);
 200     //     let y = bar(a, b, c);
 201     //
 202     //     // ...
 203     //
 204     //     result
 205     // })
 206     // ```
 207
 208     // `rewrite_last` rewrites the last child on its own line. We use a closure here instead of
 209     // directly calling `rewrite_chain_subexpr()` to avoid exponential blowup.
 210     let rewrite_last = || rewrite_chain_subexpr(last_subexpr, total_span, context, last_shape);
 211     let (last_subexpr_str, fits_single_line) = if all_in_one_line || extend_last_subexr {
 212         // First we try to 'overflow' the last child and see if it looks better than using
 213         // vertical layout.
 214         parent_shape.offset_left(almost_total).map(|shape| {
 215             if let Some(rw) = rewrite_chain_subexpr(last_subexpr, total_span, context, shape) {
 216                 // We allow overflowing here only if both of the following conditions match:
 217                 // 1. The entire chain fits in a single line expect the last child.
 218                 // 2. `last_chlid_str.lines().count() >= 5`.
 219                 let line_count = rw.lines().count();
 220                 let fits_single_line = almost_total + first_line_width(&rw) <= one_line_budget;
 221                 if fits_single_line && line_count >= 5 {
 222                     (Some(rw), true)
 223                 } else {
 224                     // We could not know whether overflowing is better than using vertical layout,
 225                     // just by looking at the overflowed rewrite. Now we rewrite the last child
 226                     // on its own line, and compare two rewrites to choose which is better.
 227                     match rewrite_last() {
 228                         Some(ref new_rw) if !fits_single_line => (Some(new_rw.clone()), false),
 229                         Some(ref new_rw) if new_rw.lines().count() >= line_count => {
 230                             (Some(rw), fits_single_line)
 231                         }
 232                         new_rw @ Some(..) => (new_rw, false),
 233                         _ => (Some(rw), fits_single_line),
 234                     }
 235                 }
 236             } else {
 237                 (rewrite_last(), false)
 238             }
 239         })?
 240     } else {
 241         (rewrite_last(), false)
 242     };
 243     rewrites.push(last_subexpr_str?);
 244
 245     let connector = if fits_single_line && !parent_rewrite_contains_newline {
 246         // Yay, we can put everything on one line.
 247         String::new()
 248     } else {
 249         // Use new lines.
 250         if context.force_one_line_chain {
 251             return None;
 252         }
 253         format!("\n{}", nested_shape.indent.to_string(context.config))
 254     };
 255
 256     let first_connector = if is_small_parent || fits_single_line
 257         || last_line_extendable(&parent_rewrite)
 258         || context.config.chain_indent() == IndentStyle::Visual
 259     {
 260         ""
 261     } else {
 262         connector.as_str()
 263     };
 264
 265     let result = if is_small_parent && rewrites.len() > 1 {
 266         let second_connector = if fits_single_line || rewrites[1] == "?"
 267             || last_line_extendable(&rewrites[0])
 268             || context.config.chain_indent() == IndentStyle::Visual
 269         {
 270             ""
 271         } else {
 272             &connector
 273         };
 274         format!(
 275             "{}{}{}{}{}",
 276             parent_rewrite,
 277             first_connector,
 278             rewrites[0],
 279             second_connector,
 280             join_rewrites(&rewrites[1..], &connector)
 281         )
 282     } else {
 283         format!(
 284             "{}{}{}",
 285             parent_rewrite,
 286             first_connector,
 287             join_rewrites(&rewrites, &connector)
 288         )
 289     };
 290     let result = format!("{}{}", result, repeat_try(suffix_try_num));
 291     if context.config.chain_indent() == IndentStyle::Visual {
 292         wrap_str(result, context.config.max_width(), shape)
 293     } else {
 294         Some(result)
 295     }
 296 }
 297
 298 // True if the chain is only `?`s.
 299 fn chain_only_try(exprs: &[ast::Expr]) -> bool {
 300     exprs.iter().all(|e| if let ast::ExprKind::Try(_) = e.node {
 301         true
 302     } else {
 303         false
 304     })
 305 }
 306
 307 // Try to rewrite and replace the last non-try child. Return `true` if
 308 // replacing succeeds.
 309 fn repeat_try(try_count: usize) -> String {
 310     iter::repeat("?").take(try_count).collect::<String>()
 311 }
 312
 313 fn rewrite_try(
 314     expr: &ast::Expr,
 315     try_count: usize,
 316     context: &RewriteContext,
 317     shape: Shape,
 318 ) -> Option<String> {
 319     let sub_expr = expr.rewrite(context, shape.sub_width(try_count)?)?;
 320     Some(format!("{}{}", sub_expr, repeat_try(try_count)))
 321 }
 322
 323 fn join_rewrites(rewrites: &[String], connector: &str) -> String {
 324     let mut rewrite_iter = rewrites.iter();
 325     let mut result = rewrite_iter.next().unwrap().clone();
 326
 327     for rewrite in rewrite_iter {
 328         if rewrite != "?" {
 329             result.push_str(connector);
 330         }
 331         result.push_str(&rewrite[..]);
 332     }
 333
 334     result
 335 }
 336
 337 // States whether an expression's last line exclusively consists of closing
 338 // parens, braces, and brackets in its idiomatic formatting.
 339 fn is_block_expr(context: &RewriteContext, expr: &ast::Expr, repr: &str) -> bool {
 340     match expr.node {
 341         ast::ExprKind::Mac(..) | ast::ExprKind::Call(..) => {
 342             context.use_block_indent() && repr.contains('\n')
 343         }
 344         ast::ExprKind::Struct(..) |
 345         ast::ExprKind::While(..) |
 346         ast::ExprKind::WhileLet(..) |
 347         ast::ExprKind::If(..) |
 348         ast::ExprKind::IfLet(..) |
 349         ast::ExprKind::Block(..) |
 350         ast::ExprKind::Loop(..) |
 351         ast::ExprKind::ForLoop(..) |
 352         ast::ExprKind::Match(..) => repr.contains('\n'),
 353         ast::ExprKind::Paren(ref expr) |
 354         ast::ExprKind::Binary(_, _, ref expr) |
 355         ast::ExprKind::Index(_, ref expr) |
 356         ast::ExprKind::Unary(_, ref expr) => is_block_expr(context, expr, repr),
 357         _ => false,
 358     }
 359 }
 360
 361 // Returns the root of the chain and a Vec of the prefixes of the rest of the chain.
 362 // E.g., for input `a.b.c` we return (`a`, [`a.b.c`, `a.b`])
 363 fn make_subexpr_list(expr: &ast::Expr, context: &RewriteContext) -> (ast::Expr, Vec<ast::Expr>) {
 364     let mut subexpr_list = vec![expr.clone()];
 365
 366     while let Some(subexpr) = pop_expr_chain(subexpr_list.last().unwrap(), context) {
 367         subexpr_list.push(subexpr.clone());
 368     }
 369
 370     let parent = subexpr_list.pop().unwrap();
 371     (parent, subexpr_list)
 372 }
 373
 374 fn chain_indent(context: &RewriteContext, shape: Shape) -> Shape {
 375     match context.config.chain_indent() {
 376         IndentStyle::Visual => shape.visual_indent(0),
 377         IndentStyle::Block => shape
 378             .block_indent(context.config.tab_spaces())
 379             .with_max_width(context.config),
 380     }
 381 }
 382
 383 // Returns the expression's subexpression, if it exists. When the subexpr
 384 // is a try! macro, we'll convert it to shorthand when the option is set.
 385 fn pop_expr_chain(expr: &ast::Expr, context: &RewriteContext) -> Option<ast::Expr> {
 386     match expr.node {
 387         ast::ExprKind::MethodCall(_, ref expressions) => {
 388             Some(convert_try(&expressions[0], context))
 389         }
 390         ast::ExprKind::TupField(ref subexpr, _) |
 391         ast::ExprKind::Field(ref subexpr, _) |
 392         ast::ExprKind::Try(ref subexpr) => Some(convert_try(subexpr, context)),
 393         _ => None,
 394     }
 395 }
 396
 397 fn convert_try(expr: &ast::Expr, context: &RewriteContext) -> ast::Expr {
 398     match expr.node {
 399         ast::ExprKind::Mac(ref mac) if context.config.use_try_shorthand() => {
 400             if let Some(subexpr) = convert_try_mac(mac, context) {
 401                 subexpr
 402             } else {
 403                 expr.clone()
 404             }
 405         }
 406         _ => expr.clone(),
 407     }
 408 }
 409
 410 // Rewrite the last element in the chain `expr`. E.g., given `a.b.c` we rewrite
 411 // `.c`.
 412 fn rewrite_chain_subexpr(
 413     expr: &ast::Expr,
 414     span: Span,
 415     context: &RewriteContext,
 416     shape: Shape,
 417 ) -> Option<String> {
 418     let rewrite_element = |expr_str: String| if expr_str.len() <= shape.width {
 419         Some(expr_str)
 420     } else {
 421         None
 422     };
 423
 424     match expr.node {
 425         ast::ExprKind::MethodCall(ref segment, ref expressions) => {
 426             let types = match segment.parameters {
 427                 Some(ref params) => match **params {
 428                     ast::PathParameters::AngleBracketed(ref data) => &data.types[..],
 429                     _ => &[],
 430                 },
 431                 _ => &[],
 432             };
 433             rewrite_method_call(segment.identifier, types, expressions, span, context, shape)
 434         }
 435         ast::ExprKind::Field(_, ref field) => rewrite_element(format!(".{}", field.node)),
 436         ast::ExprKind::TupField(ref expr, ref field) => {
 437             let space = match expr.node {
 438                 ast::ExprKind::TupField(..) => " ",
 439                 _ => "",
 440             };
 441             rewrite_element(format!("{}.{}", space, field.node))
 442         }
 443         ast::ExprKind::Try(_) => rewrite_element(String::from("?")),
 444         _ => unreachable!(),
 445     }
 446 }
 447
 448 // Determines if we can continue formatting a given expression on the same line.
 449 fn is_continuable(expr: &ast::Expr) -> bool {
 450     match expr.node {
 451         ast::ExprKind::Path(..) => true,
 452         _ => false,
 453     }
 454 }
 455
 456 fn is_try(expr: &ast::Expr) -> bool {
 457     match expr.node {
 458         ast::ExprKind::Try(..) => true,
 459         _ => false,
 460     }
 461 }
 462
 463 fn rewrite_method_call(
 464     method_name: ast::Ident,
 465     types: &[ptr::P<ast::Ty>],
 466     args: &[ptr::P<ast::Expr>],
 467     span: Span,
 468     context: &RewriteContext,
 469     shape: Shape,
 470 ) -> Option<String> {
 471     let (lo, type_str) = if types.is_empty() {
 472         (args[0].span.hi(), String::new())
 473     } else {
 474         let type_list = types
 475             .iter()
 476             .map(|ty| ty.rewrite(context, shape))
 477             .collect::<Option<Vec<_>>>()?;
 478
 479         let type_str = if context.config.spaces_within_angle_brackets() && !type_list.is_empty() {
 480             format!("::< {} >", type_list.join(", "))
 481         } else {
 482             format!("::<{}>", type_list.join(", "))
 483         };
 484
 485         (types.last().unwrap().span.hi(), type_str)
 486     };
 487
 488     let callee_str = format!(".{}{}", method_name, type_str);
 489     let span = mk_sp(lo, span.hi());
 490
 491     rewrite_call(context, &callee_str, &args[1..], span, shape)
 492 }