use std::cmp::min;
use itertools::Itertools;
-use syntax::parse::token::{DelimToken, LitKind};
-use syntax::source_map::{BytePos, SourceMap, Span};
-use syntax::{ast, ptr};
+use rustc_ast::token::{DelimToken, LitKind};
+use rustc_ast::{ast, ptr};
+use rustc_span::{BytePos, Span};
use crate::chains::rewrite_chain;
use crate::closures;
use crate::comment::{
- combine_strs_with_missing_comments, contains_comment, recover_comment_removed, rewrite_comment,
- rewrite_missing_comment, CharClasses, FindUncommented,
+ combine_strs_with_missing_comments, comment_style, contains_comment, recover_comment_removed,
+ rewrite_comment, rewrite_missing_comment, CharClasses, FindUncommented,
};
use crate::config::lists::*;
use crate::config::{Config, ControlBraceStyle, IndentStyle, Version};
| ast::ExprKind::Loop(..)
| ast::ExprKind::While(..) => to_control_flow(expr, expr_type)
.and_then(|control_flow| control_flow.rewrite(context, shape)),
+ ast::ExprKind::ConstBlock(ref anon_const) => {
+ Some(format!("const {}", anon_const.rewrite(context, shape)?))
+ }
ast::ExprKind::Block(ref block, opt_label) => {
match expr_type {
ExprType::Statement => {
ast::ExprKind::Path(ref qself, ref path) => {
rewrite_path(context, PathContext::Expr, qself.as_ref(), path, shape)
}
- ast::ExprKind::Assign(ref lhs, ref rhs) => {
+ ast::ExprKind::Assign(ref lhs, ref rhs, _) => {
rewrite_assignment(context, lhs, rhs, None, shape)
}
ast::ExprKind::AssignOp(ref op, ref lhs, ref rhs) => {
ast::ExprKind::Try(..) | ast::ExprKind::Field(..) | ast::ExprKind::MethodCall(..) => {
rewrite_chain(expr, context, shape)
}
- ast::ExprKind::Mac(ref mac) => {
+ ast::ExprKind::MacCall(ref mac) => {
rewrite_macro(mac, None, context, shape, MacroPosition::Expression).or_else(|| {
wrap_str(
context.snippet(expr.span).to_owned(),
rewrite_unary_prefix(context, "return ", &**expr, shape)
}
ast::ExprKind::Box(ref expr) => rewrite_unary_prefix(context, "box ", &**expr, shape),
- ast::ExprKind::AddrOf(mutability, ref expr) => {
- rewrite_expr_addrof(context, mutability, expr, shape)
+ ast::ExprKind::AddrOf(borrow_kind, mutability, ref expr) => {
+ rewrite_expr_addrof(context, borrow_kind, mutability, expr, shape)
}
ast::ExprKind::Cast(ref expr, ref ty) => rewrite_pair(
&**expr,
fn needs_space_before_range(context: &RewriteContext<'_>, lhs: &ast::Expr) -> bool {
match lhs.kind {
ast::ExprKind::Lit(ref lit) => match lit.kind {
- ast::LitKind::FloatUnsuffixed(..) => {
+ ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
context.snippet(lit.span).ends_with('.')
}
_ => false,
}
// We do not format these expressions yet, but they should still
// satisfy our width restrictions.
- ast::ExprKind::InlineAsm(..) => Some(context.snippet(expr.span).to_owned()),
+ // Style Guide RFC for InlineAsm variant pending
+ // https://github.com/rust-dev-tools/fmt-rfcs/issues/152
+ ast::ExprKind::LlvmInlineAsm(..) | ast::ExprKind::InlineAsm(..) => {
+ Some(context.snippet(expr.span).to_owned())
+ }
ast::ExprKind::TryBlock(ref block) => {
if let rw @ Some(_) =
rewrite_single_line_block(context, "try ", block, Some(&expr.attrs), None, shape)
return None;
}
- if !block_contains_comment(block, context.source_map) && shape.width >= 2 {
+ if !block_contains_comment(context, block) && shape.width >= 2 {
return Some(format!("{}{}{{}}", prefix, label_str));
}
label: Option<ast::Label>,
shape: Shape,
) -> Option<String> {
- if is_simple_block(block, attrs, context.source_map) {
+ if is_simple_block(context, block, attrs) {
let expr_shape = shape.offset_left(last_line_width(prefix))?;
let expr_str = block.stmts[0].rewrite(context, expr_shape)?;
let label_str = rewrite_label(label);
let fixed_cost = self.keyword.len() + " { } else { }".len();
if let ast::ExprKind::Block(ref else_node, _) = else_block.kind {
- if !is_simple_block(self.block, None, context.source_map)
- || !is_simple_block(else_node, None, context.source_map)
+ if !is_simple_block(context, self.block, None)
+ || !is_simple_block(context, else_node, None)
|| pat_expr_str.contains('\n')
{
return None;
debug!("rewrite_pat_expr {:?} {:?} {:?}", shape, self.pat, expr);
let cond_shape = shape.offset_left(offset)?;
- if !self.pat.is_none() {
+ if let Some(pat) = self.pat {
let matcher = if self.matcher.is_empty() {
self.matcher.to_owned()
} else {
let pat_shape = cond_shape
.offset_left(matcher.len())?
.sub_width(self.connector.len())?;
- let pat_string = if let Some(pat) = self.pat {
- pat.rewrite(context, pat_shape)?
+ let pat_string = pat.rewrite(context, pat_shape)?;
+ let comments_lo = context
+ .snippet_provider
+ .span_after(self.span, self.connector.trim());
+ let missing_comments = if let Some(comment) =
+ rewrite_missing_comment(mk_sp(comments_lo, expr.span.lo()), cond_shape, context)
+ {
+ if !self.connector.is_empty() && !comment.is_empty() {
+ if comment_style(&comment, false).is_line_comment() || comment.contains("\n") {
+ let newline = &pat_shape
+ .indent
+ .block_indent(context.config)
+ .to_string_with_newline(context.config);
+ // An extra space is added when the lhs and rhs are joined
+ // so we need to remove one space from the end to ensure
+ // the comment and rhs are aligned.
+ let mut suffix = newline.as_ref().to_string();
+ if !suffix.is_empty() {
+ suffix.truncate(suffix.len() - 1);
+ }
+ format!("{}{}{}", newline, comment, suffix)
+ } else {
+ format!(" {}", comment)
+ }
+ } else {
+ comment
+ }
} else {
"".to_owned()
};
- let result = format!("{}{}{}", matcher, pat_string, self.connector);
+
+ let result = format!(
+ "{}{}{}{}",
+ matcher, pat_string, self.connector, missing_comments
+ );
return rewrite_assign_rhs(context, result, expr, cond_shape);
}
}
}
-pub(crate) fn block_contains_comment(block: &ast::Block, source_map: &SourceMap) -> bool {
- let snippet = source_map.span_to_snippet(block.span).unwrap();
- contains_comment(&snippet)
+pub(crate) fn block_contains_comment(context: &RewriteContext<'_>, block: &ast::Block) -> bool {
+ contains_comment(context.snippet(block.span))
}
// Checks that a block contains no statements, an expression and no comments or
// FIXME: incorrectly returns false when comment is contained completely within
// the expression.
pub(crate) fn is_simple_block(
+ context: &RewriteContext<'_>,
block: &ast::Block,
attrs: Option<&[ast::Attribute]>,
- source_map: &SourceMap,
) -> bool {
- (block.stmts.len() == 1
+ block.stmts.len() == 1
&& stmt_is_expr(&block.stmts[0])
- && !block_contains_comment(block, source_map)
- && attrs.map_or(true, |a| a.is_empty()))
+ && !block_contains_comment(context, block)
+ && attrs.map_or(true, |a| a.is_empty())
}
/// Checks whether a block contains at most one statement or expression, and no
/// comments or attributes.
pub(crate) fn is_simple_block_stmt(
+ context: &RewriteContext<'_>,
block: &ast::Block,
attrs: Option<&[ast::Attribute]>,
- source_map: &SourceMap,
) -> bool {
block.stmts.len() <= 1
- && !block_contains_comment(block, source_map)
+ && !block_contains_comment(context, block)
&& attrs.map_or(true, |a| a.is_empty())
}
/// Checks whether a block contains no statements, expressions, comments, or
/// inner attributes.
pub(crate) fn is_empty_block(
+ context: &RewriteContext<'_>,
block: &ast::Block,
attrs: Option<&[ast::Attribute]>,
- source_map: &SourceMap,
) -> bool {
block.stmts.is_empty()
- && !block_contains_comment(block, source_map)
+ && !block_contains_comment(context, block)
&& attrs.map_or(true, |a| inner_attributes(a).is_empty())
}
.lines()
.dropping_back(1)
.all(|line| line.ends_with('\\'))
+ && context.config.version() == Version::Two
{
- let new_indent = shape.visual_indent(1).indent;
- let indented_string_lit = String::from(
- string_lit
- .lines()
- .map(|line| {
- format!(
- "{}{}",
- new_indent.to_string(context.config),
- line.trim_start()
- )
- })
- .collect::<Vec<_>>()
- .join("\n")
- .trim_start(),
- );
- return if context.config.version() == Version::Two {
- Some(indented_string_lit)
- } else {
- wrap_str(indented_string_lit, context.config.max_width(), shape)
- };
+ return Some(string_lit.to_owned());
} else {
return wrap_str(string_lit.to_owned(), context.config.max_width(), shape);
}
match expr.kind {
ast::ExprKind::Lit(..) => true,
ast::ExprKind::Path(ref qself, ref path) => qself.is_none() && path.segments.len() <= 1,
- ast::ExprKind::AddrOf(_, ref expr)
+ ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Cast(ref expr, _)
| ast::ExprKind::Field(ref expr, _)
context.config.overflow_delimited_expr()
|| (context.use_block_indent() && args_len == 1)
}
- ast::ExprKind::Mac(ref mac) => {
- match (mac.delim, context.config.overflow_delimited_expr()) {
- (ast::MacDelimiter::Bracket, true) | (ast::MacDelimiter::Brace, true) => true,
+ ast::ExprKind::MacCall(ref mac) => {
+ match (
+ rustc_ast::ast::MacDelimiter::from_token(mac.args.delim()),
+ context.config.overflow_delimited_expr(),
+ ) {
+ (Some(ast::MacDelimiter::Bracket), true)
+ | (Some(ast::MacDelimiter::Brace), true) => true,
_ => context.use_block_indent() && args_len == 1,
}
}
}
// Handle unary-like expressions
- ast::ExprKind::AddrOf(_, ref expr)
+ ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Try(ref expr)
| ast::ExprKind::Unary(_, ref expr)
pub(crate) fn is_nested_call(expr: &ast::Expr) -> bool {
match expr.kind {
- ast::ExprKind::Call(..) | ast::ExprKind::Mac(..) => true,
- ast::ExprKind::AddrOf(_, ref expr)
+ ast::ExprKind::Call(..) | ast::ExprKind::MacCall(..) => true,
+ ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Try(ref expr)
| ast::ExprKind::Unary(_, ref expr)
fn rewrite_expr_addrof(
context: &RewriteContext<'_>,
+ borrow_kind: ast::BorrowKind,
mutability: ast::Mutability,
expr: &ast::Expr,
shape: Shape,
) -> Option<String> {
- let operator_str = match mutability {
- ast::Mutability::Immutable => "&",
- ast::Mutability::Mutable => "&mut ",
+ let operator_str = match (mutability, borrow_kind) {
+ (ast::Mutability::Not, ast::BorrowKind::Ref) => "&",
+ (ast::Mutability::Not, ast::BorrowKind::Raw) => "&raw const ",
+ (ast::Mutability::Mut, ast::BorrowKind::Ref) => "&mut ",
+ (ast::Mutability::Mut, ast::BorrowKind::Raw) => "&raw mut ",
};
rewrite_unary_prefix(context, operator_str, expr, shape)
}
pub(crate) fn is_method_call(expr: &ast::Expr) -> bool {
match expr.kind {
ast::ExprKind::MethodCall(..) => true,
- ast::ExprKind::AddrOf(_, ref expr)
+ ast::ExprKind::AddrOf(_, _, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Cast(ref expr, _)
| ast::ExprKind::Try(ref expr)