use std::collections::HashMap;
use config::lists::*;
-use syntax::{ast, ptr};
use syntax::codemap::{BytePos, Span};
use syntax::parse::new_parser_from_tts;
use syntax::parse::parser::Parser;
use syntax::symbol;
use syntax::tokenstream::{Cursor, ThinTokenStream, TokenStream, TokenTree};
use syntax::util::ThinVec;
+use syntax::{ast, ptr};
use codemap::SpanUtils;
-use comment::{contains_comment, remove_trailing_white_spaces, CharClasses, FindUncommented,
- FullCodeCharKind};
+use comment::{
+ contains_comment, remove_trailing_white_spaces, CharClasses, FindUncommented, FullCodeCharKind,
+ LineClasses,
+};
use expr::rewrite_array;
use lists::{itemize_list, write_list, ListFormatting};
use overflow;
const FORCED_BRACKET_MACROS: &[&str] = &["vec!"];
-// FIXME: use the enum from libsyntax?
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-enum MacroStyle {
- Parens,
- Brackets,
- Braces,
-}
-
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MacroPosition {
Item,
Pat,
}
-impl MacroStyle {
- fn opener(&self) -> &'static str {
- match *self {
- MacroStyle::Parens => "(",
- MacroStyle::Brackets => "[",
- MacroStyle::Braces => "{",
- }
- }
-}
-
#[derive(Debug)]
pub enum MacroArg {
Expr(ptr::P<ast::Expr>),
Ty(ptr::P<ast::Ty>),
Pat(ptr::P<ast::Pat>),
- // `parse_item` returns `Option<ptr::P<ast::Item>>`.
- Item(Option<ptr::P<ast::Item>>),
+ Item(ptr::P<ast::Item>),
}
impl Rewrite for ast::Item {
MacroArg::Expr(ref expr) => expr.rewrite(context, shape),
MacroArg::Ty(ref ty) => ty.rewrite(context, shape),
MacroArg::Pat(ref pat) => pat.rewrite(context, shape),
- MacroArg::Item(ref item) => item.as_ref().and_then(|item| item.rewrite(context, shape)),
+ MacroArg::Item(ref item) => item.rewrite(context, shape),
}
}
}
fn parse_macro_arg(parser: &mut Parser) -> Option<MacroArg> {
macro_rules! parse_macro_arg {
- ($macro_arg: ident, $parser: ident) => {
+ ($macro_arg:ident, $parser:ident, $f:expr) => {
let mut cloned_parser = (*parser).clone();
match cloned_parser.$parser() {
Ok(x) => {
} else {
// Parsing succeeded.
*parser = cloned_parser;
- return Some(MacroArg::$macro_arg(x.clone()));
+ return Some(MacroArg::$macro_arg($f(x)?));
}
}
Err(mut e) => {
};
}
- parse_macro_arg!(Expr, parse_expr);
- parse_macro_arg!(Ty, parse_ty);
- parse_macro_arg!(Pat, parse_pat);
- parse_macro_arg!(Item, parse_item);
+ parse_macro_arg!(Expr, parse_expr, |x: ptr::P<ast::Expr>| Some(x));
+ parse_macro_arg!(Ty, parse_ty, |x: ptr::P<ast::Ty>| Some(x));
+ parse_macro_arg!(Pat, parse_pat, |x: ptr::P<ast::Pat>| Some(x));
+ // `parse_item` returns `Option<ptr::P<ast::Item>>`.
+ parse_macro_arg!(Item, parse_item, |x: Option<ptr::P<ast::Item>>| x);
None
}
fn rewrite_macro_name(path: &ast::Path, extra_ident: Option<ast::Ident>) -> String {
let name = if path.segments.len() == 1 {
// Avoid using pretty-printer in the common case.
- format!("{}!", path.segments[0].identifier)
+ format!("{}!", path.segments[0].ident)
} else {
format!("{}!", path)
};
shape: Shape,
position: MacroPosition,
) -> Option<String> {
- let context = &mut context.clone();
- context.inside_macro = true;
+ context.inside_macro.replace(true);
+ let result = rewrite_macro_inner(mac, extra_ident, context, shape, position);
+ context.inside_macro.replace(false);
+ result
+}
+
+pub fn rewrite_macro_inner(
+ mac: &ast::Mac,
+ extra_ident: Option<ast::Ident>,
+ context: &RewriteContext,
+ shape: Shape,
+ position: MacroPosition,
+) -> Option<String> {
if context.config.use_try_shorthand() {
if let Some(expr) = convert_try_mac(mac, context) {
- context.inside_macro = false;
+ context.inside_macro.replace(false);
return expr.rewrite(context, shape);
}
}
let macro_name = rewrite_macro_name(&mac.node.path, extra_ident);
let style = if FORCED_BRACKET_MACROS.contains(&¯o_name[..]) {
- MacroStyle::Brackets
+ DelimToken::Bracket
} else {
original_style
};
let has_comment = contains_comment(context.snippet(mac.span));
if ts.is_empty() && !has_comment {
return match style {
- MacroStyle::Parens if position == MacroPosition::Item => {
+ DelimToken::Paren if position == MacroPosition::Item => {
Some(format!("{}();", macro_name))
}
- MacroStyle::Parens => Some(format!("{}()", macro_name)),
- MacroStyle::Brackets => Some(format!("{}[]", macro_name)),
- MacroStyle::Braces => Some(format!("{}{{}}", macro_name)),
+ DelimToken::Paren => Some(format!("{}()", macro_name)),
+ DelimToken::Bracket => Some(format!("{}[]", macro_name)),
+ DelimToken::Brace => Some(format!("{}{{}}", macro_name)),
+ _ => unreachable!(),
};
}
// Format well-known macros which cannot be parsed as a valid AST.
let mut vec_with_semi = false;
let mut trailing_comma = false;
- if MacroStyle::Braces != style {
+ if DelimToken::Brace != style {
loop {
match parse_macro_arg(&mut parser) {
Some(arg) => arg_vec.push(arg),
}
match style {
- MacroStyle::Parens => {
+ DelimToken::Paren => {
// Format macro invocation as function call, preserve the trailing
// comma because not all macros support them.
overflow::rewrite_with_parens(
context,
¯o_name,
- &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>()[..],
+ &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>(),
shape,
mac.span,
context.config.width_heuristics().fn_call_width,
_ => rw,
})
}
- MacroStyle::Brackets => {
- let mac_shape = shape.offset_left(macro_name.len())?;
+ DelimToken::Bracket => {
// Handle special case: `vec![expr; expr]`
if vec_with_semi {
- let (lbr, rbr) = if context.config.spaces_within_parens_and_brackets() {
- ("[ ", " ]")
- } else {
- ("[", "]")
- };
- // 6 = `vec!` + `; `
- let total_overhead = lbr.len() + rbr.len() + 6;
+ let mac_shape = shape.offset_left(macro_name.len())?;
+ // 8 = `vec![]` + `; `
+ let total_overhead = 8;
let nested_shape = mac_shape.block_indent(context.config.tab_spaces());
let lhs = arg_vec[0].rewrite(context, nested_shape)?;
let rhs = arg_vec[1].rewrite(context, nested_shape)?;
- if !lhs.contains('\n') && !rhs.contains('\n')
+ if !lhs.contains('\n')
+ && !rhs.contains('\n')
&& lhs.len() + rhs.len() + total_overhead <= shape.width
{
- Some(format!("{}{}{}; {}{}", macro_name, lbr, lhs, rhs, rbr))
+ Some(format!("{}[{}; {}]", macro_name, lhs, rhs))
} else {
Some(format!(
- "{}{}{}{};{}{}{}{}",
+ "{}[{}{};{}{}{}]",
macro_name,
- lbr,
nested_shape.indent.to_string_with_newline(context.config),
lhs,
nested_shape.indent.to_string_with_newline(context.config),
rhs,
shape.indent.to_string_with_newline(context.config),
- rbr
))
}
} else {
// If we are rewriting `vec!` macro or other special macros,
// then we can rewrite this as an usual array literal.
// Otherwise, we must preserve the original existence of trailing comma.
- if FORCED_BRACKET_MACROS.contains(¯o_name.as_str()) {
- context.inside_macro = false;
- trailing_comma = false;
+ let macro_name = ¯o_name.as_str();
+ let mut force_trailing_comma = if trailing_comma {
+ Some(SeparatorTactic::Always)
+ } else {
+ Some(SeparatorTactic::Never)
+ };
+ if FORCED_BRACKET_MACROS.contains(macro_name) {
+ context.inside_macro.replace(false);
+ if context.use_block_indent() {
+ force_trailing_comma = Some(SeparatorTactic::Vertical);
+ };
}
// Convert `MacroArg` into `ast::Expr`, as `rewrite_array` only accepts the latter.
- let sp = mk_sp(
- context
- .snippet_provider
- .span_after(mac.span, original_style.opener()),
- mac.span.hi() - BytePos(1),
- );
- let arg_vec = &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>()[..];
- let rewrite = rewrite_array(arg_vec, sp, context, mac_shape, trailing_comma)?;
+ let arg_vec = &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>();
+ let rewrite = rewrite_array(
+ macro_name,
+ arg_vec,
+ mac.span,
+ context,
+ shape,
+ force_trailing_comma,
+ Some(original_style),
+ )?;
let comma = match position {
MacroPosition::Item => ";",
_ => "",
};
- Some(format!("{}{}{}", macro_name, rewrite, comma))
+ Some(format!("{}{}", rewrite, comma))
}
}
- MacroStyle::Braces => {
+ DelimToken::Brace => {
// Skip macro invocations with braces, for now.
indent_macro_snippet(context, context.snippet(mac.span), shape.indent)
}
+ _ => unreachable!(),
}
}
} else if c == '(' && cur_name.is_empty() {
// FIXME: Support macro def with repeat.
return None;
- } else if c.is_alphanumeric() {
+ } else if c.is_alphanumeric() || c == '_' {
cur_name.push(c);
}
}
#[derive(Debug, Clone)]
enum MacroArgKind {
+ /// e.g. `$x: expr`.
MetaVariable(ast::Ident, String),
+ /// e.g. `$($foo: expr),*`
Repeat(
+ /// `()`, `[]` or `{}`.
DelimToken,
+ /// Inner arguments inside delimiters.
Vec<ParsedMacroArg>,
+ /// Something after the closing delimiter and the repeat token, if available.
Option<Box<ParsedMacroArg>>,
+ /// The repeat token. This could be one of `*`, `+` or `?`.
Token,
),
+ /// e.g. `[derive(Debug)]`
Delimited(DelimToken, Vec<ParsedMacroArg>),
+ /// A possible separator. e.g. `,` or `;`.
Separator(String, String),
+ /// Other random stuff that does not fit to other kinds.
+ /// e.g. `== foo` in `($x: expr == foo)`.
Other(String, String),
}
let (lhs, rhs) = match *delim_token {
DelimToken::Paren => ("(", ")"),
DelimToken::Bracket => ("[", "]"),
- DelimToken::Brace => ("{", "}"),
+ DelimToken::Brace => ("{ ", " }"),
DelimToken::NoDelim => ("", ""),
};
if use_multiple_lines {
}
impl MacroArgKind {
+ fn starts_with_brace(&self) -> bool {
+ match *self {
+ MacroArgKind::Repeat(DelimToken::Brace, _, _, _)
+ | MacroArgKind::Delimited(DelimToken::Brace, _) => true,
+ _ => false,
+ }
+ }
+
fn starts_with_dollar(&self) -> bool {
match *self {
MacroArgKind::Repeat(..) | MacroArgKind::MetaVariable(..) => true,
}
}
+ fn has_meta_var(&self) -> bool {
+ match *self {
+ MacroArgKind::MetaVariable(..) => true,
+ MacroArgKind::Repeat(_, ref args, _, _) => args.iter().any(|a| a.kind.has_meta_var()),
+ _ => false,
+ }
+ }
+
fn rewrite(
&self,
context: &RewriteContext,
match *self {
MacroArgKind::MetaVariable(ty, ref name) => {
- Some(format!("${}: {}", name, ty.name.as_str()))
+ Some(format!("${}:{}", name, ty.name.as_str()))
}
MacroArgKind::Repeat(ref delim_tok, ref args, ref another, ref tok) => {
let (lhs, inner, rhs) = rewrite_delimited_inner(delim_tok, args)?;
let another = another
.as_ref()
.and_then(|a| a.rewrite(context, shape, use_multiple_lines))
- .unwrap_or("".to_owned());
+ .unwrap_or_else(|| "".to_owned());
let repeat_tok = pprust::token_to_string(tok);
Some(format!("${}{}{}{}{}", lhs, inner, rhs, another, repeat_tok))
}
}
+/// Parses macro arguments on macro def.
struct MacroArgParser {
+ /// Holds either a name of the next metavariable, a separator or a junk.
+ buf: String,
+ /// The start position on the current buffer.
lo: BytePos,
+ /// The first token of the current buffer.
+ start_tok: Token,
+ /// Set to true if we are parsing a metavariable or a repeat.
+ is_meta_var: bool,
+ /// The position of the last token.
hi: BytePos,
- buf: String,
- is_arg: bool,
+ /// The last token parsed.
last_tok: Token,
- start_tok: Token,
+ /// Holds the parsed arguments.
result: Vec<ParsedMacroArg>,
}
lo: BytePos(0),
hi: BytePos(0),
buf: String::new(),
- is_arg: false,
+ is_meta_var: false,
last_tok: Token::Eof,
start_tok: Token::Eof,
result: vec![],
self.buf.clear();
}
- fn add_meta_variable(&mut self, iter: &mut Cursor) {
+ fn add_meta_variable(&mut self, iter: &mut Cursor) -> Option<()> {
match iter.next() {
- Some(TokenTree::Token(sp, Token::Ident(ref ident))) => {
+ Some(TokenTree::Token(sp, Token::Ident(ref ident, _))) => {
self.result.push(ParsedMacroArg {
- kind: MacroArgKind::MetaVariable(ident.clone(), self.buf.clone()),
+ kind: MacroArgKind::MetaVariable(*ident, self.buf.clone()),
span: mk_sp(self.lo, sp.hi()),
});
self.buf.clear();
- self.is_arg = false;
+ self.is_meta_var = false;
+ Some(())
}
- _ => unreachable!(),
+ _ => None,
}
}
+ fn add_delimited(&mut self, inner: Vec<ParsedMacroArg>, delim: DelimToken, span: Span) {
+ self.result.push(ParsedMacroArg {
+ kind: MacroArgKind::Delimited(delim, inner),
+ span,
+ });
+ }
+
+ // $($foo: expr),?
+ fn add_repeat(
+ &mut self,
+ inner: Vec<ParsedMacroArg>,
+ delim: DelimToken,
+ iter: &mut Cursor,
+ span: Span,
+ ) -> Option<()> {
+ let mut buffer = String::new();
+ let mut first = false;
+ let mut lo = span.lo();
+ let mut hi = span.hi();
+
+ // Parse '*', '+' or '?.
+ for ref tok in iter {
+ self.set_last_tok(tok);
+ if first {
+ first = false;
+ lo = tok.span().lo();
+ }
+
+ match tok {
+ TokenTree::Token(_, Token::BinOp(BinOpToken::Plus))
+ | TokenTree::Token(_, Token::Question)
+ | TokenTree::Token(_, Token::BinOp(BinOpToken::Star)) => {
+ break;
+ }
+ TokenTree::Token(sp, ref t) => {
+ buffer.push_str(&pprust::token_to_string(t));
+ hi = sp.hi();
+ }
+ _ => return None,
+ }
+ }
+
+ // There could be some random stuff between ')' and '*', '+' or '?'.
+ let another = if buffer.trim().is_empty() {
+ None
+ } else {
+ Some(Box::new(ParsedMacroArg {
+ kind: MacroArgKind::Other(buffer, "".to_owned()),
+ span: mk_sp(lo, hi),
+ }))
+ };
+
+ self.result.push(ParsedMacroArg {
+ kind: MacroArgKind::Repeat(delim, inner, another, self.last_tok.clone()),
+ span: mk_sp(self.lo, self.hi),
+ });
+ Some(())
+ }
+
fn update_buffer(&mut self, lo: BytePos, t: &Token) {
if self.buf.is_empty() {
self.lo = lo;
self.start_tok = t.clone();
- } else if force_space_before(t) {
- self.buf.push(' ');
+ } else {
+ let needs_space = match next_space(&self.last_tok) {
+ SpaceState::Ident => ident_like(t),
+ SpaceState::Punctuation => !ident_like(t),
+ SpaceState::Always => true,
+ SpaceState::Never => false,
+ };
+ if force_space_before(t) || needs_space {
+ self.buf.push(' ');
+ }
}
self.buf.push_str(&pprust::token_to_string(t));
if ident_like(&self.start_tok) {
return true;
}
+ if self.start_tok == Token::Colon {
+ return true;
+ }
}
if force_space_before(&self.start_tok) {
}
/// Returns a collection of parsed macro def's arguments.
- pub fn parse(mut self, tokens: ThinTokenStream) -> Vec<ParsedMacroArg> {
+ pub fn parse(mut self, tokens: ThinTokenStream) -> Option<Vec<ParsedMacroArg>> {
let mut iter = (tokens.into(): TokenStream).trees();
while let Some(ref tok) = iter.next() {
}
// Start keeping the name of this metavariable in the buffer.
- self.is_arg = true;
+ self.is_meta_var = true;
self.lo = sp.lo();
self.start_tok = Token::Dollar;
}
- TokenTree::Token(_, Token::Colon) if self.is_arg => {
- self.add_meta_variable(&mut iter);
+ TokenTree::Token(_, Token::Colon) if self.is_meta_var => {
+ self.add_meta_variable(&mut iter)?;
}
TokenTree::Token(sp, ref t) => self.update_buffer(sp.lo(), t),
- TokenTree::Delimited(sp, ref delimited) => {
+ TokenTree::Delimited(sp, delimited) => {
if !self.buf.is_empty() {
if next_space(&self.last_tok) == SpaceState::Always {
self.add_separator();
}
}
+ // Parse the stuff inside delimiters.
let mut parser = MacroArgParser::new();
parser.lo = sp.lo();
- let mut delimited_arg = parser.parse(delimited.tts.clone());
-
- if self.is_arg {
- // Parse '*' or '+'.
- let mut buffer = String::new();
- let mut first = false;
- let mut lo = sp.lo();
-
- while let Some(ref next_tok) = iter.next() {
- self.set_last_tok(next_tok);
- if first {
- first = false;
- lo = next_tok.span().lo();
- }
+ let delimited_arg = parser.parse(delimited.tts.clone())?;
- match next_tok {
- TokenTree::Token(_, Token::BinOp(BinOpToken::Plus))
- | TokenTree::Token(_, Token::Question)
- | TokenTree::Token(_, Token::BinOp(BinOpToken::Star)) => {
- break;
- }
- TokenTree::Token(_, ref t) => {
- buffer.push_str(&pprust::token_to_string(t))
- }
- _ => unreachable!(),
- }
- }
-
- let another = if buffer.trim().is_empty() {
- None
- } else {
- Some(Box::new(ParsedMacroArg {
- kind: MacroArgKind::Other(buffer, "".to_owned()),
- span: mk_sp(lo, self.hi),
- }))
- };
-
- self.result.push(ParsedMacroArg {
- kind: MacroArgKind::Repeat(
- delimited.delim,
- delimited_arg,
- another,
- self.last_tok.clone(),
- ),
- span: mk_sp(self.lo, self.hi),
- });
+ if self.is_meta_var {
+ self.add_repeat(delimited_arg, delimited.delim, &mut iter, *sp)?;
+ self.is_meta_var = false;
} else {
- self.result.push(ParsedMacroArg {
- kind: MacroArgKind::Delimited(delimited.delim, delimited_arg),
- span: *sp,
- });
+ self.add_delimited(delimited_arg, delimited.delim, *sp);
}
}
}
self.set_last_tok(tok);
}
+ // We are left with some stuff in the buffer. Since there is nothing
+ // left to separate, add this as `Other`.
if !self.buf.is_empty() {
self.add_other();
}
- self.result
+ Some(self.result)
}
}
let indent_str = shape.indent.to_string_with_newline(context.config);
while let Some(ref arg) = iter.next() {
- let nested_shape = if use_multiple_lines {
- shape.with_max_width(context.config)
- } else {
- shape
- };
- result.push_str(&arg.rewrite(context, nested_shape, use_multiple_lines)?);
+ result.push_str(&arg.rewrite(context, shape, use_multiple_lines)?);
- if use_multiple_lines && arg.kind.ends_with_space() {
- result.pop();
+ if use_multiple_lines
+ && (arg.kind.ends_with_space() || iter.peek().map_or(false, |a| a.kind.has_meta_var()))
+ {
+ if arg.kind.ends_with_space() {
+ result.pop();
+ }
result.push_str(&indent_str);
} else if let Some(ref next_arg) = iter.peek() {
let space_before_dollar =
!arg.kind.ends_with_space() && next_arg.kind.starts_with_dollar();
- if space_before_dollar {
+ let space_before_brace = next_arg.kind.starts_with_brace();
+ if space_before_dollar || space_before_brace {
result.push(' ');
}
}
toks: ThinTokenStream,
shape: Shape,
) -> Option<String> {
- let parsed_args = MacroArgParser::new().parse(toks);
+ let parsed_args = MacroArgParser::new().parse(toks)?;
wrap_macro_args(context, &parsed_args, shape)
}
| Token::RArrow
| Token::LArrow
| Token::FatArrow
+ | Token::BinOp(_)
| Token::Pound
| Token::Dollar => true,
- Token::BinOp(bot) => bot != BinOpToken::Star,
_ => false,
}
}
fn ident_like(tok: &Token) -> bool {
match *tok {
- Token::Ident(_) | Token::Literal(..) | Token::Lifetime(_) => true,
+ Token::Ident(..) | Token::Literal(..) | Token::Lifetime(_) => true,
_ => false,
}
}
match *tok {
Token::Not
+ | Token::BinOp(BinOpToken::And)
| Token::Tilde
| Token::At
| Token::Comma
| Token::DotDotDot
| Token::DotDotEq
| Token::DotEq
- | Token::Question
- | Token::Underscore
- | Token::BinOp(_) => SpaceState::Punctuation,
+ | Token::Question => SpaceState::Punctuation,
Token::ModSep
| Token::Pound
| Token::CloseDelim(_)
| Token::Whitespace => SpaceState::Never,
- Token::Literal(..) | Token::Ident(_) | Token::Lifetime(_) => SpaceState::Ident,
+ Token::Literal(..) | Token::Ident(..) | Token::Lifetime(_) => SpaceState::Ident,
_ => SpaceState::Always,
}
/// when the macro is not an instance of try! (or parsing the inner expression
/// failed).
pub fn convert_try_mac(mac: &ast::Mac, context: &RewriteContext) -> Option<ast::Expr> {
- if &format!("{}", mac.node.path)[..] == "try" {
+ if &format!("{}", mac.node.path) == "try" {
let ts: TokenStream = mac.node.tts.clone().into();
let mut parser = new_parser_from_tts(context.parse_session, ts.trees().collect());
}
}
-fn macro_style(mac: &ast::Mac, context: &RewriteContext) -> MacroStyle {
+fn macro_style(mac: &ast::Mac, context: &RewriteContext) -> DelimToken {
let snippet = context.snippet(mac.span);
let paren_pos = snippet.find_uncommented("(").unwrap_or(usize::max_value());
let bracket_pos = snippet.find_uncommented("[").unwrap_or(usize::max_value());
let brace_pos = snippet.find_uncommented("{").unwrap_or(usize::max_value());
if paren_pos < bracket_pos && paren_pos < brace_pos {
- MacroStyle::Parens
+ DelimToken::Paren
} else if bracket_pos < brace_pos {
- MacroStyle::Brackets
+ DelimToken::Bracket
} else {
- MacroStyle::Braces
+ DelimToken::Brace
}
}
macro_str: &str,
indent: Indent,
) -> Option<String> {
- let mut lines = macro_str.lines();
- let first_line = lines.next().map(|s| s.trim_right())?;
+ let mut lines = LineClasses::new(macro_str);
+ let first_line = lines.next().map(|(_, s)| s.trim_right().to_owned())?;
let mut trimmed_lines = Vec::with_capacity(16);
+ let mut veto_trim = false;
let min_prefix_space_width = lines
- .filter_map(|line| {
- let prefix_space_width = if is_empty_line(line) {
+ .filter_map(|(kind, line)| {
+ let mut trimmed = true;
+ let prefix_space_width = if is_empty_line(&line) {
None
} else {
- Some(get_prefix_space_width(context, line))
+ Some(get_prefix_space_width(context, &line))
};
- trimmed_lines.push((line.trim(), prefix_space_width));
+ let line = if veto_trim || (kind.is_string() && !line.ends_with('\\')) {
+ veto_trim = kind.is_string() && !line.ends_with('\\');
+ trimmed = false;
+ line
+ } else {
+ line.trim().to_owned()
+ };
+ trimmed_lines.push((trimmed, line, prefix_space_width));
prefix_space_width
})
.min()?;
Some(
- String::from(first_line) + "\n"
+ first_line + "\n"
+ &trimmed_lines
.iter()
- .map(|&(line, prefix_space_width)| match prefix_space_width {
- Some(original_indent_width) => {
- let new_indent_width = indent.width()
- + original_indent_width
- .checked_sub(min_prefix_space_width)
- .unwrap_or(0);
- let new_indent = Indent::from_width(context.config, new_indent_width);
- format!("{}{}", new_indent.to_string(context.config), line.trim())
- }
- None => String::new(),
- })
+ .map(
+ |&(trimmed, ref line, prefix_space_width)| match prefix_space_width {
+ _ if !trimmed => line.to_owned(),
+ Some(original_indent_width) => {
+ let new_indent_width = indent.width()
+ + original_indent_width.saturating_sub(min_prefix_space_width);
+ let new_indent = Indent::from_width(context.config, new_indent_width);
+ format!("{}{}", new_indent.to_string(context.config), line.trim())
+ }
+ None => String::new(),
+ },
+ )
.collect::<Vec<_>>()
.join("\n"),
)
// Indent the body since it is in a block.
let indent_str = body_indent.to_string(&config);
- let mut new_body = new_body
- .trim_right()
- .lines()
- .fold(String::new(), |mut s, l| {
- if !l.is_empty() {
- s += &indent_str;
- }
- s + l + "\n"
- });
+ let mut new_body = LineClasses::new(new_body.trim_right())
+ .fold(
+ (String::new(), true),
+ |(mut s, need_indent), (kind, ref l)| {
+ if !l.is_empty() && need_indent {
+ s += &indent_str;
+ }
+ (s + l + "\n", !kind.is_string() || l.ends_with('\\'))
+ },
+ )
+ .0;
// Undo our replacement of macro variables.
// FIXME: this could be *much* more efficient.
fn format_lazy_static(context: &RewriteContext, shape: Shape, ts: &TokenStream) -> Option<String> {
let mut result = String::with_capacity(1024);
let mut parser = new_parser_from_tts(context.parse_session, ts.trees().collect());
- let nested_shape = shape.block_indent(context.config.tab_spaces());
+ let nested_shape = shape
+ .block_indent(context.config.tab_spaces())
+ .with_max_width(context.config);
result.push_str("lazy_static! {");
result.push_str(&nested_shape.indent.to_string_with_newline(context.config));
projects / rust.git / blobdiff