use std::collections::HashMap;
use config::lists::*;
-use syntax::codemap::{BytePos, Span};
use syntax::parse::new_parser_from_tts;
use syntax::parse::parser::Parser;
use syntax::parse::token::{BinOpToken, DelimToken, Token};
use syntax::print::pprust;
+use syntax::source_map::{BytePos, Span};
use syntax::symbol;
use syntax::tokenstream::{Cursor, ThinTokenStream, TokenStream, TokenTree};
-use syntax::util::ThinVec;
+use syntax::ThinVec;
use syntax::{ast, ptr};
-use codemap::SpanUtils;
use comment::{
contains_comment, remove_trailing_white_spaces, CharClasses, FindUncommented, FullCodeCharKind,
LineClasses,
use overflow;
use rewrite::{Rewrite, RewriteContext};
use shape::{Indent, Shape};
+use source_map::SpanUtils;
use spanned::Spanned;
use utils::{format_visibility, mk_sp, rewrite_ident, wrap_str};
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);
+ 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);
}
- context.inside_macro.replace(false);
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 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
} 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);
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,
- nested: false,
- 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 += " {";
fn delim_token_to_str(
context: &RewriteContext,
- delim_token: &DelimToken,
+ delim_token: DelimToken,
shape: Shape,
use_multiple_lines: bool,
inner_is_empty: bool,
) -> (String, String) {
- let (lhs, rhs) = match *delim_token {
+ let (lhs, rhs) = match delim_token {
DelimToken::Paren => ("(", ")"),
DelimToken::Bracket => ("[", "]"),
DelimToken::Brace => {
MacroArgKind::MetaVariable(ty, ref name) => {
Some(format!("${}:{}", name, ty.name.as_str()))
}
- MacroArgKind::Repeat(ref delim_tok, ref args, ref another, ref tok) => {
+ MacroArgKind::Repeat(delim_tok, ref args, ref another, ref tok) => {
let (lhs, inner, rhs) = rewrite_delimited_inner(delim_tok, args)?;
let another = another
.as_ref()
Some(format!("${}{}{}{}{}", lhs, inner, rhs, another, repeat_tok))
}
- MacroArgKind::Delimited(ref delim_tok, ref args) => {
+ MacroArgKind::Delimited(delim_tok, ref args) => {
rewrite_delimited_inner(delim_tok, args)
.map(|(lhs, inner, rhs)| format!("{}{}{}", lhs, inner, rhs))
}
let mut hi = span.hi();
// Parse '*', '+' or '?.
- for ref tok in iter {
- self.set_last_tok(tok);
+ for tok in iter {
+ self.set_last_tok(&tok);
if first {
first = false;
lo = tok.span().lo();
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);
}
}
}
fn force_space_before(tok: &Token) -> bool {
debug!("tok: force_space_before {:?}", tok);
- match *tok {
+ match tok {
Token::Eq
| Token::Lt
| Token::Le
}
fn ident_like(tok: &Token) -> bool {
- match *tok {
+ match tok {
Token::Ident(..) | Token::Literal(..) | Token::Lifetime(_) => true,
_ => false,
}
fn next_space(tok: &Token) -> SpaceState {
debug!("next_space: {:?}", tok);
- match *tok {
+ match tok {
Token::Not
| Token::BinOp(BinOpToken::And)
| Token::Tilde
}).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"),
+ 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"),
)
}
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(),
)
}
};
let body_indent = if has_block_body {
shape.indent
} else {
- // We'll hack the indent below, take this into account when formatting,
- let body_indent = shape.indent.block_indent(&config);
- let new_width = config.max_width() - body_indent.width();
- config.set().max_width(new_width);
- body_indent
+ shape.indent.block_indent(&config)
};
+ let new_width = config.max_width() - body_indent.width();
+ config.set().max_width(new_width);
// First try to format as items, then as statements.
let new_body = match ::format_snippet(&body_str, &config) {
Some(new_body) => new_body,
- None => match ::format_code_block(&body_str, &config) {
- Some(new_body) => new_body,
- None => return None,
- },
+ None => {
+ let new_width = new_width + config.tab_spaces();
+ config.set().max_width(new_width);
+ match ::format_code_block(&body_str, &config) {
+ Some(new_body) => new_body,
+ None => return None,
+ }
+ }
};
let new_body = wrap_str(new_body, config.max_width(), shape)?;
projects / rust.git / blobdiff