275 lines
11 KiB
Rust
275 lines
11 KiB
Rust
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use rewrite::{Rewrite, RewriteContext};
|
|
use lists::{write_list, itemize_list, ListFormatting, SeparatorTactic, ListTactic};
|
|
use string::{StringFormat, rewrite_string};
|
|
use utils::span_after;
|
|
|
|
use syntax::{ast, ptr};
|
|
use syntax::codemap::{Pos, Span, BytePos};
|
|
use syntax::parse::token;
|
|
use syntax::print::pprust;
|
|
|
|
impl Rewrite for ast::Expr {
|
|
fn rewrite(&self, context: &RewriteContext, width: usize, offset: usize) -> Option<String> {
|
|
match self.node {
|
|
ast::Expr_::ExprLit(ref l) => {
|
|
match l.node {
|
|
ast::Lit_::LitStr(ref is, _) => {
|
|
let result = rewrite_string_lit(context, &is, l.span, width, offset);
|
|
debug!("string lit: `{:?}`", result);
|
|
return result;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
ast::Expr_::ExprCall(ref callee, ref args) => {
|
|
return rewrite_call(context, callee, args, self.span, width, offset);
|
|
}
|
|
ast::Expr_::ExprParen(ref subexpr) => {
|
|
return rewrite_paren(context, subexpr, width, offset);
|
|
}
|
|
ast::Expr_::ExprStruct(ref path, ref fields, ref base) => {
|
|
return rewrite_struct_lit(context,
|
|
path,
|
|
fields,
|
|
base.as_ref().map(|e| &**e),
|
|
self.span,
|
|
width,
|
|
offset);
|
|
}
|
|
ast::Expr_::ExprTup(ref items) => {
|
|
return rewrite_tuple_lit(context, items, self.span, width, offset);
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
context.codemap.span_to_snippet(self.span).ok()
|
|
}
|
|
}
|
|
|
|
fn rewrite_string_lit(context: &RewriteContext,
|
|
s: &str,
|
|
span: Span,
|
|
width: usize,
|
|
offset: usize)
|
|
-> Option<String> {
|
|
// Check if there is anything to fix: we always try to fixup multi-line
|
|
// strings, or if the string is too long for the line.
|
|
let l_loc = context.codemap.lookup_char_pos(span.lo);
|
|
let r_loc = context.codemap.lookup_char_pos(span.hi);
|
|
if l_loc.line == r_loc.line && r_loc.col.to_usize() <= context.config.max_width {
|
|
return context.codemap.span_to_snippet(span).ok();
|
|
}
|
|
let fmt = StringFormat {
|
|
opener: "\"",
|
|
closer: "\"",
|
|
line_start: " ",
|
|
line_end: "\\",
|
|
width: width,
|
|
offset: offset,
|
|
trim_end: false
|
|
};
|
|
|
|
Some(rewrite_string(&s.escape_default(), &fmt))
|
|
}
|
|
|
|
fn rewrite_call(context: &RewriteContext,
|
|
callee: &ast::Expr,
|
|
args: &[ptr::P<ast::Expr>],
|
|
span: Span,
|
|
width: usize,
|
|
offset: usize)
|
|
-> Option<String> {
|
|
debug!("rewrite_call, width: {}, offset: {}", width, offset);
|
|
|
|
// TODO using byte lens instead of char lens (and probably all over the place too)
|
|
let callee_str = try_opt!(callee.rewrite(context, width, offset));
|
|
debug!("rewrite_call, callee_str: `{}`", callee_str);
|
|
|
|
if args.len() == 0 {
|
|
return Some(format!("{}()", callee_str));
|
|
}
|
|
|
|
// 2 is for parens.
|
|
let remaining_width = width - callee_str.len() - 2;
|
|
let offset = callee_str.len() + 1 + offset;
|
|
|
|
let items = itemize_list(context.codemap,
|
|
Vec::new(),
|
|
args.iter(),
|
|
",",
|
|
")",
|
|
|item| item.span.lo,
|
|
|item| item.span.hi,
|
|
// Take old span when rewrite fails.
|
|
|item| item.rewrite(context, remaining_width, offset)
|
|
.unwrap_or(context.codemap.span_to_snippet(item.span)
|
|
.unwrap()),
|
|
callee.span.hi + BytePos(1),
|
|
span.hi);
|
|
|
|
let fmt = ListFormatting {
|
|
tactic: ListTactic::HorizontalVertical,
|
|
separator: ",",
|
|
trailing_separator: SeparatorTactic::Never,
|
|
indent: offset,
|
|
h_width: remaining_width,
|
|
v_width: remaining_width,
|
|
ends_with_newline: true,
|
|
};
|
|
|
|
Some(format!("{}({})", callee_str, write_list(&items, &fmt)))
|
|
}
|
|
|
|
fn rewrite_paren(context: &RewriteContext, subexpr: &ast::Expr, width: usize, offset: usize) -> Option<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
|
|
let subexpr_str = subexpr.rewrite(context, width-2, offset+1);
|
|
debug!("rewrite_paren, subexpr_str: `{:?}`", subexpr_str);
|
|
subexpr_str.map(|s| format!("({})", s))
|
|
}
|
|
|
|
fn rewrite_struct_lit<'a>(context: &RewriteContext,
|
|
path: &ast::Path,
|
|
fields: &'a [ast::Field],
|
|
base: Option<&'a ast::Expr>,
|
|
span: Span,
|
|
width: usize,
|
|
offset: usize)
|
|
-> Option<String>
|
|
{
|
|
debug!("rewrite_struct_lit: width {}, offset {}", width, offset);
|
|
assert!(fields.len() > 0 || base.is_some());
|
|
|
|
enum StructLitField<'a> {
|
|
Regular(&'a ast::Field),
|
|
Base(&'a ast::Expr)
|
|
}
|
|
|
|
let path_str = pprust::path_to_string(path);
|
|
// Foo { a: Foo } - indent is +3, width is -5.
|
|
let indent = offset + path_str.len() + 3;
|
|
let budget = width - (path_str.len() + 5);
|
|
|
|
let field_iter = fields.into_iter().map(StructLitField::Regular)
|
|
.chain(base.into_iter().map(StructLitField::Base));
|
|
|
|
let items = itemize_list(context.codemap,
|
|
Vec::new(),
|
|
field_iter,
|
|
",",
|
|
"}",
|
|
|item| {
|
|
match *item {
|
|
StructLitField::Regular(ref field) => field.span.lo,
|
|
// 2 = ..
|
|
StructLitField::Base(ref expr) => expr.span.lo - BytePos(2)
|
|
}
|
|
},
|
|
|item| {
|
|
match *item {
|
|
StructLitField::Regular(ref field) => field.span.hi,
|
|
StructLitField::Base(ref expr) => expr.span.hi
|
|
}
|
|
},
|
|
|item| {
|
|
match *item {
|
|
StructLitField::Regular(ref field) => {
|
|
rewrite_field(context, &field, budget, indent)
|
|
.unwrap_or(context.codemap.span_to_snippet(field.span)
|
|
.unwrap())
|
|
},
|
|
StructLitField::Base(ref expr) => {
|
|
// 2 = ..
|
|
expr.rewrite(context, budget - 2, indent + 2)
|
|
.map(|s| format!("..{}", s))
|
|
.unwrap_or(context.codemap.span_to_snippet(expr.span)
|
|
.unwrap())
|
|
}
|
|
}
|
|
},
|
|
span_after(span, "{", context.codemap),
|
|
span.hi);
|
|
|
|
let fmt = ListFormatting {
|
|
tactic: ListTactic::HorizontalVertical,
|
|
separator: ",",
|
|
trailing_separator: if base.is_some() {
|
|
SeparatorTactic::Never
|
|
} else {
|
|
context.config.struct_lit_trailing_comma
|
|
},
|
|
indent: indent,
|
|
h_width: budget,
|
|
v_width: budget,
|
|
ends_with_newline: true,
|
|
};
|
|
let fields_str = write_list(&items, &fmt);
|
|
Some(format!("{} {{ {} }}", path_str, fields_str))
|
|
|
|
// FIXME if the usual multi-line layout is too wide, we should fall back to
|
|
// Foo {
|
|
// a: ...,
|
|
// }
|
|
}
|
|
|
|
fn rewrite_field(context: &RewriteContext, field: &ast::Field, width: usize, offset: usize) -> Option<String> {
|
|
let name = &token::get_ident(field.ident.node);
|
|
let overhead = name.len() + 2;
|
|
let expr = field.expr.rewrite(context, width - overhead, offset + overhead);
|
|
expr.map(|s| format!("{}: {}", name, s))
|
|
}
|
|
|
|
fn rewrite_tuple_lit(context: &RewriteContext,
|
|
items: &[ptr::P<ast::Expr>],
|
|
span: Span,
|
|
width: usize,
|
|
offset: usize)
|
|
-> Option<String> {
|
|
let indent = offset + 1;
|
|
|
|
let items = itemize_list(context.codemap,
|
|
Vec::new(),
|
|
items.into_iter(),
|
|
",",
|
|
")",
|
|
|item| item.span.lo,
|
|
|item| item.span.hi,
|
|
|item| item.rewrite(context,
|
|
context.config.max_width - indent - 2,
|
|
indent)
|
|
.unwrap_or(context.codemap.span_to_snippet(item.span)
|
|
.unwrap()),
|
|
span.lo + BytePos(1), // Remove parens
|
|
span.hi - BytePos(1));
|
|
|
|
// In case of length 1, need a trailing comma
|
|
let trailing_separator_tactic = if items.len() == 1 {
|
|
SeparatorTactic::Always
|
|
} else {
|
|
SeparatorTactic::Never
|
|
};
|
|
|
|
let fmt = ListFormatting {
|
|
tactic: ListTactic::HorizontalVertical,
|
|
separator: ",",
|
|
trailing_separator: trailing_separator_tactic,
|
|
indent: indent,
|
|
h_width: width - 2,
|
|
v_width: width - 2,
|
|
ends_with_newline: true,
|
|
};
|
|
|
|
Some(format!("({})", write_list(&items, &fmt)))
|
|
}
|