use syntax::symbol;
use syntax::tokenstream::{Cursor, ThinTokenStream, TokenStream, TokenTree};
use syntax::ThinVec;
-use syntax::{ast, ptr};
+use syntax::{ast, parse, ptr};
-use comment::{
- contains_comment, remove_trailing_white_spaces, CharClasses, FindUncommented, FullCodeCharKind,
- LineClasses,
-};
+use comment::{contains_comment, CharClasses, FindUncommented, FullCodeCharKind, LineClasses};
use expr::rewrite_array;
use lists::{itemize_list, write_list, ListFormatting};
use overflow;
use shape::{Indent, Shape};
use source_map::SpanUtils;
use spanned::Spanned;
-use utils::{format_visibility, mk_sp, rewrite_ident, wrap_str};
+use utils::{
+ format_visibility, is_empty_line, mk_sp, remove_trailing_white_spaces, rewrite_ident,
+ trim_left_preserve_layout, wrap_str, NodeIdExt,
+};
+use visitor::FmtVisitor;
const FORCED_BRACKET_MACROS: &[&str] = &["vec!"];
Item(ptr::P<ast::Item>),
}
+impl MacroArg {
+ fn is_item(&self) -> bool {
+ match self {
+ MacroArg::Item(..) => true,
+ _ => false,
+ }
+ }
+}
+
impl Rewrite for ast::Item {
fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
let mut visitor = ::visitor::FmtVisitor::from_context(context);
visitor.block_indent = shape.indent;
visitor.last_pos = self.span().lo();
visitor.visit_item(self);
- Some(visitor.buffer)
+ Some(visitor.buffer.to_owned())
}
}
}
}
-fn parse_macro_arg(parser: &mut Parser) -> Option<MacroArg> {
+fn parse_macro_arg<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
macro_rules! parse_macro_arg {
- ($macro_arg:ident, $parser:ident, $f:expr) => {
+ ($macro_arg:ident, $parser:expr, $f:expr) => {
let mut cloned_parser = (*parser).clone();
- match cloned_parser.$parser() {
+ match $parser(&mut cloned_parser) {
Ok(x) => {
if parser.sess.span_diagnostic.has_errors() {
parser.sess.span_diagnostic.reset_err_count();
};
}
- 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_macro_arg!(
+ Expr,
+ |parser: &mut parse::parser::Parser<'b>| parser.parse_expr(),
+ |x: ptr::P<ast::Expr>| Some(x)
+ );
+ parse_macro_arg!(
+ Ty,
+ |parser: &mut parse::parser::Parser<'b>| parser.parse_ty(),
+ |x: ptr::P<ast::Ty>| Some(x)
+ );
+ parse_macro_arg!(
+ Pat,
+ |parser: &mut parse::parser::Parser<'b>| parser.parse_pat(None),
+ |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);
+ parse_macro_arg!(
+ Item,
+ |parser: &mut parse::parser::Parser<'b>| parser.parse_item(),
+ |x: Option<ptr::P<ast::Item>>| x
+ );
None
}
}
// Use this on failing to format the macro call.
-fn return_original_snippet_with_failure_marked(
+fn return_macro_parse_failure_fallback(
context: &RewriteContext,
+ indent: Indent,
span: Span,
) -> Option<String> {
+ // Mark this as a failure however we format it
context.macro_rewrite_failure.replace(true);
+
+ // Heuristically determine whether the last line of the macro uses "Block" style
+ // rather than using "Visual" style, or another indentation style.
+ let is_like_block_indent_style = context
+ .snippet(span)
+ .lines()
+ .last()
+ .map(|closing_line| {
+ closing_line.trim().chars().all(|ch| match ch {
+ '}' | ')' | ']' => true,
+ _ => false,
+ })
+ })
+ .unwrap_or(false);
+ if is_like_block_indent_style {
+ return trim_left_preserve_layout(context.snippet(span), indent, &context.config);
+ }
+
+ // Return the snippet unmodified if the macro is not block-like
Some(context.snippet(span).to_owned())
}
}
DelimToken::Paren => Some(format!("{}()", macro_name)),
DelimToken::Bracket => Some(format!("{}[]", macro_name)),
- DelimToken::Brace => Some(format!("{}{{}}", macro_name)),
+ DelimToken::Brace => Some(format!("{} {{}}", macro_name)),
_ => unreachable!(),
};
}
loop {
match parse_macro_arg(&mut parser) {
Some(arg) => arg_vec.push(arg),
- None => return return_original_snippet_with_failure_marked(context, mac.span),
+ None => {
+ return return_macro_parse_failure_fallback(context, shape.indent, mac.span);
+ }
}
match parser.token {
}
}
None => {
- return return_original_snippet_with_failure_marked(
- context, mac.span,
- )
+ return return_macro_parse_failure_fallback(
+ context,
+ shape.indent,
+ mac.span,
+ );
}
}
}
}
- return return_original_snippet_with_failure_marked(context, mac.span);
+ return return_macro_parse_failure_fallback(context, shape.indent, mac.span);
}
- _ => return return_original_snippet_with_failure_marked(context, mac.span),
+ _ if arg_vec.last().map_or(false, MacroArg::is_item) => continue,
+ _ => return return_macro_parse_failure_fallback(context, shape.indent, mac.span),
}
parser.bump();
}
}
+ if !arg_vec.is_empty() && arg_vec.iter().all(MacroArg::is_item) {
+ return rewrite_macro_with_items(
+ context,
+ &arg_vec,
+ ¯o_name,
+ shape,
+ style,
+ position,
+ mac.span,
+ );
+ }
+
match style {
DelimToken::Paren => {
// Format macro invocation as function call, preserve the trailing
overflow::rewrite_with_parens(
context,
¯o_name,
- &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>(),
+ arg_vec.iter(),
shape,
mac.span,
context.config.width_heuristics().fn_call_width,
} else {
Some(SeparatorTactic::Never)
},
- ).map(|rw| match position {
+ )
+ .map(|rw| match position {
MacroPosition::Item => format!("{};", rw),
_ => rw,
})
force_trailing_comma = Some(SeparatorTactic::Vertical);
};
}
- // Convert `MacroArg` into `ast::Expr`, as `rewrite_array` only accepts the latter.
- let arg_vec = &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>();
let rewrite = rewrite_array(
macro_name,
- arg_vec,
+ arg_vec.iter(),
mac.span,
context,
shape,
}
}
DelimToken::Brace => {
- // Skip macro invocations with braces, for now.
- indent_macro_snippet(context, context.snippet(mac.span), shape.indent)
+ // For macro invocations with braces, always put a space between
+ // the `macro_name!` and `{ /* macro_body */ }` but skip modifying
+ // anything in between the braces (for now).
+ let snippet = context.snippet(mac.span);
+ let macro_raw = snippet.split_at(snippet.find('!')? + 1).1.trim_start();
+ match trim_left_preserve_layout(macro_raw, shape.indent, &context.config) {
+ Some(macro_body) => Some(format!("{} {}", macro_name, macro_body)),
+ None => Some(format!("{} {}", macro_name, macro_raw)),
+ }
}
_ => unreachable!(),
}
";",
|branch| branch.span.lo(),
|branch| branch.span.hi(),
- |branch| branch.rewrite(context, arm_shape, multi_branch_style),
+ |branch| match branch.rewrite(context, arm_shape, multi_branch_style) {
+ Some(v) => Some(v),
+ // if the rewrite returned None because a macro could not be rewritten, then return the
+ // original body
+ None if *context.macro_rewrite_failure.borrow() => {
+ Some(context.snippet(branch.body).trim().to_string())
+ }
+ None => None,
+ },
context.snippet_provider.span_after(span, "{"),
span.hi(),
false,
- ).collect::<Vec<_>>();
+ )
+ .collect::<Vec<_>>();
let fmt = ListFormatting::new(arm_shape, context.config)
.separator(if def.legacy { ";" } else { "" })
/// Returns a collection of parsed macro def's arguments.
pub fn parse(mut self, tokens: ThinTokenStream) -> Option<Vec<ParsedMacroArg>> {
- let mut iter = (tokens.into(): TokenStream).trees();
+ let stream: TokenStream = tokens.into();
+ let mut iter = stream.trees();
while let Some(ref tok) = iter.next() {
match tok {
self.add_meta_variable(&mut iter)?;
}
TokenTree::Token(sp, ref t) => self.update_buffer(sp.lo(), t),
- TokenTree::Delimited(sp, delimited) => {
+ TokenTree::Delimited(delimited_span, 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();
+ parser.lo = delimited_span.open.lo();
let delimited_arg = parser.parse(delimited.tts.clone())?;
+ let span = delimited_span.entire();
if self.is_meta_var {
- self.add_repeat(delimited_arg, delimited.delim, &mut iter, *sp)?;
+ self.add_repeat(delimited_arg, delimited.delim, &mut iter, span)?;
self.is_meta_var = false;
} else {
- self.add_delimited(delimited_arg, delimited.delim, *sp);
+ self.add_delimited(delimited_arg, delimited.delim, span);
}
}
}
) -> Option<String> {
if !context.config.format_macro_matchers() {
let token_stream: TokenStream = toks.into();
- let span = span_for_token_stream(token_stream);
+ let span = span_for_token_stream(&token_stream);
return Some(match span {
Some(span) => context.snippet(span).to_owned(),
None => String::new(),
wrap_macro_args(context, &parsed_args, shape)
}
-fn span_for_token_stream(token_stream: TokenStream) -> Option<Span> {
+fn span_for_token_stream(token_stream: &TokenStream) -> Option<Span> {
token_stream.trees().next().map(|tt| tt.span())
}
| Token::DotDot
| Token::DotDotDot
| Token::DotDotEq
- | Token::DotEq
| Token::Question => SpaceState::Punctuation,
Token::ModSep
/// 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 &mac.node.path.to_string() == "try" {
let ts: TokenStream = mac.node.tts.clone().into();
let mut parser = new_parser_from_tts(context.parse_session, ts.trees().collect());
Some(ast::Expr {
- id: ast::NodeId::new(0), // dummy value
+ id: ast::NodeId::root(), // dummy value
node: ast::ExprKind::Try(parser.parse_expr().ok()?),
span: mac.span, // incorrect span, but shouldn't matter too much
attrs: ThinVec::new(),
}
}
-/// Indent each line according to the specified `indent`.
-/// e.g.
-///
-/// ```rust,ignore
-/// foo!{
-/// x,
-/// y,
-/// foo(
-/// a,
-/// b,
-/// c,
-/// ),
-/// }
-/// ```
-///
-/// will become
-///
-/// ```rust,ignore
-/// foo!{
-/// x,
-/// y,
-/// foo(
-/// a,
-/// b,
-/// c,
-/// ),
-/// }
-/// ```
-fn indent_macro_snippet(
- context: &RewriteContext,
- macro_str: &str,
- indent: Indent,
-) -> Option<String> {
- 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(|(kind, line)| {
- let mut trimmed = true;
- let prefix_space_width = if is_empty_line(&line) {
- None
- } else {
- Some(get_prefix_space_width(context, &line))
- };
- 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(
- first_line + "\n" + &trimmed_lines
- .iter()
- .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"),
- )
-}
-
-fn get_prefix_space_width(context: &RewriteContext, s: &str) -> usize {
- let mut width = 0;
- for c in s.chars() {
- match c {
- ' ' => width += 1,
- '\t' => width += context.config.tab_spaces(),
- _ => return width,
- }
- }
- width
-}
-
-fn is_empty_line(s: &str) -> bool {
- s.is_empty() || s.chars().all(char::is_whitespace)
-}
-
// A very simple parser that just parses a macros 2.0 definition into its branches.
// Currently we do not attempt to parse any further than that.
#[derive(new)]
let tok = self.toks.next()?;
let (lo, args_paren_kind) = match tok {
TokenTree::Token(..) => return None,
- TokenTree::Delimited(sp, ref d) => (sp.lo(), d.delim),
+ TokenTree::Delimited(delimited_span, ref d) => (delimited_span.open.lo(), d.delim),
};
let args = tok.joint().into();
match self.toks.next()? {
}
let (mut hi, body, whole_body) = match self.toks.next()? {
TokenTree::Token(..) => return None,
- TokenTree::Delimited(sp, _) => {
- let data = sp.data();
+ TokenTree::Delimited(delimited_span, _) => {
+ let data = delimited_span.entire().data();
(
data.hi,
Span::new(data.lo + BytePos(1), data.hi - BytePos(1), data.ctxt),
- sp,
+ delimited_span.entire(),
)
}
};
config.set().max_width(new_width);
// First try to format as items, then as statements.
- let new_body = match ::format_snippet(&body_str, &config) {
+ let new_body_snippet = match ::format_snippet(&body_str, &config) {
Some(new_body) => new_body,
None => {
let new_width = new_width + config.tab_spaces();
}
}
};
- let new_body = wrap_str(new_body, config.max_width(), shape)?;
+ let new_body = wrap_str(
+ new_body_snippet.snippet.to_string(),
+ config.max_width(),
+ shape,
+ )?;
// Indent the body since it is in a block.
let indent_str = body_indent.to_string(&config);
- let mut new_body = LineClasses::new(new_body.trim_right())
+ let mut new_body = LineClasses::new(new_body.trim_end())
+ .enumerate()
.fold(
(String::new(), true),
- |(mut s, need_indent), (kind, ref l)| {
- if !l.is_empty() && need_indent {
+ |(mut s, need_indent), (i, (kind, ref l))| {
+ if !is_empty_line(l)
+ && need_indent
+ && !new_body_snippet.is_line_non_formatted(i + 1)
+ {
s += &indent_str;
}
(s + l + "\n", !kind.is_string() || l.ends_with('\\'))
},
- ).0;
+ )
+ .0;
// Undo our replacement of macro variables.
// FIXME: this could be *much* more efficient.
result.push_str("lazy_static! {");
result.push_str(&nested_shape.indent.to_string_with_newline(context.config));
- macro parse_or($method:ident $(,)* $($arg:expr),* $(,)*) {
- match parser.$method($($arg,)*) {
- Ok(val) => {
- if parser.sess.span_diagnostic.has_errors() {
+ macro_rules! parse_or {
+ ($method:ident $(,)* $($arg:expr),* $(,)*) => {
+ match parser.$method($($arg,)*) {
+ Ok(val) => {
+ if parser.sess.span_diagnostic.has_errors() {
+ parser.sess.span_diagnostic.reset_err_count();
+ return None;
+ } else {
+ val
+ }
+ }
+ Err(mut err) => {
+ err.cancel();
parser.sess.span_diagnostic.reset_err_count();
return None;
- } else {
- val
}
}
- Err(mut err) => {
- err.cancel();
- parser.sess.span_diagnostic.reset_err_count();
- return None;
- }
}
}
Some(result)
}
+
+fn rewrite_macro_with_items(
+ context: &RewriteContext,
+ items: &[MacroArg],
+ macro_name: &str,
+ shape: Shape,
+ style: DelimToken,
+ position: MacroPosition,
+ span: Span,
+) -> Option<String> {
+ let (opener, closer) = match style {
+ DelimToken::Paren => ("(", ")"),
+ DelimToken::Bracket => ("[", "]"),
+ DelimToken::Brace => (" {", "}"),
+ _ => return None,
+ };
+ let trailing_semicolon = match style {
+ DelimToken::Paren | DelimToken::Bracket if position == MacroPosition::Item => ";",
+ _ => "",
+ };
+
+ let mut visitor = FmtVisitor::from_context(context);
+ visitor.block_indent = shape.indent.block_indent(context.config);
+ visitor.last_pos = context.snippet_provider.span_after(span, opener.trim());
+ for item in items {
+ let item = match item {
+ MacroArg::Item(item) => item,
+ _ => return None,
+ };
+ visitor.visit_item(&item);
+ }
+
+ let mut result = String::with_capacity(256);
+ result.push_str(¯o_name);
+ result.push_str(opener);
+ result.push_str(&visitor.block_indent.to_string_with_newline(context.config));
+ result.push_str(visitor.buffer.trim());
+ result.push_str(&shape.indent.to_string_with_newline(context.config));
+ result.push_str(closer);
+ result.push_str(trailing_semicolon);
+ Some(result)
+}