use rewrite::{Rewrite, RewriteContext};
use shape::{Indent, Shape};
use spanned::Spanned;
-use utils::{format_visibility, mk_sp, wrap_str};
+use utils::{format_visibility, mk_sp, rewrite_ident, wrap_str};
const FORCED_BRACKET_MACROS: &[&str] = &["vec!"];
}
/// Rewrite macro name without using pretty-printer if possible.
-fn rewrite_macro_name(path: &ast::Path, extra_ident: Option<ast::Ident>) -> String {
+fn rewrite_macro_name(
+ context: &RewriteContext,
+ 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].ident)
+ format!("{}!", rewrite_ident(context, path.segments[0].ident))
} else {
format!("{}!", path)
};
}
}
+// Use this on failing to format the macro call.
+fn return_original_snippet_with_failure_marked(
+ context: &RewriteContext,
+ span: Span,
+) -> Option<String> {
+ context.macro_rewrite_failure.replace(true);
+ Some(context.snippet(span).to_owned())
+}
+
+struct InsideMacroGuard<'a> {
+ context: &'a RewriteContext<'a>,
+ is_nested: bool,
+}
+
+impl<'a> InsideMacroGuard<'a> {
+ fn inside_macro_context(context: &'a RewriteContext) -> InsideMacroGuard<'a> {
+ let is_nested = context.inside_macro.replace(true);
+ InsideMacroGuard { context, is_nested }
+ }
+}
+
+impl<'a> Drop for InsideMacroGuard<'a> {
+ fn drop(&mut self) {
+ self.context.inside_macro.replace(self.is_nested);
+ }
+}
+
pub fn rewrite_macro(
mac: &ast::Mac,
extra_ident: Option<ast::Ident>,
shape: Shape,
position: MacroPosition,
) -> Option<String> {
- context.inside_macro.replace(true);
- let result = rewrite_macro_inner(mac, extra_ident, context, shape, position);
- context.inside_macro.replace(false);
+ let guard = InsideMacroGuard::inside_macro_context(context);
+ let result = rewrite_macro_inner(mac, extra_ident, context, shape, position, guard.is_nested);
+ if result.is_none() {
+ context.macro_rewrite_failure.replace(true);
+ }
result
}
context: &RewriteContext,
shape: Shape,
position: MacroPosition,
+ is_nested_macro: bool,
) -> Option<String> {
if context.config.use_try_shorthand() {
if let Some(expr) = convert_try_mac(mac, context) {
let original_style = macro_style(mac, context);
- let macro_name = rewrite_macro_name(&mac.node.path, extra_ident);
+ let macro_name = rewrite_macro_name(context, &mac.node.path, extra_ident);
- let style = if FORCED_BRACKET_MACROS.contains(&¯o_name[..]) {
+ let style = if FORCED_BRACKET_MACROS.contains(&¯o_name[..]) && !is_nested_macro {
DelimToken::Bracket
} else {
original_style
};
}
// Format well-known macros which cannot be parsed as a valid AST.
- // TODO: Maybe add more macros?
if macro_name == "lazy_static!" && !has_comment {
if let success @ Some(..) = format_lazy_static(context, shape, &ts) {
return success;
loop {
match parse_macro_arg(&mut parser) {
Some(arg) => arg_vec.push(arg),
- None => return Some(context.snippet(mac.span).to_owned()),
+ None => return return_original_snippet_with_failure_marked(context, mac.span),
}
match parser.token {
break;
}
}
- None => return Some(context.snippet(mac.span).to_owned()),
+ None => {
+ return return_original_snippet_with_failure_marked(
+ context, mac.span,
+ )
+ }
}
}
}
- return Some(context.snippet(mac.span).to_owned());
+ return return_original_snippet_with_failure_marked(context, mac.span);
}
- _ => return Some(context.snippet(mac.span).to_owned()),
+ _ => return return_original_snippet_with_failure_marked(context, mac.span),
}
parser.bump();
// Handle special case: `vec![expr; expr]`
if vec_with_semi {
let mac_shape = shape.offset_left(macro_name.len())?;
- let (lbr, rbr) = if context.config.spaces_within_parens_and_brackets() {
- ("[ ", " ]")
- } else {
- ("[", "]")
- };
- // 6 = `vec!` + `; `
- let total_overhead = lbr.len() + rbr.len() + 6;
+ // 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)?;
&& !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 {
} else {
Some(SeparatorTactic::Never)
};
- if FORCED_BRACKET_MACROS.contains(macro_name) {
+ if FORCED_BRACKET_MACROS.contains(macro_name) && !is_nested_macro {
context.inside_macro.replace(false);
if context.use_block_indent() {
force_trailing_comma = Some(SeparatorTactic::Vertical);
let mut result = if def.legacy {
String::from("macro_rules!")
} else {
- format!("{}macro", format_visibility(vis))
+ format!("{}macro", format_visibility(context, vis))
};
result += " ";
- result += &ident.name.as_str();
+ result += rewrite_ident(context, ident);
let multi_branch_style = def.legacy || parsed_def.branches.len() != 1;
false,
).collect::<Vec<_>>();
- let fmt = ListFormatting {
- tactic: DefinitiveListTactic::Vertical,
- separator: if def.legacy { ";" } else { "" },
- trailing_separator: SeparatorTactic::Always,
- separator_place: SeparatorPlace::Back,
- shape: arm_shape,
- ends_with_newline: true,
- preserve_newline: true,
- config: context.config,
- };
+ let fmt = ListFormatting::new(arm_shape, context.config)
+ .separator(if def.legacy { ";" } else { "" })
+ .trailing_separator(SeparatorTactic::Always)
+ .preserve_newline(true);
if multi_branch_style {
result += " {";
result += &arm_shape.indent.to_string_with_newline(context.config);
}
- result += write_list(&branch_items, &fmt)?.as_str();
+ match write_list(&branch_items, &fmt) {
+ Some(ref s) => result += s,
+ None => return snippet,
+ }
if multi_branch_style {
result += &indent.to_string_with_newline(context.config);
delim_token: &DelimToken,
shape: Shape,
use_multiple_lines: bool,
+ inner_is_empty: bool,
) -> (String, String) {
let (lhs, rhs) = match *delim_token {
DelimToken::Paren => ("(", ")"),
DelimToken::Bracket => ("[", "]"),
- DelimToken::Brace => ("{ ", " }"),
+ DelimToken::Brace => {
+ if inner_is_empty || use_multiple_lines {
+ ("{", "}")
+ } else {
+ ("{ ", " }")
+ }
+ }
DelimToken::NoDelim => ("", ""),
};
if use_multiple_lines {
use_multiple_lines: bool,
) -> Option<String> {
let rewrite_delimited_inner = |delim_tok, args| -> Option<(String, String, String)> {
- let (lhs, rhs) = delim_token_to_str(context, delim_tok, shape, false);
let inner = wrap_macro_args(context, args, shape)?;
+ let (lhs, rhs) = delim_token_to_str(context, delim_tok, shape, false, inner.is_empty());
if lhs.len() + inner.len() + rhs.len() <= shape.width {
return Some((lhs, inner, rhs));
}
- let (lhs, rhs) = delim_token_to_str(context, delim_tok, shape, true);
+ let (lhs, rhs) = delim_token_to_str(context, delim_tok, shape, true, false);
let nested_shape = shape
.block_indent(context.config.tab_spaces())
.with_max_width(context.config);
if self.is_meta_var {
self.add_repeat(delimited_arg, delimited.delim, &mut iter, *sp)?;
+ self.is_meta_var = false;
} else {
self.add_delimited(delimited_arg, delimited.delim, *sp);
}
toks: ThinTokenStream,
shape: Shape,
) -> Option<String> {
+ if !context.config.format_macro_matchers() {
+ let token_stream: TokenStream = toks.into();
+ let span = span_for_token_stream(token_stream);
+ return Some(match span {
+ Some(span) => context.snippet(span).to_owned(),
+ None => String::new(),
+ });
+ }
let parsed_args = MacroArgParser::new().parse(toks)?;
wrap_macro_args(context, &parsed_args, shape)
}
+fn span_for_token_stream(token_stream: TokenStream) -> Option<Span> {
+ token_stream.trees().next().map(|tt| tt.span())
+}
+
// We should insert a space if the next token is a:
#[derive(Copy, Clone, PartialEq)]
enum SpaceState {
};
trimmed_lines.push((trimmed, line, prefix_space_width));
prefix_space_width
- })
- .min()?;
+ }).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
- .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(),
- },
- )
- .collect::<Vec<_>>()
- .join("\n"),
+ 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"),
)
}
TokenTree::Token(_, Token::FatArrow) => {}
_ => return None,
}
- let (mut hi, body) = 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();
(
data.hi,
Span::new(data.lo + BytePos(1), data.hi - BytePos(1), data.ctxt),
+ sp,
)
}
};
args_paren_kind,
args,
body,
+ whole_body,
})
}
}
args_paren_kind: DelimToken,
args: ThinTokenStream,
body: Span,
+ whole_body: Span,
}
impl MacroBranch {
result += " =>";
}
+ if !context.config.format_macro_bodies() {
+ result += " ";
+ result += context.snippet(self.whole_body);
+ return Some(result);
+ }
+
// The macro body is the most interesting part. It might end up as various
// AST nodes, but also has special variables (e.g, `$foo`) which can't be
// parsed as regular Rust code (and note that these can be escaped using
let old_body = context.snippet(self.body).trim();
let (body_str, substs) = replace_names(old_body)?;
+ let has_block_body = old_body.starts_with('{');
let mut config = context.config.clone();
config.set().hide_parse_errors(true);
result += " {";
- let has_block_body = old_body.starts_with('{');
-
let body_indent = if has_block_body {
shape.indent
} else {
}
(s + l + "\n", !kind.is_string() || l.ends_with('\\'))
},
- )
- .0;
+ ).0;
// Undo our replacement of macro variables.
// FIXME: this could be *much* more efficient.
while parser.token != Token::Eof {
// Parse a `lazy_static!` item.
- let vis = ::utils::format_visibility(&parse_or!(parse_visibility, false));
+ let vis = ::utils::format_visibility(context, &parse_or!(parse_visibility, false));
parser.eat_keyword(symbol::keywords::Static);
parser.eat_keyword(symbol::keywords::Ref);
let id = parse_or!(parse_ident);
projects / rust.git / blobdiff