mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Apply refactoring from cargo clippy

Browse Source
This commit is contained in:
Seiichi Uchida 2017-08-29 22:16:04 +09:00
parent 8122f0b083
commit 4b79055a15
21 changed files with 188 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/bin/cargo-fmt.rs
View File

@ -84,7 +84,7 @@ fn execute() -> i32 {
let workspace_hitlist = WorkspaceHitlist::from_matches(&matches);
match format_crate(verbosity, workspace_hitlist) {
match format_crate(verbosity, &workspace_hitlist) {
Err(e) => {
print_usage(&opts, &e.to_string());
failure
@ -115,7 +115,7 @@ pub enum Verbosity {
fn format_crate(
verbosity: Verbosity,
workspace_hitlist: WorkspaceHitlist,
workspace_hitlist: &WorkspaceHitlist,
) -> Result<ExitStatus, std::io::Error> {
let targets = get_targets(workspace_hitlist)?;
@ -178,9 +178,9 @@ pub enum WorkspaceHitlist {
}
impl WorkspaceHitlist {
pub fn get_some<'a>(&'a self) -> Option<&'a [String]> {
if let &WorkspaceHitlist::Some(ref hitlist) = self {
Some(&hitlist)
pub fn get_some(&self) -> Option<&[String]> {
if let WorkspaceHitlist::Some(ref hitlist) = *self {
Some(hitlist)
} else {
None
}
@ -196,9 +196,9 @@ impl WorkspaceHitlist {
}
// Returns a vector of all compile targets of a crate
fn get_targets(workspace_hitlist: WorkspaceHitlist) -> Result<Vec<Target>, std::io::Error> {
fn get_targets(workspace_hitlist: &WorkspaceHitlist) -> Result<Vec<Target>, std::io::Error> {
let mut targets: Vec<Target> = vec![];
if workspace_hitlist == WorkspaceHitlist::None {
if *workspace_hitlist == WorkspaceHitlist::None {
let output = Command::new("cargo").arg("read-manifest").output()?;
if output.status.success() {
// None of the unwraps should fail if output of `cargo read-manifest` is correct
@ -229,7 +229,7 @@ fn get_targets(workspace_hitlist: WorkspaceHitlist) -> Result<Vec<Target>, std::
let data = &String::from_utf8(output.stdout).unwrap();
let json: Value = json::from_str(data).unwrap();
let json_obj = json.as_object().unwrap();
let mut hitlist: HashSet<&String> = if workspace_hitlist != WorkspaceHitlist::All {
let mut hitlist: HashSet<&String> = if *workspace_hitlist != WorkspaceHitlist::All {
HashSet::from_iter(workspace_hitlist.get_some().unwrap())
} else {
HashSet::new() // Unused
@ -240,7 +240,7 @@ fn get_targets(workspace_hitlist: WorkspaceHitlist) -> Result<Vec<Target>, std::
.as_array()
.unwrap()
.into_iter()
.filter(|member| if workspace_hitlist == WorkspaceHitlist::All {
.filter(|member| if *workspace_hitlist == WorkspaceHitlist::All {
true
} else {
let member_obj = member.as_object().unwrap();
@ -248,7 +248,7 @@ fn get_targets(workspace_hitlist: WorkspaceHitlist) -> Result<Vec<Target>, std::
hitlist.take(&member_name.to_string()).is_some()
})
.collect();
if hitlist.len() != 0 {
if hitlist.is_empty() {
// Mimick cargo of only outputting one <package> spec.
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,

14
src/bin/rustfmt.rs
View File

@ -104,7 +104,7 @@ fn match_cli_path_or_file(
let toml = Config::from_toml_path(config_file.as_ref())?;
return Ok((toml, Some(config_file)));
}
Config::from_resolved_toml_path(input_file).map_err(|e| FmtError::from(e))
Config::from_resolved_toml_path(input_file).map_err(FmtError::from)
}
fn make_opts() -> Options {
@ -161,21 +161,21 @@ fn execute(opts: &Options) -> FmtResult<Summary> {
Operation::Help => {
print_usage(opts, "");
Summary::print_exit_codes();
Ok(Summary::new())
Ok(Summary::default())
}
Operation::Version => {
print_version();
Ok(Summary::new())
Ok(Summary::default())
}
Operation::ConfigHelp => {
Config::print_docs();
Ok(Summary::new())
Ok(Summary::default())
}
Operation::ConfigOutputDefault { path } => {
let mut file = File::create(path)?;
let toml = Config::default().all_options().to_toml()?;
file.write_all(toml.as_bytes())?;
Ok(Summary::new())
Ok(Summary::default())
}
Operation::Stdin { input, config_path } => {
// try to read config from local directory
@ -222,7 +222,7 @@ fn execute(opts: &Options) -> FmtResult<Summary> {
}
}
let mut error_summary = Summary::new();
let mut error_summary = Summary::default();
for file in files {
if !file.exists() {
println!("Error: file `{}` does not exist", file.to_str().unwrap());
@ -354,7 +354,7 @@ fn determine_operation(matches: &Matches) -> FmtResult<Operation> {
return config_path_not_found(path.to_str().unwrap());
}
}
path @ _ => path,
path => path,
};
// If no path is given, we won't output a minimal config.

4
src/chains.rs
View File

@ -256,7 +256,7 @@ pub fn rewrite_chain(expr: &ast::Expr, context: &RewriteContext, shape: Shape) -
"{}{}{}",
parent_rewrite,
first_connector,
join_rewrites(&rewrites, &subexpr_list, &connector)
join_rewrites(&rewrites, subexpr_list, &connector)
)
};
let result = format!("{}{}", result, repeat_try(suffix_try_num));
@ -475,7 +475,7 @@ fn rewrite_method_call(
let type_list: Vec<_> =
try_opt!(types.iter().map(|ty| ty.rewrite(context, shape)).collect());
let type_str = if context.config.spaces_within_angle_brackets() && type_list.len() > 0 {
let type_str = if context.config.spaces_within_angle_brackets() && !type_list.is_empty() {
format!("::< {} >", type_list.join(", "))
} else {
format!("::<{}>", type_list.join(", "))

7
src/codemap.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! This module contains utilities that work with the `CodeMap` from libsyntax / syntex_syntax.
//! This module contains utilities that work with the `CodeMap` from `libsyntax` / `syntex_syntax`.
//! This includes extension traits and methods for looking up spans and line ranges for AST nodes.
use std::rc::Rc;
@ -77,8 +77,9 @@ impl LineRangeUtils for CodeMap {
let lo = self.lookup_char_pos(span.lo());
let hi = self.lookup_char_pos(span.hi());
assert!(
lo.file.name == hi.file.name,
assert_eq!(
lo.file.name,
hi.file.name,
"span crossed file boundary: lo: {:?}, hi: {:?}",
lo,
hi

42
src/comment.rs
View File

@ -23,16 +23,14 @@ use utils::{first_line_width, last_line_width, wrap_str};
fn is_custom_comment(comment: &str) -> bool {
if !comment.starts_with("//") {
false
} else if let Some(c) = comment.chars().nth(2) {
!c.is_alphanumeric() && !c.is_whitespace()
} else {
if let Some(c) = comment.chars().nth(2) {
!c.is_alphanumeric() && !c.is_whitespace()
} else {
false
}
false
}
}
#[derive(PartialEq, Eq)]
#[derive(Copy, Clone, PartialEq, Eq)]
pub enum CommentStyle<'a> {
DoubleSlash,
TripleSlash,
@ -194,17 +192,15 @@ pub fn combine_strs_with_missing_comments(
};
let second_sep = if missing_comment.is_empty() || next_str.is_empty() {
String::new()
} else if missing_comment.starts_with("//") {
format!("\n{}", indent_str)
} else {
if missing_comment.starts_with("//") {
format!("\n{}", indent_str)
one_line_width += missing_comment.len() + first_sep.len() + 1;
allow_one_line &= !missing_comment.starts_with("//") && !missing_comment.contains('\n');
if prefer_same_line && allow_one_line && one_line_width <= shape.width {
String::from(" ")
} else {
one_line_width += missing_comment.len() + first_sep.len() + 1;
allow_one_line &= !missing_comment.starts_with("//") && !missing_comment.contains('\n');
if prefer_same_line && allow_one_line && one_line_width <= shape.width {
String::from(" ")
} else {
format!("\n{}", indent_str)
}
format!("\n{}", indent_str)
}
};
Some(format!(
@ -314,7 +310,7 @@ fn rewrite_comment_inner(
line = line.trim();
// Drop old closer.
if i == line_breaks && line.ends_with("*/") && !line.starts_with("//") {
line = &line[..(line.len() - 2)].trim_right();
line = line[..(line.len() - 2)].trim_right();
}
line
@ -339,7 +335,7 @@ fn rewrite_comment_inner(
}
if config.wrap_comments() && line.len() > max_chars {
let rewrite = rewrite_string(line, &fmt).unwrap_or(line.to_owned());
let rewrite = rewrite_string(line, &fmt).unwrap_or_else(|| line.to_owned());
result.push_str(&rewrite);
} else {
if line.is_empty() && result.ends_with(' ') {
@ -412,7 +408,7 @@ fn light_rewrite_comment(orig: &str, offset: Indent, config: &Config) -> Option<
// `*` in `/*`.
let first_non_whitespace = l.find(|c| !char::is_whitespace(c));
if let Some(fnw) = first_non_whitespace {
if l.as_bytes()[fnw] == '*' as u8 && fnw > 0 {
if l.as_bytes()[fnw] == b'*' && fnw > 0 {
&l[fnw - 1..]
} else {
&l[fnw..]
@ -432,7 +428,7 @@ fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle) -> &'a str {
line.starts_with("/** ")
{
&line[4..]
} else if let &CommentStyle::Custom(opener) = style {
} else if let CommentStyle::Custom(opener) = *style {
if line.starts_with(opener) {
&line[opener.len()..]
} else {
@ -646,7 +642,7 @@ where
_ => CharClassesStatus::Normal,
},
CharClassesStatus::BlockComment(deepness) => {
assert!(deepness != 0);
assert_ne!(deepness, 0);
self.status = match self.base.peek() {
Some(next) if next.get_char() == '/' && chr == '*' => {
CharClassesStatus::BlockCommentClosing(deepness - 1)
@ -901,10 +897,8 @@ impl<'a> Iterator for CommentReducer<'a> {
if c == '*' {
c = try_opt!(self.iter.next());
}
} else {
if c == '\n' {
self.at_start_line = true;
}
} else if c == '\n' {
self.at_start_line = true;
}
if !c.is_whitespace() {
return Some(c);

6
src/config.rs
View File

@ -280,11 +280,11 @@ macro_rules! create_config {
}
)+
pub fn set<'a>(&'a mut self) -> ConfigSetter<'a> {
pub fn set(&mut self) -> ConfigSetter {
ConfigSetter(self)
}
pub fn was_set<'a>(&'a self) -> ConfigWasSet<'a> {
pub fn was_set(&self) -> ConfigWasSet {
ConfigWasSet(self)
}
@ -306,7 +306,7 @@ macro_rules! create_config {
let table = parsed
.as_table()
.ok_or(String::from("Parsed config was not table"))?;
for (key, _) in table {
for key in table.keys() {
match &**key {
$(
stringify!($i) => (),

73
src/expr.rs
View File

@ -44,7 +44,7 @@ impl Rewrite for ast::Expr {
}
}
#[derive(PartialEq)]
#[derive(Copy, Clone, PartialEq)]
pub enum ExprType {
Statement,
SubExpression,
@ -249,7 +249,7 @@ pub fn format_expr(
}
match (lhs.as_ref().map(|x| &**x), rhs.as_ref().map(|x| &**x)) {
(Some(ref lhs), Some(ref rhs)) => {
(Some(lhs), Some(rhs)) => {
let sp_delim = if context.config.spaces_around_ranges() {
format!(" {} ", delim)
} else if needs_space_before_range(context, lhs) {
@ -257,23 +257,23 @@ pub fn format_expr(
} else {
delim.into()
};
rewrite_pair(&**lhs, &**rhs, "", &sp_delim, "", context, shape)
rewrite_pair(&*lhs, &*rhs, "", &sp_delim, "", context, shape)
}
(None, Some(ref rhs)) => {
(None, Some(rhs)) => {
let sp_delim = if context.config.spaces_around_ranges() {
format!("{} ", delim)
} else {
delim.into()
};
rewrite_unary_prefix(context, &sp_delim, &**rhs, shape)
rewrite_unary_prefix(context, &sp_delim, &*rhs, shape)
}
(Some(ref lhs), None) => {
(Some(lhs), None) => {
let sp_delim = if context.config.spaces_around_ranges() {
format!(" {}", delim)
} else {
delim.into()
};
rewrite_unary_suffix(context, &sp_delim, &**lhs, shape)
rewrite_unary_suffix(context, &sp_delim, &*lhs, shape)
}
(None, None) => wrap_str(delim.into(), context.config.max_width(), shape),
}
@ -488,7 +488,7 @@ where
let result = if context.config.array_layout() == IndentStyle::Visual ||
tactic == DefinitiveListTactic::Horizontal
{
if context.config.spaces_within_square_brackets() && list_str.len() > 0 {
if context.config.spaces_within_square_brackets() && !list_str.is_empty() {
format!("[ {} ]", list_str)
} else {
format!("[{}]", list_str)
@ -631,7 +631,7 @@ fn rewrite_closure(
};
if no_return_type && !needs_block {
// lock.stmts.len() == 1
if let Some(ref expr) = stmt_expr(&block.stmts[0]) {
if let Some(expr) = stmt_expr(&block.stmts[0]) {
if let Some(rw) = rewrite_closure_expr(expr, &prefix, context, body_shape) {
return Some(rw);
}
@ -651,7 +651,7 @@ fn rewrite_closure(
}
// Either we require a block, or tried without and failed.
rewrite_closure_block(&block, &prefix, context, body_shape)
rewrite_closure_block(block, &prefix, context, body_shape)
} else {
rewrite_closure_expr(body, &prefix, context, body_shape).or_else(|| {
// The closure originally had a non-block expression, but we can't fit on
@ -715,7 +715,7 @@ fn rewrite_closure_block(
// closure is large.
let block_threshold = context.config.closure_block_indent_threshold();
if block_threshold >= 0 {
if let Some(block_str) = block.rewrite(&context, shape) {
if let Some(block_str) = block.rewrite(context, shape) {
if block_str.matches('\n').count() <= block_threshold as usize &&
!need_block_indent(&block_str, shape)
{
@ -729,7 +729,7 @@ fn rewrite_closure_block(
// The body of the closure is big enough to be block indented, that
// means we must re-format.
let block_shape = shape.block();
let block_str = try_opt!(block.rewrite(&context, block_shape));
let block_str = try_opt!(block.rewrite(context, block_shape));
Some(format!("{} {}", prefix, block_str))
}
@ -933,7 +933,7 @@ struct ControlFlow<'a> {
span: Span,
}
fn to_control_flow<'a>(expr: &'a ast::Expr, expr_type: ExprType) -> Option<ControlFlow<'a>> {
fn to_control_flow(expr: &ast::Expr, expr_type: ExprType) -> Option<ControlFlow> {
match expr.node {
ast::ExprKind::If(ref cond, ref if_block, ref else_block) => Some(ControlFlow::new_if(
cond,
@ -1644,7 +1644,7 @@ fn rewrite_match_arm(
fn rewrite_match_pattern(
context: &RewriteContext,
pats: &Vec<ptr::P<ast::Pat>>,
pats: &[ptr::P<ast::Pat>],
guard: &Option<ptr::P<ast::Expr>>,
shape: Shape,
) -> Option<String> {
@ -1722,9 +1722,9 @@ fn rewrite_match_body(
has_guard: bool,
is_last: bool,
) -> Option<String> {
let (extend, body) = flatten_arm_body(context, &body);
let (extend, body) = flatten_arm_body(context, body);
let comma = arm_comma(&context.config, body, is_last);
let comma = arm_comma(context.config, body, is_last);
let alt_block_sep = String::from("\n") + &shape.indent.block_only().to_string(context.config);
let alt_block_sep = alt_block_sep.as_str();
let (is_block, is_empty_block) = if let ast::ExprKind::Block(ref block) = body.node {
@ -1790,7 +1790,7 @@ fn rewrite_match_body(
// Let's try and get the arm body on the same line as the condition.
// 4 = ` => `.len()
let orig_body_shape = shape
.offset_left(extra_offset(&pats_str, shape) + 4)
.offset_left(extra_offset(pats_str, shape) + 4)
.and_then(|shape| shape.sub_width(comma.len()));
let orig_body = if let Some(body_shape) = orig_body_shape {
let rewrite = nop_block_collapse(
@ -1985,10 +1985,8 @@ fn string_requires_rewrite(
if line.len() > shape.width {
return true;
}
} else {
if line.len() > shape.width + shape.indent.width() {
return true;
}
} else if line.len() > shape.width + shape.indent.width() {
return true;
}
}
@ -2049,7 +2047,7 @@ pub fn rewrite_call(
};
rewrite_call_inner(
context,
&callee,
callee,
&args.iter().map(|x| &**x).collect::<Vec<_>>(),
span,
shape,
@ -2076,7 +2074,7 @@ where
} else {
1
};
let used_width = extra_offset(&callee_str, shape);
let used_width = extra_offset(callee_str, shape);
let one_line_width = shape
.width
.checked_sub(used_width + 2 * paren_overhead)
@ -2117,7 +2115,7 @@ where
}
let args_shape = shape
.sub_width(last_line_width(&callee_str))
.sub_width(last_line_width(callee_str))
.ok_or(Ordering::Less)?;
Ok(format!(
"{}{}",
@ -2203,19 +2201,18 @@ fn try_overflow_last_arg<'a, T>(
where
T: Rewrite + Spanned + ToExpr + 'a,
{
let overflow_last = can_be_overflowed(&context, args);
let overflow_last = can_be_overflowed(context, args);
// Replace the last item with its first line to see if it fits with
// first arguments.
let placeholder = if overflow_last {
let mut context = context.clone();
if let Some(expr) = args[args.len() - 1].to_expr() {
match expr.node {
ast::ExprKind::MethodCall(..) => context.force_one_line_chain = true,
_ => (),
if let ast::ExprKind::MethodCall(..) = expr.node {
context.force_one_line_chain = true;
}
}
last_arg_shape(&context, &item_vec, shape, args_max_width).and_then(|arg_shape| {
last_arg_shape(&context, item_vec, shape, args_max_width).and_then(|arg_shape| {
rewrite_last_arg_with_overflow(&context, args, &mut item_vec[args.len() - 1], arg_shape)
})
} else {
@ -2253,12 +2250,12 @@ where
fn last_arg_shape(
context: &RewriteContext,
items: &Vec<ListItem>,
items: &[ListItem],
shape: Shape,
args_max_width: usize,
) -> Option<Shape> {
let overhead = items.iter().rev().skip(1).fold(0, |acc, i| {
acc + i.item.as_ref().map_or(0, |s| first_line_width(&s))
acc + i.item.as_ref().map_or(0, |s| first_line_width(s))
});
let max_width = min(args_max_width, shape.width);
let arg_indent = if context.use_block_indent() {
@ -2413,7 +2410,7 @@ pub fn wrap_args_with_parens(
(context.inside_macro && !args_str.contains('\n') &&
args_str.len() + paren_overhead(context) <= shape.width) || is_extendable
{
if context.config.spaces_within_parens() && args_str.len() > 0 {
if context.config.spaces_within_parens() && !args_str.is_empty() {
format!("( {} )", args_str)
} else {
format!("({})", args_str)
@ -2445,7 +2442,7 @@ fn rewrite_paren(context: &RewriteContext, subexpr: &ast::Expr, shape: Shape) ->
.and_then(|s| s.sub_width(paren_overhead))
);
let paren_wrapper = |s: &str| if context.config.spaces_within_parens() && s.len() > 0 {
let paren_wrapper = |s: &str| if context.config.spaces_within_parens() && !s.is_empty() {
format!("( {} )", s)
} else {
format!("({})", s)
@ -2505,7 +2502,7 @@ fn rewrite_index(
(_, Some(ref new_index_str)) if !new_index_str.contains('\n') => Some(format!(
"{}\n{}{}{}{}",
expr_str,
indent.to_string(&context.config),
indent.to_string(context.config),
lbr,
new_index_str,
rbr
@ -2513,7 +2510,7 @@ fn rewrite_index(
(None, Some(ref new_index_str)) => Some(format!(
"{}\n{}{}{}{}",
expr_str,
indent.to_string(&context.config),
indent.to_string(context.config),
lbr,
new_index_str,
rbr
@ -2556,7 +2553,7 @@ fn rewrite_struct_lit<'a>(
path_shape,
));
if fields.len() == 0 && base.is_none() {
if fields.is_empty() && base.is_none() {
return Some(format!("{} {{}}", path_str));
}
@ -2706,7 +2703,7 @@ pub fn rewrite_field(
"{}{}:\n{}{}",
attrs_str,
name,
expr_offset.to_string(&context.config),
expr_offset.to_string(context.config),
s
)
})
@ -2789,7 +2786,7 @@ where
};
let list_str = try_opt!(write_list(&item_vec, &fmt));
if context.config.spaces_within_parens() && list_str.len() > 0 {
if context.config.spaces_within_parens() && !list_str.is_empty() {
Some(format!("( {} )", list_str))
} else {
Some(format!("({})", list_str))

8
src/file_lines.rs
View File

@ -95,7 +95,7 @@ fn normalize_ranges(ranges: &mut HashMap<String, Vec<Range>>) {
{
let mut iter = ranges.into_iter().peekable();
while let Some(next) = iter.next() {
let mut next = next.clone();
let mut next = *next;
while let Some(&&mut peek) = iter.peek() {
if let Some(merged) = next.merge(peek) {
iter.next().unwrap();
@ -166,7 +166,7 @@ impl FileLines {
}
}
/// FileLines files iterator.
/// `FileLines` files iterator.
pub struct Files<'a>(
Option<::std::collections::hash_map::Keys<'a, String, Vec<Range>>>,
);
@ -197,9 +197,9 @@ impl str::FromStr for FileLines {
fn from_str(s: &str) -> Result<FileLines, String> {
let v: Vec<JsonSpan> = json::from_str(s).map_err(|e| e.to_string())?;
let mut m = HashMap::new();
for js in v.into_iter() {
for js in v {
let (s, r) = JsonSpan::into_tuple(js)?;
m.entry(s).or_insert(vec![]).push(r);
m.entry(s).or_insert_with(|| vec![]).push(r);
}
Ok(FileLines::from_ranges(m))
}

14
src/imports.rs
View File

@ -25,8 +25,8 @@ use visitor::FmtVisitor;
fn path_of(a: &ast::ViewPath_) -> &ast::Path {
match *a {
ast::ViewPath_::ViewPathSimple(_, ref p) => p,
ast::ViewPath_::ViewPathGlob(ref p) => p,
ast::ViewPath_::ViewPathSimple(_, ref p) |
ast::ViewPath_::ViewPathGlob(ref p) |
ast::ViewPath_::ViewPathList(ref p, _) => p,
}
}
@ -54,12 +54,10 @@ fn compare_path_list_items(a: &ast::PathListItem, b: &ast::PathListItem) -> Orde
} else {
Ordering::Less
}
} else if b_name_str == "self" {
Ordering::Greater
} else {
if b_name_str == "self" {
Ordering::Greater
} else {
a_name_str.cmp(&b_name_str)
}
a_name_str.cmp(b_name_str)
};
if name_ordering == Ordering::Equal {
match a.node.rename {
@ -137,7 +135,7 @@ fn rewrite_view_path_prefix(
path.segments.len() > 1
{
let path = &ast::Path {
span: path.span.clone(),
span: path.span,
segments: path.segments[..path.segments.len() - 1].to_owned(),
};
try_opt!(rewrite_path(

75
src/items.rs
View File

@ -80,7 +80,7 @@ impl Rewrite for ast::Local {
let pat_shape = try_opt!(shape.offset_left(4));
// 1 = ;
let pat_shape = try_opt!(pat_shape.sub_width(1));
let pat_str = try_opt!(self.pat.rewrite(&context, pat_shape));
let pat_str = try_opt!(self.pat.rewrite(context, pat_shape));
result.push_str(&pat_str);
// String that is placed within the assignment pattern and expression.
@ -111,7 +111,7 @@ impl Rewrite for ast::Local {
// 1 = trailing semicolon;
let nested_shape = try_opt!(shape.sub_width(1));
result = try_opt!(rewrite_assign_rhs(&context, result, ex, nested_shape));
result = try_opt!(rewrite_assign_rhs(context, result, ex, nested_shape));
}
result.push(';');
@ -195,7 +195,7 @@ impl<'a> FmtVisitor<'a> {
fn format_body_element(&mut self, element: &BodyElement) {
match *element {
BodyElement::ForeignItem(ref item) => self.format_foreign_item(item),
BodyElement::ForeignItem(item) => self.format_foreign_item(item),
}
}
@ -321,7 +321,7 @@ impl<'a> FmtVisitor<'a> {
if self.config.fn_single_line() && is_simple_block_stmt(block, codemap) {
let rewrite = {
if let Some(ref stmt) = block.stmts.first() {
if let Some(stmt) = block.stmts.first() {
match stmt_expr(stmt) {
Some(e) => {
let suffix = if semicolon_for_expr(&self.get_context(), e) {
@ -574,10 +574,10 @@ pub fn format_impl(
if try_opt!(is_impl_single_line(
context,
&items,
items,
&result,
&where_clause_str,
&item,
item,
)) {
result.push_str(&where_clause_str);
if where_clause_str.contains('\n') || last_line_contains_single_line_comment(&result) {
@ -680,7 +680,7 @@ fn format_impl_ref_and_type(
let mut result = String::with_capacity(128);
result.push_str(&format_visibility(&item.vis));
result.push_str(&format_defaultness(defaultness));
result.push_str(format_defaultness(defaultness));
result.push_str(format_unsafety(unsafety));
result.push_str("impl");
@ -713,7 +713,7 @@ fn format_impl_ref_and_type(
let result_len = result.len();
if let Some(trait_ref_str) = rewrite_trait_ref(
context,
&trait_ref,
trait_ref,
offset,
&generics_str,
true,
@ -731,7 +731,7 @@ fn format_impl_ref_and_type(
));
result.push_str(&try_opt!(rewrite_trait_ref(
context,
&trait_ref,
trait_ref,
offset,
&generics_str,
false,
@ -1100,7 +1100,7 @@ pub fn format_struct_struct(
if !generics_str.contains('\n') && result.len() + generics_str.len() + overhead > max_len {
result.push('\n');
result.push_str(&offset.to_string(context.config));
result.push_str(&generics_str.trim_left());
result.push_str(generics_str.trim_left());
} else {
result.push_str(&generics_str);
}
@ -1111,7 +1111,7 @@ pub fn format_struct_struct(
// `struct S {}`
} else if snippet.trim_right_matches(&[' ', '\t'][..]).ends_with('\n') {
// fix indent
result.push_str(&snippet.trim_right());
result.push_str(snippet.trim_right());
result.push('\n');
result.push_str(&offset.to_string(context.config));
} else {
@ -1178,7 +1178,7 @@ fn format_tuple_struct(
} else {
// This is a dirty hack to work around a missing `)` from the span of the last field.
let last_arg_span = fields[fields.len() - 1].span;
if context.snippet(last_arg_span).ends_with(")") {
if context.snippet(last_arg_span).ends_with(')') {
last_arg_span.hi()
} else {
context
@ -1226,7 +1226,7 @@ fn format_tuple_struct(
if snippet.is_empty() {
// `struct S ()`
} else if snippet.trim_right_matches(&[' ', '\t'][..]).ends_with('\n') {
result.push_str(&snippet.trim_right());
result.push_str(snippet.trim_right());
result.push('\n');
result.push_str(&offset.to_string(context.config));
} else {
@ -1440,7 +1440,7 @@ pub fn rewrite_struct_field(
let ty_rewritten = rewrite_struct_field_type(context, overhead, field, &spacing, shape);
if let Some(ref ty) = ty_rewritten {
if !ty.contains('\n') {
return Some(attr_prefix + &ty);
return Some(attr_prefix + ty);
}
}
@ -1461,17 +1461,17 @@ pub fn rewrite_struct_field(
Some(ref new_ty) if !new_ty.contains('\n') => format!(
"{}\n{}{}",
prefix,
type_offset.to_string(&context.config),
type_offset.to_string(context.config),
&new_ty
),
_ => prefix + &ty,
_ => prefix + ty,
},
_ => {
let ty = try_opt!(rewrite_type_in_next_line());
format!(
"{}\n{}{}",
prefix,
type_offset.to_string(&context.config),
type_offset.to_string(context.config),
&ty
)
}
@ -1554,7 +1554,7 @@ pub fn rewrite_associated_type(
.map(|ty_bound| ty_bound.rewrite(context, shape))
.collect::<Option<Vec<_>>>()
);
if bounds.len() > 0 {
if !bounds.is_empty() {
format!(": {}", join_bounds(context, shape, &bound_str))
} else {
String::new()
@ -1798,7 +1798,7 @@ fn rewrite_fn_base(
// return type later anyway.
let ret_str = try_opt!(
fd.output
.rewrite(&context, Shape::indented(indent, context.config))
.rewrite(context, Shape::indented(indent, context.config))
);
let multi_line_ret_str = ret_str.contains('\n');
@ -1826,26 +1826,24 @@ fn rewrite_fn_base(
if one_line_budget == 0 {
if snuggle_angle_bracket {
result.push('(');
} else if context.config.fn_args_paren_newline() {
result.push('\n');
result.push_str(&arg_indent.to_string(context.config));
if context.config.fn_args_layout() == IndentStyle::Visual {
arg_indent = arg_indent + 1; // extra space for `(`
}
result.push('(');
} else {
if context.config.fn_args_paren_newline() {
result.push_str("(");
if context.config.fn_args_layout() == IndentStyle::Visual {
result.push('\n');
result.push_str(&arg_indent.to_string(context.config));
if context.config.fn_args_layout() == IndentStyle::Visual {
arg_indent = arg_indent + 1; // extra space for `(`
}
result.push('(');
} else {
result.push_str("(");
if context.config.fn_args_layout() == IndentStyle::Visual {
result.push('\n');
result.push_str(&arg_indent.to_string(context.config));
}
}
}
} else {
result.push('(');
}
if context.config.spaces_within_parens() && fd.inputs.len() > 0 && result.ends_with('(') {
if context.config.spaces_within_parens() && !fd.inputs.is_empty() && result.ends_with('(') {
result.push(' ')
}
@ -1900,10 +1898,10 @@ fn rewrite_fn_base(
let used_width = last_line_used_width(&result, indent.width()) + first_line_width(&ret_str);
// Put the closing brace on the next line if it overflows the max width.
// 1 = `)`
if fd.inputs.len() == 0 && used_width + 1 > context.config.max_width() {
if fd.inputs.is_empty() && used_width + 1 > context.config.max_width() {
result.push('\n');
}
if context.config.spaces_within_parens() && fd.inputs.len() > 0 {
if context.config.spaces_within_parens() && !fd.inputs.is_empty() {
result.push(' ')
}
// If the last line of args contains comment, we cannot put the closing paren
@ -1924,7 +1922,7 @@ fn rewrite_fn_base(
if let ast::FunctionRetTy::Ty(..) = fd.output {
let ret_should_indent = match context.config.fn_args_layout() {
// If our args are block layout then we surely must have space.
IndentStyle::Block if put_args_in_block || fd.inputs.len() == 0 => false,
IndentStyle::Block if put_args_in_block || fd.inputs.is_empty() => false,
_ if args_last_line_contains_comment => false,
_ if result.contains('\n') || multi_line_ret_str => true,
_ => {
@ -2071,9 +2069,10 @@ fn rewrite_fn_base(
result.push_str(&where_clause_str);
force_new_line_for_brace |= last_line_contains_single_line_comment(&result);
return Some((result, force_new_line_for_brace));
Some((result, force_new_line_for_brace))
}
#[derive(Copy, Clone)]
struct WhereClauseOption {
suppress_comma: bool, // Force no trailing comma
snuggle: bool, // Do not insert newline before `where`
@ -2121,7 +2120,7 @@ fn rewrite_args(
let mut arg_item_strs = try_opt!(
args.iter()
.map(|arg| {
arg.rewrite(&context, Shape::legacy(multi_line_budget, arg_indent))
arg.rewrite(context, Shape::legacy(multi_line_budget, arg_indent))
})
.collect::<Option<Vec<_>>>()
);
@ -2203,7 +2202,7 @@ fn rewrite_args(
}
let fits_in_one_line = !generics_str_contains_newline &&
(arg_items.len() == 0 || arg_items.len() == 1 && arg_item_strs[0].len() <= one_line_budget);
(arg_items.is_empty() || arg_items.len() == 1 && arg_item_strs[0].len() <= one_line_budget);
for (item, arg) in arg_items.iter_mut().zip(arg_item_strs) {
item.item = Some(arg);
@ -2497,7 +2496,7 @@ fn rewrite_trait_bounds(
let bound_str = try_opt!(
bounds
.iter()
.map(|ty_bound| ty_bound.rewrite(&context, shape))
.map(|ty_bound| ty_bound.rewrite(context, shape))
.collect::<Option<Vec<_>>>()
);
Some(format!(": {}", join_bounds(context, shape, &bound_str)))

9
src/lib.rs
View File

@ -504,7 +504,7 @@ impl FormattingError {
fn msg_suffix(&self) -> String {
match self.kind {
ErrorKind::LineOverflow(..) if self.is_comment => format!(
ErrorKind::LineOverflow(..) if self.is_comment => String::from(
"use `error_on_line_overflow_comments = false` to suppress \
the warning against line comments\n",
),
@ -802,9 +802,8 @@ fn format_lines(text: &mut StringBuffer, name: &str, config: &Config, report: &m
last_wspace = Some(b);
}
} else if c == '/' {
match prev_char {
Some('/') => is_comment = true,
_ => (),
if let Some('/') = prev_char {
is_comment = true;
}
last_wspace = None;
} else {
@ -869,7 +868,7 @@ pub fn format_input<T: Write>(
config: &Config,
mut out: Option<&mut T>,
) -> Result<(Summary, FileMap, FormatReport), (io::Error, Summary)> {
let mut summary = Summary::new();
let mut summary = Summary::default();
if config.disable_all_formatting() {
return Ok((summary, FileMap::new(), FormatReport::new()));
}

25
src/lists.rs
View File

@ -20,7 +20,7 @@ use rewrite::RewriteContext;
use utils::{first_line_width, last_line_width, mk_sp};
/// Formatting tactic for lists. This will be cast down to a
/// DefinitiveListTactic depending on the number and length of the items and
/// `DefinitiveListTactic` depending on the number and length of the items and
/// their comments.
#[derive(Eq, PartialEq, Debug, Copy, Clone)]
pub enum ListTactic {
@ -172,7 +172,7 @@ impl DefinitiveListTactic {
}
/// The type of separator for lists.
#[derive(Eq, PartialEq, Debug)]
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub enum Separator {
Comma,
VerticalBar,
@ -346,9 +346,9 @@ where
if tactic == DefinitiveListTactic::Vertical {
// We cannot keep pre-comments on the same line if the comment if normalized.
let keep_comment = if formatting.config.normalize_comments() {
false
} else if item.pre_comment_style == ListItemCommentStyle::DifferentLine {
let keep_comment = if formatting.config.normalize_comments() ||
item.pre_comment_style == ListItemCommentStyle::DifferentLine
{
false
} else {
// We will try to keep the comment on the same line with the item here.
@ -405,7 +405,7 @@ where
formatting.config.max_width(),
));
}
let overhead = if let &mut Some(max_width) = item_max_width {
let overhead = if let Some(max_width) = *item_max_width {
max_width + 2
} else {
// 1 = space between item and comment.
@ -548,8 +548,7 @@ where
.chars()
.rev()
.take(comment_end + 1)
.find(|c| *c == '\n')
.is_some()
.any(|c| c == '\n')
{
(
Some(trimmed_pre_snippet.to_owned()),
@ -612,7 +611,7 @@ where
}
None => post_snippet
.find_uncommented(self.terminator)
.unwrap_or(post_snippet.len()),
.unwrap_or_else(|| post_snippet.len()),
};
if !post_snippet.is_empty() && comment_end > 0 {
@ -621,12 +620,14 @@ where
// Everything from the separator to the next item.
let test_snippet = &post_snippet[comment_end - 1..];
let first_newline = test_snippet.find('\n').unwrap_or(test_snippet.len());
let first_newline = test_snippet
.find('\n')
.unwrap_or_else(|| test_snippet.len());
// From the end of the first line of comments.
let test_snippet = &test_snippet[first_newline..];
let first = test_snippet
.find(|c: char| !c.is_whitespace())
.unwrap_or(test_snippet.len());
.unwrap_or_else(|| test_snippet.len());
// From the end of the first line of comments to the next non-whitespace char.
let test_snippet = &test_snippet[..first];
@ -747,7 +748,7 @@ pub fn struct_lit_shape(
IndentStyle::Block => {
let shape = shape.block_indent(context.config.tab_spaces());
Shape {
width: try_opt!(context.config.max_width().checked_sub(shape.indent.width())),
width: context.budget(shape.indent.width()),
..shape
}
}

5
src/macros.rs
View File

@ -224,7 +224,7 @@ pub fn rewrite_macro(
// If we are rewriting `vec!` macro or other special macros,
// then we can rewrite this as an usual array literal.
// Otherwise, we must preserve the original existence of trailing comma.
if FORCED_BRACKET_MACROS.contains(&&macro_name.as_str()) {
if FORCED_BRACKET_MACROS.contains(&macro_name.as_str()) {
context.inside_macro = false;
trailing_comma = false;
}
@ -355,8 +355,7 @@ fn indent_macro_snippet(
fn get_prefix_space_width(context: &RewriteContext, s: &str) -> usize {
let mut width = 0;
let mut iter = s.chars();
while let Some(c) = iter.next() {
for c in s.chars() {
match c {
' ' => width += 1,
'\t' => width += context.config.tab_spaces(),

4
src/missed_spans.rs
View File

@ -90,7 +90,7 @@ impl<'a> FmtVisitor<'a> {
let big_snippet = &local_begin.fm.src.as_ref().unwrap()[start_index..end_index];
let big_diff = (span.lo() - big_span_lo).to_usize();
let snippet = self.snippet(span.clone());
let snippet = self.snippet(span);
debug!("write_snippet `{}`", snippet);
@ -180,7 +180,7 @@ impl<'a> FmtVisitor<'a> {
last_wspace = None;
line_start = offset + subslice.len();
if let Some('/') = subslice.chars().skip(1).next() {
if let Some('/') = subslice.chars().nth(1) {
// check that there are no contained block comments
if !subslice
.split('\n')

21
src/patterns.rs
View File

@ -139,7 +139,7 @@ fn rewrite_struct_pat(
path_shape,
));
if fields.len() == 0 && !elipses {
if fields.is_empty() && !elipses {
return Some(format!("{} {{}}", path_str));
}
@ -223,7 +223,7 @@ pub enum TuplePatField<'a> {
impl<'a> Rewrite for TuplePatField<'a> {
fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
match *self {
TuplePatField::Pat(ref p) => p.rewrite(context, shape),
TuplePatField::Pat(p) => p.rewrite(context, shape),
TuplePatField::Dotdot(_) => Some("..".to_string()),
}
}
@ -232,15 +232,15 @@ impl<'a> Rewrite for TuplePatField<'a> {
impl<'a> Spanned for TuplePatField<'a> {
fn span(&self) -> Span {
match *self {
TuplePatField::Pat(ref p) => p.span(),
TuplePatField::Pat(p) => p.span(),
TuplePatField::Dotdot(span) => span,
}
}
}
pub fn can_be_overflowed_pat(context: &RewriteContext, pat: &TuplePatField, len: usize) -> bool {
match pat {
&TuplePatField::Pat(ref pat) => match pat.node {
match *pat {
TuplePatField::Pat(pat) => match pat.node {
ast::PatKind::Path(..) | ast::PatKind::Tuple(..) | ast::PatKind::Struct(..) => {
context.use_block_indent() && len == 1
}
@ -250,7 +250,7 @@ pub fn can_be_overflowed_pat(context: &RewriteContext, pat: &TuplePatField, len:
ast::PatKind::Lit(ref expr) => can_be_overflowed_expr(context, expr, len),
_ => false,
},
&TuplePatField::Dotdot(..) => false,
TuplePatField::Dotdot(..) => false,
}
}
@ -288,7 +288,7 @@ fn rewrite_tuple_pat(
}
if pat_vec.is_empty() {
return Some(format!("{}()", path_str.unwrap_or(String::new())));
return Some(format!("{}()", path_str.unwrap_or_default()));
}
let wildcard_suffix_len = count_wildcard_suffix_len(context, &pat_vec, span, shape);
@ -313,12 +313,13 @@ fn rewrite_tuple_pat(
if let Some(&TuplePatField::Dotdot(..)) = pat_vec.last() {
context.inside_macro = true;
}
let path_str = path_str.unwrap_or(String::new());
let path_str = path_str.unwrap_or_default();
let mut pat_ref_vec = Vec::with_capacity(pat_vec.len());
for pat in pat_vec {
pat_ref_vec.push(pat);
}
return rewrite_call_inner(
rewrite_call_inner(
&context,
&path_str,
&pat_ref_vec[..],
@ -326,7 +327,7 @@ fn rewrite_tuple_pat(
shape,
shape.width,
add_comma,
).ok();
).ok()
}
fn count_wildcard_suffix_len(

11
src/summary.rs
View File

@ -1,5 +1,5 @@
#[must_use]
#[derive(Debug, Clone)]
#[derive(Debug, Default, Clone)]
pub struct Summary {
// Encountered e.g. an IO error.
has_operational_errors: bool,
@ -15,15 +15,6 @@ pub struct Summary {
}
impl Summary {
pub fn new() -> Summary {
Summary {
has_operational_errors: false,
has_parsing_errors: false,
has_formatting_errors: false,
has_diff: false,
}
}
pub fn has_operational_errors(&self) -> bool {
self.has_operational_errors
}

6
src/types.rs
View File

@ -447,7 +447,7 @@ impl Rewrite for ast::WherePredicate {
);
let bounds_str = join_bounds(context, ty_shape, &bounds);
if context.config.spaces_within_angle_brackets() && lifetime_str.len() > 0 {
if context.config.spaces_within_angle_brackets() && !lifetime_str.is_empty() {
format!(
"for< {} > {}{}{}",
lifetime_str,
@ -635,7 +635,7 @@ impl Rewrite for ast::PolyTraitRef {
));
Some(
if context.config.spaces_within_angle_brackets() && lifetime_str.len() > 0 {
if context.config.spaces_within_angle_brackets() && !lifetime_str.is_empty() {
format!("for< {} > {}", lifetime_str, path_str)
} else {
format!("for<{}> {}", lifetime_str, path_str)
@ -812,7 +812,7 @@ fn rewrite_bare_fn(
Some(result)
}
pub fn join_bounds(context: &RewriteContext, shape: Shape, type_strs: &Vec<String>) -> String {
pub fn join_bounds(context: &RewriteContext, shape: Shape, type_strs: &[String]) -> String {
// Try to join types in a single line
let joiner = match context.config.type_punctuation_density() {
TypeDensity::Compressed => "+",

2
src/utils.rs
View File

@ -123,7 +123,7 @@ pub fn last_line_contains_single_line_comment(s: &str) -> bool {
#[inline]
pub fn is_attributes_extendable(attrs_str: &str) -> bool {
!attrs_str.contains('\n') && !last_line_contains_single_line_comment(&attrs_str)
!attrs_str.contains('\n') && !last_line_contains_single_line_comment(attrs_str)
}
// The width of the first line in s.

8
src/vertical.rs
View File

@ -284,13 +284,7 @@ fn group_aligned_items<T: AlignedItem>(
.skip(1)
.collect::<Vec<_>>()
.join("\n");
let spacings = if snippet
.lines()
.rev()
.skip(1)
.find(|l| l.trim().is_empty())
.is_some()
{
let spacings = if snippet.lines().rev().skip(1).any(|l| l.trim().is_empty()) {
"\n"
} else {
""

19
src/visitor.rs
View File

@ -260,7 +260,7 @@ impl<'a> FmtVisitor<'a> {
abi,
vis,
mk_sp(s.lo(), b.span.lo()),
&b,
b,
)
}
visit::FnKind::Method(ident, sig, vis, b) => {
@ -276,7 +276,7 @@ impl<'a> FmtVisitor<'a> {
sig.abi,
vis.unwrap_or(&ast::Visibility::Inherited),
mk_sp(s.lo(), b.span.lo()),
&b,
b,
)
}
visit::FnKind::Closure(_) => unreachable!(),
@ -503,8 +503,8 @@ impl<'a> FmtVisitor<'a> {
}
ast::ItemKind::MacroDef(..) => {
// FIXME(#1539): macros 2.0
let snippet = Some(self.snippet(item.span));
self.push_rewrite(item.span, snippet);
let mac_snippet = Some(self.snippet(item.span));
self.push_rewrite(item.span, mac_snippet);
}
}
}
@ -719,7 +719,7 @@ impl<'a> FmtVisitor<'a> {
// next item for output.
if self.config.reorder_imports() && is_use_item(&*items_left[0]) {
let used_items_len = self.reorder_items(
&items_left,
items_left,
&is_use_item,
self.config.reorder_imports_in_group(),
);
@ -727,7 +727,7 @@ impl<'a> FmtVisitor<'a> {
items_left = rest;
} else if self.config.reorder_extern_crates() && is_extern_crate(&*items_left[0]) {
let used_items_len = self.reorder_items(
&items_left,
items_left,
&is_extern_crate,
self.config.reorder_extern_crates_in_group(),
);
@ -863,10 +863,7 @@ impl Rewrite for ast::MetaItem {
.unwrap_or(0),
..shape
};
format!(
"{}",
try_opt!(rewrite_comment(&value, false, doc_shape, context.config))
)
try_opt!(rewrite_comment(&value, false, doc_shape, context.config))
} else {
format!("{} = {}", name, value)
}
@ -923,7 +920,7 @@ impl<'a> Rewrite for [ast::Attribute] {
{
// Look at before and after comment and see if there are any empty lines.
let comment_begin = comment.chars().position(|c| c == '/');
let len = comment_begin.unwrap_or(comment.len());
let len = comment_begin.unwrap_or_else(|| comment.len());
let mlb = comment.chars().take(len).filter(|c| *c == '\n').count() > 1;
let mla = if comment_begin.is_none() {
mlb

31
tests/system.rs
View File

@ -45,7 +45,7 @@ fn system_tests() {
// Display results.
println!("Ran {} system tests.", count);
assert!(fails == 0, "{} system tests failed", fails);
assert_eq!(fails, 0, "{} system tests failed", fails);
}
// Do the same for tests/coverage-source directory
@ -57,7 +57,7 @@ fn coverage_tests() {
let (_reports, count, fails) = check_files(files);
println!("Ran {} tests in coverage mode.", count);
assert!(fails == 0, "{} tests failed", fails);
assert_eq!(fails, 0, "{} tests failed", fails);
}
#[test]
@ -71,7 +71,7 @@ fn checkstyle_test() {
// Helper function for comparing the results of rustfmt
// to a known output file generated by one of the write modes.
fn assert_output(source: &str, expected_filename: &str) {
let config = read_config(&source);
let config = read_config(source);
let (file_map, _report) = format_file(source, &config);
// Populate output by writing to a vec.
@ -86,7 +86,7 @@ fn assert_output(source: &str, expected_filename: &str) {
.expect("Failed reading target");
let compare = make_diff(&expected_text, &output, DIFF_CONTEXT_SIZE);
if compare.len() > 0 {
if !compare.is_empty() {
let mut failures = HashMap::new();
failures.insert(source.to_string(), compare);
print_mismatches(failures);
@ -106,7 +106,7 @@ fn idempotence_tests() {
// Display results.
println!("Ran {} idempotent tests.", count);
assert!(fails == 0, "{} idempotent tests failed", fails);
assert_eq!(fails, 0, "{} idempotent tests failed", fails);
}
// Run rustfmt on itself. This operation must be idempotent. We also check that
@ -126,15 +126,16 @@ fn self_tests() {
// Display results.
println!("Ran {} self tests.", count);
assert!(fails == 0, "{} self tests failed", fails);
assert_eq!(fails, 0, "{} self tests failed", fails);
for format_report in reports {
println!("{}", format_report);
warnings += format_report.warning_count();
}
assert!(
warnings == 0,
assert_eq!(
warnings,
0,
"Rustfmt's code generated {} warnings",
warnings
);
@ -149,7 +150,7 @@ fn stdin_formatting_smoke_test() {
assert!(error_summary.has_no_errors());
for &(ref file_name, ref text) in &file_map {
if file_name == "stdin" {
assert!(text.to_string() == "fn main() {}\n");
assert_eq!(text.to_string(), "fn main() {}\n");
return;
}
}
@ -210,7 +211,7 @@ fn print_mismatches(result: HashMap<String, Vec<Mismatch>>) {
}
fn read_config(filename: &str) -> Config {
let sig_comments = read_significant_comments(&filename);
let sig_comments = read_significant_comments(filename);
// Look for a config file... If there is a 'config' property in the significant comments, use
// that. Otherwise, if there are no significant comments at all, look for a config file with
// the same name as the test file.
@ -241,8 +242,8 @@ fn format_file<P: Into<PathBuf>>(filepath: P, config: &Config) -> (FileMap, Form
let filepath = filepath.into();
let input = Input::File(filepath);
let (_error_summary, file_map, report) =
format_input::<io::Stdout>(input, &config, None).unwrap();
return (file_map, report);
format_input::<io::Stdout>(input, config, None).unwrap();
(file_map, report)
}
pub fn idempotent_check(filename: String) -> Result<FormatReport, HashMap<String, Vec<Mismatch>>> {
@ -273,7 +274,7 @@ fn get_config(config_file: Option<&str>) -> Config {
None => return Default::default(),
Some(file_name) => {
let mut full_path = "tests/config/".to_owned();
full_path.push_str(&file_name);
full_path.push_str(file_name);
if !Path::new(&full_path).exists() {
return Default::default();
};
@ -296,7 +297,7 @@ fn read_significant_comments(file_name: &str) -> HashMap<String, String> {
let file = fs::File::open(file_name).expect(&format!("Couldn't read file {}", file_name));
let reader = BufReader::new(file);
let pattern = r"^\s*//\s*rustfmt-([^:]+):\s*(\S+)";
let regex = regex::Regex::new(&pattern).expect("Failed creating pattern 1");
let regex = regex::Regex::new(pattern).expect("Failed creating pattern 1");
// Matches lines containing significant comments or whitespace.
let line_regex = regex::Regex::new(r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)")
@ -305,7 +306,7 @@ fn read_significant_comments(file_name: &str) -> HashMap<String, String> {
reader
.lines()
.map(|line| line.expect("Failed getting line"))
.take_while(|line| line_regex.is_match(&line))
.take_while(|line| line_regex.is_match(line))
.filter_map(|line| {
regex.captures_iter(&line).next().map(|capture| {
(