rust/src/patterns.rs

418 lines
14 KiB
Rust
Raw Normal View History

2015-10-17 15:56:53 +02:00
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
2018-02-07 22:48:05 +09:00
use config::lists::*;
2017-09-27 22:19:10 +02:00
use syntax::ast::{self, BindingMode, FieldPat, Pat, PatKind, RangeEnd, RangeSyntax};
use syntax::codemap::{self, BytePos, Span};
use syntax::ptr;
use codemap::SpanUtils;
use comment::FindUncommented;
2018-04-29 20:22:48 +08:00
use expr::{
can_be_overflowed_expr, rewrite_pair, rewrite_unary_prefix, wrap_struct_field, PairParts,
};
use lists::{
itemize_list, shape_for_tactic, struct_lit_formatting, struct_lit_shape, struct_lit_tactic,
write_list,
};
2017-12-10 00:22:00 +09:00
use macros::{rewrite_macro, MacroPosition};
use overflow;
use rewrite::{Rewrite, RewriteContext};
use shape::Shape;
use spanned::Spanned;
use types::{rewrite_path, PathContext};
2017-09-19 11:40:20 +09:00
use utils::{format_mutability, mk_sp};
2015-10-17 15:56:53 +02:00
/// Returns true if the given pattern is short. A short pattern is defined by the following grammer:
///
/// [small, ntp]:
/// - single token
/// - `&[single-line, ntp]`
///
/// [small]:
/// - `[small, ntp]`
/// - unary tuple constructor `([small, ntp])`
/// - `&[small]`
pub fn is_short_pattern(pat: &ast::Pat, pat_str: &str) -> bool {
// We also require that the pattern is reasonably 'small' with its literal width.
pat_str.len() <= 20 && !pat_str.contains('\n') && is_short_pattern_inner(pat)
}
fn is_short_pattern_inner(pat: &ast::Pat) -> bool {
match pat.node {
ast::PatKind::Wild | ast::PatKind::Lit(_) => true,
ast::PatKind::Ident(_, _, ref pat) => pat.is_none(),
ast::PatKind::Struct(..)
| ast::PatKind::Mac(..)
| ast::PatKind::Slice(..)
| ast::PatKind::Path(..)
| ast::PatKind::Range(..) => false,
ast::PatKind::Tuple(ref subpats, _) => subpats.len() <= 1,
ast::PatKind::TupleStruct(ref path, ref subpats, _) => {
path.segments.len() <= 1 && subpats.len() <= 1
}
ast::PatKind::Box(ref p) | ast::PatKind::Ref(ref p, _) | ast::PatKind::Paren(ref p) => {
is_short_pattern_inner(&*p)
}
}
}
2015-10-17 15:56:53 +02:00
impl Rewrite for Pat {
fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
2015-10-17 15:56:53 +02:00
match self.node {
PatKind::Box(ref pat) => rewrite_unary_prefix(context, "box ", &**pat, shape),
2016-03-01 17:27:19 -05:00
PatKind::Ident(binding_mode, ident, ref sub_pat) => {
2015-10-17 15:56:53 +02:00
let (prefix, mutability) = match binding_mode {
2016-03-01 17:27:19 -05:00
BindingMode::ByRef(mutability) => ("ref ", mutability),
BindingMode::ByValue(mutability) => ("", mutability),
2015-10-17 15:56:53 +02:00
};
let mut_infix = format_mutability(mutability);
2018-04-08 22:18:18 +08:00
let id_str = ident.name.to_string();
let sub_pat = match *sub_pat {
Some(ref p) => {
2016-02-15 10:07:19 +13:00
// 3 - ` @ `.
let width = shape
.width
.checked_sub(prefix.len() + mut_infix.len() + id_str.len() + 3)?;
format!(
" @ {}",
p.rewrite(context, Shape::legacy(width, shape.indent))?
)
}
None => "".to_owned(),
};
2017-09-19 11:40:20 +09:00
Some(format!("{}{}{}{}", prefix, mut_infix, id_str, sub_pat))
2015-10-17 15:56:53 +02:00
}
2017-08-16 00:48:12 +09:00
PatKind::Wild => {
if 1 <= shape.width {
Some("_".to_owned())
} else {
None
}
}
2017-09-27 22:19:10 +02:00
PatKind::Range(ref lhs, ref rhs, ref end_kind) => {
let infix = match *end_kind {
RangeEnd::Included(RangeSyntax::DotDotDot) => "...",
RangeEnd::Included(RangeSyntax::DotDotEq) => "..=",
RangeEnd::Excluded => "..",
};
let infix = if context.config.spaces_around_ranges() {
format!(" {} ", infix)
} else {
infix.to_owned()
};
2017-09-27 22:19:10 +02:00
rewrite_pair(
&**lhs,
&**rhs,
PairParts::new("", &infix, ""),
context,
shape,
SeparatorPlace::Front,
2017-09-27 22:19:10 +02:00
)
}
2016-03-01 17:27:19 -05:00
PatKind::Ref(ref pat, mutability) => {
2015-10-17 15:56:53 +02:00
let prefix = format!("&{}", format_mutability(mutability));
rewrite_unary_prefix(context, &prefix, &**pat, shape)
2015-10-17 15:56:53 +02:00
}
PatKind::Tuple(ref items, dotdot_pos) => {
rewrite_tuple_pat(items, dotdot_pos, None, self.span, context, shape)
}
PatKind::Path(ref q_self, ref path) => {
rewrite_path(context, PathContext::Expr, q_self.as_ref(), path, shape)
}
PatKind::TupleStruct(ref path, ref pat_vec, dotdot_pos) => {
let path_str = rewrite_path(context, PathContext::Expr, None, path, shape)?;
rewrite_tuple_pat(
pat_vec,
dotdot_pos,
Some(path_str),
self.span,
context,
shape,
)
2015-10-17 15:56:53 +02:00
}
PatKind::Lit(ref expr) => expr.rewrite(context, shape),
PatKind::Slice(ref prefix, ref slice_pat, ref suffix) => {
// Rewrite all the sub-patterns.
2017-03-28 11:25:59 +13:00
let prefix = prefix.iter().map(|p| p.rewrite(context, shape));
let slice_pat = slice_pat
.as_ref()
.map(|p| Some(format!("{}..", p.rewrite(context, shape)?)));
2017-03-28 11:25:59 +13:00
let suffix = suffix.iter().map(|p| p.rewrite(context, shape));
// Munge them together.
2017-04-24 16:50:11 +09:00
let pats: Option<Vec<String>> =
prefix.chain(slice_pat.into_iter()).chain(suffix).collect();
// Check that all the rewrites succeeded, and if not return None.
let pats = pats?;
// Unwrap all the sub-strings and join them with commas.
let result = if context.config.spaces_within_parens_and_brackets() {
format!("[ {} ]", pats.join(", "))
} else {
format!("[{}]", pats.join(", "))
};
2017-09-19 11:40:20 +09:00
Some(result)
}
2017-11-01 07:33:55 +01:00
PatKind::Struct(ref path, ref fields, ellipsis) => {
rewrite_struct_pat(path, fields, ellipsis, self.span, context, shape)
}
2017-12-10 00:22:00 +09:00
PatKind::Mac(ref mac) => rewrite_macro(mac, None, context, shape, MacroPosition::Pat),
2018-03-06 20:05:47 +09:00
PatKind::Paren(ref pat) => pat.rewrite(context, shape.offset_left(1)?.sub_width(1)?)
.map(|inner_pat| format!("({})", inner_pat)),
2015-10-17 15:56:53 +02:00
}
}
}
fn rewrite_struct_pat(
path: &ast::Path,
fields: &[codemap::Spanned<ast::FieldPat>],
2017-11-01 07:33:55 +01:00
ellipsis: bool,
span: Span,
context: &RewriteContext,
shape: Shape,
) -> Option<String> {
// 2 = ` {`
let path_shape = shape.sub_width(2)?;
let path_str = rewrite_path(context, PathContext::Expr, None, path, path_shape)?;
2017-11-01 07:33:55 +01:00
if fields.is_empty() && !ellipsis {
return Some(format!("{} {{}}", path_str));
}
2017-11-01 07:33:55 +01:00
let (ellipsis_str, terminator) = if ellipsis { (", ..", "..") } else { ("", "}") };
// 3 = ` { `, 2 = ` }`.
let (h_shape, v_shape) =
2017-11-01 07:33:55 +01:00
struct_lit_shape(shape, context, path_str.len() + 3, ellipsis_str.len() + 2)?;
let items = itemize_list(
context.snippet_provider,
fields.iter(),
terminator,
",",
2017-08-19 21:47:40 +03:00
|f| f.span.lo(),
|f| f.span.hi(),
|f| f.node.rewrite(context, v_shape),
context.snippet_provider.span_after(span, "{"),
2017-08-19 21:47:40 +03:00
span.hi(),
2017-08-07 17:29:55 +09:00
false,
);
let item_vec = items.collect::<Vec<_>>();
let tactic = struct_lit_tactic(h_shape, context, &item_vec);
let nested_shape = shape_for_tactic(tactic, h_shape, v_shape);
let fmt = struct_lit_formatting(nested_shape, tactic, context, false);
let mut fields_str = write_list(&item_vec, &fmt)?;
let one_line_width = h_shape.map_or(0, |shape| shape.width);
2017-11-01 07:33:55 +01:00
if ellipsis {
if fields_str.contains('\n') || fields_str.len() > one_line_width {
// Add a missing trailing comma.
if fmt.trailing_separator == SeparatorTactic::Never {
fields_str.push_str(",");
}
fields_str.push_str("\n");
fields_str.push_str(&nested_shape.indent.to_string(context.config));
fields_str.push_str("..");
} else {
if !fields_str.is_empty() {
2017-11-01 07:33:55 +01:00
// there are preceding struct fields being matched on
if fmt.tactic == DefinitiveListTactic::Vertical {
// if the tactic is Vertical, write_list already added a trailing ,
fields_str.push_str(" ");
} else {
fields_str.push_str(", ");
}
}
fields_str.push_str("..");
}
}
let fields_str = wrap_struct_field(context, &fields_str, shape, v_shape, one_line_width);
Some(format!("{} {{{}}}", path_str, fields_str))
}
impl Rewrite for FieldPat {
fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
let pat = self.pat.rewrite(context, shape);
if self.is_shorthand {
pat
} else {
let pat_str = pat?;
2017-09-19 11:40:20 +09:00
let id_str = self.ident.to_string();
let one_line_width = id_str.len() + 2 + pat_str.len();
if one_line_width <= shape.width {
Some(format!("{}: {}", id_str, pat_str))
} else {
let nested_shape = shape.block_indent(context.config.tab_spaces());
let pat_str = self.pat.rewrite(context, nested_shape)?;
2017-09-19 11:40:20 +09:00
Some(format!(
"{}:\n{}{}",
id_str,
nested_shape.indent.to_string(context.config),
pat_str,
))
}
}
}
}
pub enum TuplePatField<'a> {
Pat(&'a ptr::P<ast::Pat>),
Dotdot(Span),
}
impl<'a> Rewrite for TuplePatField<'a> {
fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
match *self {
2017-08-29 22:16:04 +09:00
TuplePatField::Pat(p) => p.rewrite(context, shape),
TuplePatField::Dotdot(_) => Some("..".to_string()),
}
}
}
impl<'a> Spanned for TuplePatField<'a> {
fn span(&self) -> Span {
match *self {
2017-08-29 22:16:04 +09:00
TuplePatField::Pat(p) => p.span(),
TuplePatField::Dotdot(span) => span,
}
}
}
pub fn can_be_overflowed_pat(context: &RewriteContext, pat: &TuplePatField, len: usize) -> bool {
2017-08-29 22:16:04 +09:00
match *pat {
TuplePatField::Pat(pat) => match pat.node {
2017-11-16 16:42:07 +09:00
ast::PatKind::Path(..)
| ast::PatKind::Tuple(..)
| ast::PatKind::Struct(..)
| ast::PatKind::TupleStruct(..) => context.use_block_indent() && len == 1,
2017-07-11 21:53:10 +09:00
ast::PatKind::Ref(ref p, _) | ast::PatKind::Box(ref p) => {
can_be_overflowed_pat(context, &TuplePatField::Pat(p), len)
}
ast::PatKind::Lit(ref expr) => can_be_overflowed_expr(context, expr, len),
_ => false,
},
2017-08-29 22:16:04 +09:00
TuplePatField::Dotdot(..) => false,
}
}
fn rewrite_tuple_pat(
pats: &[ptr::P<ast::Pat>],
dotdot_pos: Option<usize>,
path_str: Option<String>,
span: Span,
context: &RewriteContext,
shape: Shape,
) -> Option<String> {
2017-04-24 16:50:11 +09:00
let mut pat_vec: Vec<_> = pats.into_iter().map(|x| TuplePatField::Pat(x)).collect();
if let Some(pos) = dotdot_pos {
let prev = if pos == 0 {
2017-08-19 21:47:40 +03:00
span.lo()
} else {
2017-08-19 21:47:40 +03:00
pats[pos - 1].span().hi()
};
let next = if pos + 1 >= pats.len() {
2017-08-19 21:47:40 +03:00
span.hi()
} else {
2017-08-19 21:47:40 +03:00
pats[pos + 1].span().lo()
};
let dot_span = mk_sp(prev, next);
let snippet = context.snippet(dot_span);
2017-08-19 21:47:40 +03:00
let lo = dot_span.lo() + BytePos(snippet.find_uncommented("..").unwrap() as u32);
let dotdot = TuplePatField::Dotdot(Span::new(
lo,
// 2 == "..".len()
2017-08-19 21:47:40 +03:00
lo + BytePos(2),
codemap::NO_EXPANSION,
));
pat_vec.insert(pos, dotdot);
}
if pat_vec.is_empty() {
2017-08-29 22:16:04 +09:00
return Some(format!("{}()", path_str.unwrap_or_default()));
}
let wildcard_suffix_len = count_wildcard_suffix_len(context, &pat_vec, span, shape);
2017-07-26 17:43:17 +09:00
let (pat_vec, span) = if context.config.condense_wildcard_suffixes() && wildcard_suffix_len >= 2
{
let new_item_count = 1 + pat_vec.len() - wildcard_suffix_len;
let sp = pat_vec[new_item_count - 1].span();
let snippet = context.snippet(sp);
2017-08-19 21:47:40 +03:00
let lo = sp.lo() + BytePos(snippet.find_uncommented("_").unwrap() as u32);
2017-07-26 17:43:17 +09:00
pat_vec[new_item_count - 1] = TuplePatField::Dotdot(mk_sp(lo, lo + BytePos(1)));
2017-08-19 21:47:40 +03:00
(
&pat_vec[..new_item_count],
mk_sp(span.lo(), lo + BytePos(1)),
)
2017-07-26 17:43:17 +09:00
} else {
(&pat_vec[..], span)
};
// add comma if `(x,)`
let add_comma = path_str.is_none() && pat_vec.len() == 1 && dotdot_pos.is_none();
2017-08-29 22:16:04 +09:00
let path_str = path_str.unwrap_or_default();
2018-04-01 19:35:00 +09:00
let pat_ref_vec = pat_vec.iter().collect::<Vec<_>>();
2017-08-29 22:16:04 +09:00
overflow::rewrite_with_parens(
&context,
&path_str,
2018-04-01 18:12:50 +09:00
&pat_ref_vec,
shape,
span,
context.config.max_width(),
if add_comma {
Some(SeparatorTactic::Always)
} else {
None
},
)
}
fn count_wildcard_suffix_len(
context: &RewriteContext,
patterns: &[TuplePatField],
span: Span,
shape: Shape,
) -> usize {
let mut suffix_len = 0;
let items: Vec<_> = itemize_list(
context.snippet_provider,
patterns.iter(),
")",
",",
2017-08-19 21:47:40 +03:00
|item| item.span().lo(),
|item| item.span().hi(),
|item| item.rewrite(context, shape),
context.snippet_provider.span_after(span, "("),
2017-08-19 21:47:40 +03:00
span.hi() - BytePos(1),
2017-08-07 17:29:55 +09:00
false,
).collect();
2017-05-16 23:24:38 +09:00
for item in items.iter().rev().take_while(|i| match i.item {
Some(ref internal_string) if internal_string == "_" => true,
_ => false,
2017-06-17 21:17:20 +09:00
}) {
suffix_len += 1;
2018-04-01 21:43:01 +09:00
if item.has_comment() {
break;
}
}
suffix_len
}