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

Merge commit '4236289b75ee55c78538c749512cdbeea5e1c332' into update-rustfmt

Browse Source
This commit is contained in:
Caleb Cartwright 2021-07-25 22:57:19 -05:00
parent 277feac1f9
commit e4b8714c09
39 changed files with 276 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Cargo.lock generated
View File

@ -73,7 +73,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "924c76597f0d9ca25d762c25a4d369d51267536465dc5064bdf0eb073ed477ea"
dependencies = [
"backtrace-sys",
"cfg-if",
"cfg-if 0.1.10",
"libc",
"rustc-demangle",
]
@ -162,6 +162,12 @@ version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "clap"
version = "2.33.0"
@ -207,7 +213,7 @@ version = "0.6.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04973fa96e96579258a5091af6003abde64af786b860f18622b82e026cca60e6"
dependencies = [
"cfg-if",
"cfg-if 0.1.10",
"lazy_static",
]
@ -218,7 +224,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce446db02cdc3165b94ae73111e570793400d0794e46125cc4056c81cbb039f4"
dependencies = [
"autocfg",
"cfg-if",
"cfg-if 0.1.10",
"lazy_static",
]
@ -245,7 +251,7 @@ version = "2.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13aea89a5c93364a98e9b37b2fa237effbb694d5cfe01c5b70941f7eb087d5e3"
dependencies = [
"cfg-if",
"cfg-if 0.1.10",
"dirs-sys",
]
@ -255,7 +261,7 @@ version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "afa0b23de8fd801745c471deffa6e12d248f962c9fd4b4c33787b055599bde7b"
dependencies = [
"cfg-if",
"cfg-if 0.1.10",
"libc",
"redox_users",
"winapi",
@ -401,11 +407,11 @@ checksum = "f2f96b10ec2560088a8e76961b00d47107b3a625fecb76dedb29ee7ccbf98235"
[[package]]
name = "log"
version = "0.4.8"
version = "0.4.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
dependencies = [
"cfg-if",
"cfg-if 1.0.0",
]
[[package]]
@ -426,7 +432,7 @@ version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a85ea9fc0d4ac0deb6fe7911d38786b32fc11119afd9e9d38b84ff691ce64220"
dependencies = [
"cfg-if",
"cfg-if 0.1.10",
]
[[package]]

24
Configurations.md
View File

@ -1475,7 +1475,9 @@ Copyright 2018 The Rust Project Developers.`, etc.:
## `match_arm_blocks`
Wrap the body of arms in blocks when it does not fit on the same line with the pattern of arms
Controls whether arm bodies are wrapped in cases where the first line of the body cannot fit on the same line as the `=>` operator.
The Style Guide requires that bodies are block wrapped by default if a line break is required after the `=>`, but this option can be used to disable that behavior to prevent wrapping arm bodies in that event, so long as the body does not contain multiple statements nor line comments.
- **Default value**: `true`
- **Possible values**: `true`, `false`
@ -1486,10 +1488,16 @@ Wrap the body of arms in blocks when it does not fit on the same line with the p
```rust
fn main() {
match lorem {
true => {
ipsum => {
foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x)
}
false => println!("{}", sit),
dolor => println!("{}", sit),
sit => foo(
"foooooooooooooooooooooooo",
"baaaaaaaaaaaaaaaaaaaaaaaarr",
"baaaaaaaaaaaaaaaaaaaazzzzzzzzzzzzz",
"qqqqqqqqquuuuuuuuuuuuuuuuuuuuuuuuuuxxx",
),
}
}
```
@ -1499,9 +1507,15 @@ fn main() {
```rust
fn main() {
match lorem {
true =>
lorem =>
foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x),
false => println!("{}", sit),
ipsum => println!("{}", sit),
sit => foo(
"foooooooooooooooooooooooo",
"baaaaaaaaaaaaaaaaaaaaaaaarr",
"baaaaaaaaaaaaaaaaaaaazzzzzzzzzzzzz",
"qqqqqqqqquuuuuuuuuuuuuuuuuuuuuuuuuuxxx",
),
}
}
```

6
Contributing.md
View File

@ -65,7 +65,7 @@ and get a better grasp on the execution flow.
## Hack!
Here are some [good starting issues](https://github.com/rust-lang/rustfmt/issues?q=is%3Aopen+is%3Aissue+label%3Agood-first-issue).
Here are some [good starting issues](https://github.com/rust-lang/rustfmt/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22).
If you've found areas which need polish and don't have issues, please submit a
PR, don't feel there needs to be an issue.
@ -138,8 +138,8 @@ format.
There are different nodes for every kind of item and expression in Rust. For
more details see the source code in the compiler -
[ast.rs](https://dxr.mozilla.org/rust/source/src/libsyntax/ast.rs) - and/or the
[docs](https://doc.rust-lang.org/nightly/nightly-rustc/syntax/ast/index.html).
[ast.rs](https://github.com/rust-lang/rust/blob/master/compiler/rustc_ast/src/ast.rs) - and/or the
[docs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/index.html).
Many nodes in the AST (but not all, annoyingly) have a `Span`. A `Span` is a
range in the source code, it can easily be converted to a snippet of source

4
README.md
View File

@ -230,5 +230,5 @@ Apache License (Version 2.0).
See [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT) for details.
[rust]: https://github.com/rust-lang/rust
[fmt rfcs]: https://github.com/rust-lang-nursery/fmt-rfcs
[style guide]: https://github.com/rust-lang-nursery/fmt-rfcs/blob/master/guide/guide.md
[fmt rfcs]: https://github.com/rust-dev-tools/fmt-rfcs
[style guide]: https://github.com/rust-dev-tools/fmt-rfcs/blob/master/guide/guide.md

110
appveyor.yml
View File

@ -1,55 +1,55 @@
# This is based on https://github.com/japaric/rust-everywhere/blob/master/appveyor.yml
# and modified (mainly removal of deployment) to suit rustfmt.
environment:
global:
PROJECT_NAME: rustfmt
matrix:
# Stable channel
# - TARGET: i686-pc-windows-gnu
# CHANNEL: stable
# - TARGET: i686-pc-windows-msvc
# CHANNEL: stable
# - TARGET: x86_64-pc-windows-gnu
# CHANNEL: stable
# - TARGET: x86_64-pc-windows-msvc
# CHANNEL: stable
# Beta channel
# - TARGET: i686-pc-windows-gnu
# CHANNEL: beta
# - TARGET: i686-pc-windows-msvc
# CHANNEL: beta
# - TARGET: x86_64-pc-windows-gnu
# CHANNEL: beta
# - TARGET: x86_64-pc-windows-msvc
# CHANNEL: beta
# Nightly channel
- TARGET: i686-pc-windows-gnu
CHANNEL: nightly
- TARGET: i686-pc-windows-msvc
CHANNEL: nightly
- TARGET: x86_64-pc-windows-gnu
CHANNEL: nightly
- TARGET: x86_64-pc-windows-msvc
CHANNEL: nightly
# Install Rust and Cargo
# (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
install:
- appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
- if "%TARGET%" == "i686-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw32\bin
- if "%TARGET%" == "x86_64-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw64\bin
- set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
- rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
- rustc -Vv
- cargo -V
# ???
build: false
test_script:
- set CFG_RELEASE_CHANNEL=nightly
- set CFG_RELEASE=nightly
- cargo build --verbose
- cargo test
- cargo test -- --ignored
# This is based on https://github.com/japaric/rust-everywhere/blob/master/appveyor.yml
# and modified (mainly removal of deployment) to suit rustfmt.
environment:
global:
PROJECT_NAME: rustfmt
matrix:
# Stable channel
# - TARGET: i686-pc-windows-gnu
# CHANNEL: stable
# - TARGET: i686-pc-windows-msvc
# CHANNEL: stable
# - TARGET: x86_64-pc-windows-gnu
# CHANNEL: stable
# - TARGET: x86_64-pc-windows-msvc
# CHANNEL: stable
# Beta channel
# - TARGET: i686-pc-windows-gnu
# CHANNEL: beta
# - TARGET: i686-pc-windows-msvc
# CHANNEL: beta
# - TARGET: x86_64-pc-windows-gnu
# CHANNEL: beta
# - TARGET: x86_64-pc-windows-msvc
# CHANNEL: beta
# Nightly channel
- TARGET: i686-pc-windows-gnu
CHANNEL: nightly
- TARGET: i686-pc-windows-msvc
CHANNEL: nightly
- TARGET: x86_64-pc-windows-gnu
CHANNEL: nightly
- TARGET: x86_64-pc-windows-msvc
CHANNEL: nightly
# Install Rust and Cargo
# (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
install:
- appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
- if "%TARGET%" == "i686-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw32\bin
- if "%TARGET%" == "x86_64-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw64\bin
- set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
- rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
- rustc -Vv
- cargo -V
# ???
build: false
test_script:
- set CFG_RELEASE_CHANNEL=nightly
- set CFG_RELEASE=nightly
- cargo build --verbose
- cargo test
- cargo test -- --ignored

2
rust-toolchain
View File

@ -1,3 +1,3 @@
[toolchain]
channel = "nightly-2021-05-13"
channel = "nightly-2021-07-23"
components = ["rustc-dev"]

2
src/attr.rs
View File

@ -183,7 +183,7 @@ fn format_derive(
} else if let SeparatorTactic::Always = context.config.trailing_comma() {
// Retain the trailing comma.
result.push_str(&item_str);
} else if item_str.ends_with(",") {
} else if item_str.ends_with(',') {
// Remove the trailing comma.
result.push_str(&item_str[..item_str.len() - 1]);
} else {

18
src/bin/main.rs
View File

@ -178,12 +178,15 @@ fn make_opts() -> Options {
opts.optflag("v", "verbose", "Print verbose output");
opts.optflag("q", "quiet", "Print less output");
opts.optflag("V", "version", "Show version information");
opts.optflagopt(
"h",
"help",
"Show this message or help about a specific topic: `config` or `file-lines`",
"=TOPIC",
);
let help_topics = if is_nightly {
"`config` or `file-lines`"
} else {
"`config`"
};
let mut help_topic_msg = "Show this message or help about a specific topic: ".to_owned();
help_topic_msg.push_str(help_topics);
opts.optflagopt("h", "help", &help_topic_msg, "=TOPIC");
opts
}
@ -437,7 +440,7 @@ fn determine_operation(matches: &Matches) -> Result<Operation, OperationError> {
return Ok(Operation::Help(HelpOp::None));
} else if topic == Some("config".to_owned()) {
return Ok(Operation::Help(HelpOp::Config));
} else if topic == Some("file-lines".to_owned()) {
} else if topic == Some("file-lines".to_owned()) && is_nightly() {
return Ok(Operation::Help(HelpOp::FileLines));
} else {
return Err(OperationError::UnknownHelpTopic(topic.unwrap()));
@ -689,6 +692,7 @@ fn edition_from_edition_str(edition_str: &str) -> Result<Edition> {
match edition_str {
"2015" => Ok(Edition::Edition2015),
"2018" => Ok(Edition::Edition2018),
"2021" => Ok(Edition::Edition2021),
_ => Err(format_err!("Invalid value for `--edition`")),
}
}

5
src/cargo-fmt/main.rs
View File

@ -1,6 +1,7 @@
// Inspired by Paul Woolcock's cargo-fmt (https://github.com/pwoolcoc/cargo-fmt/).
#![deny(warnings)]
#![allow(clippy::match_like_matches_macro)]
use std::cmp::Ordering;
use std::collections::{BTreeMap, BTreeSet};
@ -405,8 +406,8 @@ fn get_targets_recursive(
.packages
.iter()
.find(|p| p.name == dependency.name && p.source.is_none());
let manifest_path = if dependency_package.is_some() {
PathBuf::from(&dependency_package.unwrap().manifest_path)
let manifest_path = if let Some(dep_pkg) = dependency_package {
PathBuf::from(&dep_pkg.manifest_path)
} else {
let mut package_manifest_path = PathBuf::from(&package.manifest_path);
package_manifest_path.pop();

5
src/chains.rs
View File

@ -231,10 +231,7 @@ impl ChainItem {
}
fn is_comment(&self) -> bool {
match self.kind {
ChainItemKind::Comment(..) => true,
_ => false,
}
matches!(self.kind, ChainItemKind::Comment(..))
}
fn rewrite_method_call(

15
src/closures.rs
View File

@ -336,7 +336,7 @@ pub(crate) fn rewrite_last_closure(
// We force to use block for the body of the closure for certain kinds of expressions.
if is_block_closure_forced(context, body) {
return rewrite_closure_with_block(body, &prefix, context, body_shape).and_then(
return rewrite_closure_with_block(body, &prefix, context, body_shape).map(
|body_str| {
match fn_decl.output {
ast::FnRetTy::Default(..) if body_str.lines().count() <= 7 => {
@ -344,15 +344,15 @@ pub(crate) fn rewrite_last_closure(
// closure. However, if the closure has a return type, then we must
// keep the blocks.
match rewrite_closure_expr(body, &prefix, context, shape) {
Some(ref single_line_body_str)
Some(single_line_body_str)
if !single_line_body_str.contains('\n') =>
{
Some(single_line_body_str.clone())
single_line_body_str
}
_ => Some(body_str),
_ => body_str,
}
}
_ => Some(body_str),
_ => body_str,
}
},
);
@ -377,10 +377,7 @@ pub(crate) fn rewrite_last_closure(
pub(crate) fn args_have_many_closure(args: &[OverflowableItem<'_>]) -> bool {
args.iter()
.filter_map(OverflowableItem::to_expr)
.filter(|expr| match expr.kind {
ast::ExprKind::Closure(..) => true,
_ => false,
})
.filter(|expr| matches!(expr.kind, ast::ExprKind::Closure(..)))
.count()
> 1
}

21
src/comment.rs
View File

@ -67,10 +67,7 @@ impl<'a> CommentStyle<'a> {
/// Returns `true` if the commenting style is for documentation.
pub(crate) fn is_doc_comment(&self) -> bool {
match *self {
CommentStyle::TripleSlash | CommentStyle::Doc => true,
_ => false,
}
matches!(*self, CommentStyle::TripleSlash | CommentStyle::Doc)
}
pub(crate) fn opener(&self) -> &'a str {
@ -689,8 +686,8 @@ impl<'a> CommentRewrite<'a> {
self.code_block_attr = None;
self.item_block = None;
if line.starts_with("```") {
self.code_block_attr = Some(CodeBlockAttribute::new(&line[3..]))
if let Some(stripped) = line.strip_prefix("```") {
self.code_block_attr = Some(CodeBlockAttribute::new(stripped))
} else if self.fmt.config.wrap_comments() && ItemizedBlock::is_itemized_line(&line) {
let ib = ItemizedBlock::new(&line);
self.item_block = Some(ib);
@ -948,8 +945,8 @@ fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle<'_>) -> (&'a s
{
(&line[4..], true)
} else if let CommentStyle::Custom(opener) = *style {
if line.starts_with(opener) {
(&line[opener.len()..], true)
if let Some(ref stripped) = line.strip_prefix(opener) {
(stripped, true)
} else {
(&line[opener.trim_end().len()..], false)
}
@ -968,8 +965,8 @@ fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle<'_>) -> (&'a s
|| line.starts_with("**")
{
(&line[2..], line.chars().nth(1).unwrap() == ' ')
} else if line.starts_with('*') {
(&line[1..], false)
} else if let Some(stripped) = line.strip_prefix('*') {
(stripped, false)
} else {
(line, line.starts_with(' '))
}
@ -1682,8 +1679,8 @@ impl<'a> Iterator for CommentReducer<'a> {
fn remove_comment_header(comment: &str) -> &str {
if comment.starts_with("///") || comment.starts_with("//!") {
&comment[3..]
} else if comment.starts_with("//") {
&comment[2..]
} else if let Some(ref stripped) = comment.strip_prefix("//") {
stripped
} else if (comment.starts_with("/**") && !comment.starts_with("/**/"))
|| comment.starts_with("/*!")
{

2
src/config/config_type.rs
View File

@ -409,7 +409,7 @@ macro_rules! create_config {
if self.was_set().merge_imports() {
eprintln!(
"Warning: the `merge_imports` option is deprecated. \
Use `imports_granularity=Crate` instead"
Use `imports_granularity=\"Crate\"` instead"
);
if !self.was_set().imports_granularity() {
self.imports_granularity.2 = if self.merge_imports() {

4
src/config/file_lines.rs
View File

@ -305,7 +305,7 @@ impl str::FromStr for FileLines {
let mut m = HashMap::new();
for js in v {
let (s, r) = JsonSpan::into_tuple(js)?;
m.entry(s).or_insert_with(|| vec![]).push(r);
m.entry(s).or_insert_with(Vec::new).push(r);
}
Ok(FileLines::from_ranges(m))
}
@ -322,7 +322,7 @@ impl JsonSpan {
fn into_tuple(self) -> Result<(FileName, Range), FileLinesError> {
let (lo, hi) = self.range;
let canonical = canonicalize_path_string(&self.file)
.ok_or_else(|| FileLinesError::CannotCanonicalize(self.file))?;
.ok_or(FileLinesError::CannotCanonicalize(self.file))?;
Ok((canonical, Range::new(lo, hi)))
}
}

1
src/config/license.rs
View File

@ -3,7 +3,6 @@ use std::fs::File;
use std::io;
use std::io::Read;
use regex;
use regex::Regex;
#[derive(Debug)]

2
src/emitter/diff.rs
View File

@ -45,7 +45,7 @@ impl Emitter for DiffEmitter {
return Ok(EmitterResult { has_diff: true });
}
return Ok(EmitterResult { has_diff });
Ok(EmitterResult { has_diff })
}
}

30
src/expr.rs
View File

@ -263,15 +263,12 @@ pub(crate) fn format_expr(
}
fn needs_space_after_range(rhs: &ast::Expr) -> bool {
match rhs.kind {
// Don't format `.. ..` into `....`, which is invalid.
//
// This check is unnecessary for `lhs`, because a range
// starting from another range needs parentheses as `(x ..) ..`
// (`x .. ..` is a range from `x` to `..`).
ast::ExprKind::Range(None, _, _) => true,
_ => false,
}
// Don't format `.. ..` into `....`, which is invalid.
//
// This check is unnecessary for `lhs`, because a range
// starting from another range needs parentheses as `(x ..) ..`
// (`x .. ..` is a range from `x` to `..`).
matches!(rhs.kind, ast::ExprKind::Range(None, _, _))
}
let default_sp_delim = |lhs: Option<&ast::Expr>, rhs: Option<&ast::Expr>| {
@ -531,7 +528,7 @@ pub(crate) fn rewrite_block_with_visitor(
let inner_attrs = attrs.map(inner_attributes);
let label_str = rewrite_label(label);
visitor.visit_block(block, inner_attrs.as_ref().map(|a| &**a), has_braces);
visitor.visit_block(block, inner_attrs.as_deref(), has_braces);
let visitor_context = visitor.get_context();
context
.skipped_range
@ -595,7 +592,7 @@ pub(crate) fn rewrite_cond(
String::from("\n") + &shape.indent.block_only().to_string(context.config);
control_flow
.rewrite_cond(context, shape, &alt_block_sep)
.and_then(|rw| Some(rw.0))
.map(|rw| rw.0)
}),
}
}
@ -1157,18 +1154,11 @@ pub(crate) fn is_empty_block(
}
pub(crate) fn stmt_is_expr(stmt: &ast::Stmt) -> bool {
match stmt.kind {
ast::StmtKind::Expr(..) => true,
_ => false,
}
matches!(stmt.kind, ast::StmtKind::Expr(..))
}
pub(crate) fn is_unsafe_block(block: &ast::Block) -> bool {
if let ast::BlockCheckMode::Unsafe(..) = block.rules {
true
} else {
false
}
matches!(block.rules, ast::BlockCheckMode::Unsafe(..))
}
pub(crate) fn rewrite_literal(

2
src/formatting/newline_style.rs
View File

@ -77,7 +77,7 @@ fn convert_to_windows_newlines(formatted_text: &String) -> String {
transformed
}
fn convert_to_unix_newlines(formatted_text: &String) -> String {
fn convert_to_unix_newlines(formatted_text: &str) -> String {
formatted_text.replace(WINDOWS_NEWLINE, UNIX_NEWLINE)
}

30
src/imports.rs
View File

@ -374,7 +374,7 @@ impl UseTree {
UseTreeKind::Nested(ref list) => {
// Extract comments between nested use items.
// This needs to be done before sorting use items.
let items: Vec<_> = itemize_list(
let items = itemize_list(
context.snippet_provider,
list.iter().map(|(tree, _)| tree),
"}",
@ -385,8 +385,8 @@ impl UseTree {
context.snippet_provider.span_after(a.span, "{"),
a.span.hi(),
false,
)
.collect();
);
// in case of a global path and the nested list starts at the root,
// e.g., "::{foo, bar}"
if a.prefix.segments.len() == 1 && leading_modsep {
@ -394,7 +394,7 @@ impl UseTree {
}
result.path.push(UseSegment::List(
list.iter()
.zip(items.into_iter())
.zip(items)
.map(|(t, list_item)| {
Self::from_ast(context, &t.0, Some(list_item), None, None, None)
})
@ -466,11 +466,8 @@ impl UseTree {
// Normalise foo::self as bar -> foo as bar.
if let UseSegment::Slf(_) = last {
match self.path.last() {
Some(UseSegment::Ident(_, None)) => {
aliased_self = true;
}
_ => {}
if let Some(UseSegment::Ident(_, None)) = self.path.last() {
aliased_self = true;
}
}
@ -572,9 +569,8 @@ impl UseTree {
match self.path.clone().last().unwrap() {
UseSegment::List(list) => {
if list.len() == 1 && list[0].path.len() == 1 {
match list[0].path[0] {
UseSegment::Slf(..) => return vec![self],
_ => (),
if let UseSegment::Slf(..) = list[0].path[0] {
return vec![self];
};
}
let prefix = &self.path[..self.path.len() - 1];
@ -790,13 +786,9 @@ fn rewrite_nested_use_tree(
}
}
let has_nested_list = use_tree_list.iter().any(|use_segment| {
use_segment
.path
.last()
.map_or(false, |last_segment| match last_segment {
UseSegment::List(..) => true,
_ => false,
})
use_segment.path.last().map_or(false, |last_segment| {
matches!(last_segment, UseSegment::List(..))
})
});
let remaining_width = if has_nested_list {

14
src/issues.rs
View File

@ -126,11 +126,7 @@ impl BadIssueSeeker {
return Seeking::Number {
issue: Issue {
issue_type: IssueType::Todo,
missing_number: if let ReportTactic::Unnumbered = self.report_todo {
true
} else {
false
},
missing_number: matches!(self.report_todo, ReportTactic::Unnumbered),
},
part: NumberPart::OpenParen,
};
@ -144,11 +140,7 @@ impl BadIssueSeeker {
return Seeking::Number {
issue: Issue {
issue_type: IssueType::Fixme,
missing_number: if let ReportTactic::Unnumbered = self.report_fixme {
true
} else {
false
},
missing_number: matches!(self.report_fixme, ReportTactic::Unnumbered),
},
part: NumberPart::OpenParen,
};
@ -196,7 +188,7 @@ impl BadIssueSeeker {
}
}
NumberPart::Number => {
if c >= '0' && c <= '9' {
if ('0'..='9').contains(&c) {
part = NumberPart::CloseParen;
} else {
return IssueClassification::Bad(issue);

26
src/items.rs
View File

@ -741,7 +741,7 @@ pub(crate) fn format_impl(
// there is only one where-clause predicate
// recover the suppressed comma in single line where_clause formatting
if generics.where_clause.predicates.len() == 1 {
result.push_str(",");
result.push(',');
}
result.push_str(&format!("{}{{{}}}", sep, sep));
} else {
@ -1207,7 +1207,7 @@ impl<'a> Rewrite for TraitAliasBounds<'a> {
let fits_single_line = !generic_bounds_str.contains('\n')
&& !where_str.contains('\n')
&& generic_bounds_str.len() + where_str.len() + 1 <= shape.width;
&& generic_bounds_str.len() + where_str.len() < shape.width;
let space = if generic_bounds_str.is_empty() || where_str.is_empty() {
Cow::from("")
} else if fits_single_line {
@ -1236,8 +1236,8 @@ pub(crate) fn format_trait_alias(
let lhs = format!("{}trait {} =", vis_str, generics_str);
// 1 = ";"
let trait_alias_bounds = TraitAliasBounds {
generics,
generic_bounds,
generics,
};
rewrite_assign_rhs(context, lhs, &trait_alias_bounds, shape.sub_width(1)?).map(|s| s + ";")
}
@ -1993,7 +1993,7 @@ impl Rewrite for ast::Param {
let num_attrs = self.attrs.len();
(
mk_sp(self.attrs[num_attrs - 1].span.hi(), self.pat.span.lo()),
param_attrs_result.contains("\n"),
param_attrs_result.contains('\n'),
)
} else {
(mk_sp(self.span.lo(), self.span.lo()), false)
@ -3265,22 +3265,16 @@ pub(crate) fn rewrite_extern_crate(
/// Returns `true` for `mod foo;`, false for `mod foo { .. }`.
pub(crate) fn is_mod_decl(item: &ast::Item) -> bool {
match item.kind {
ast::ItemKind::Mod(_, ast::ModKind::Loaded(_, ast::Inline::Yes, _)) => false,
_ => true,
}
!matches!(
item.kind,
ast::ItemKind::Mod(_, ast::ModKind::Loaded(_, ast::Inline::Yes, _))
)
}
pub(crate) fn is_use_item(item: &ast::Item) -> bool {
match item.kind {
ast::ItemKind::Use(_) => true,
_ => false,
}
matches!(item.kind, ast::ItemKind::Use(_))
}
pub(crate) fn is_extern_crate(item: &ast::Item) -> bool {
match item.kind {
ast::ItemKind::ExternCrate(..) => true,
_ => false,
}
matches!(item.kind, ast::ItemKind::ExternCrate(..))
}

7
src/lib.rs
View File

@ -2,6 +2,7 @@
#![deny(rust_2018_idioms)]
#![warn(unreachable_pub)]
#![recursion_limit = "256"]
#![allow(clippy::match_like_matches_macro)]
#[macro_use]
extern crate derive_new;
@ -30,7 +31,6 @@ use std::panic;
use std::path::PathBuf;
use std::rc::Rc;
use ignore;
use rustc_ast::ast;
use rustc_span::{symbol, DUMMY_SP};
use thiserror::Error;
@ -149,10 +149,7 @@ pub enum ErrorKind {
impl ErrorKind {
fn is_comment(&self) -> bool {
match self {
ErrorKind::LostComment => true,
_ => false,
}
matches!(self, ErrorKind::LostComment)
}
}

11
src/lists.rs
View File

@ -194,10 +194,7 @@ impl ListItem {
// Returns `true` if the item causes something to be written.
fn is_substantial(&self) -> bool {
fn empty(s: &Option<String>) -> bool {
match *s {
Some(ref s) if !s.is_empty() => false,
_ => true,
}
!matches!(*s, Some(ref s) if !s.is_empty())
}
!(empty(&self.pre_comment) && empty(&self.item) && empty(&self.post_comment))
@ -618,8 +615,8 @@ pub(crate) fn extract_post_comment(
let post_snippet = post_snippet[..comment_end].trim();
let post_snippet_trimmed = if post_snippet.starts_with(|c| c == ',' || c == ':') {
post_snippet[1..].trim_matches(white_space)
} else if post_snippet.starts_with(separator) {
post_snippet[separator.len()..].trim_matches(white_space)
} else if let Some(stripped) = post_snippet.strip_prefix(separator) {
stripped.trim_matches(white_space)
}
// not comment or over two lines
else if post_snippet.ends_with(',')
@ -823,7 +820,7 @@ where
pub(crate) fn total_item_width(item: &ListItem) -> usize {
comment_len(item.pre_comment.as_ref().map(|x| &(*x)[..]))
+ comment_len(item.post_comment.as_ref().map(|x| &(*x)[..]))
+ &item.item.as_ref().map_or(0, |s| unicode_str_width(&s))
+ item.item.as_ref().map_or(0, |s| unicode_str_width(&s))
}
fn comment_len(comment: Option<&str>) -> usize {

39
src/macros.rs
View File

@ -179,10 +179,10 @@ fn return_macro_parse_failure_fallback(
.lines()
.last()
.map(|closing_line| {
closing_line.trim().chars().all(|ch| match ch {
'}' | ')' | ']' => true,
_ => false,
})
closing_line
.trim()
.chars()
.all(|ch| matches!(ch, '}' | ')' | ']'))
})
.unwrap_or(false);
if is_like_block_indent_style {
@ -690,25 +690,22 @@ fn delim_token_to_str(
impl MacroArgKind {
fn starts_with_brace(&self) -> bool {
match *self {
matches!(
*self,
MacroArgKind::Repeat(DelimToken::Brace, _, _, _)
| MacroArgKind::Delimited(DelimToken::Brace, _) => true,
_ => false,
}
| MacroArgKind::Delimited(DelimToken::Brace, _)
)
}
fn starts_with_dollar(&self) -> bool {
match *self {
MacroArgKind::Repeat(..) | MacroArgKind::MetaVariable(..) => true,
_ => false,
}
matches!(
*self,
MacroArgKind::Repeat(..) | MacroArgKind::MetaVariable(..)
)
}
fn ends_with_space(&self) -> bool {
match *self {
MacroArgKind::Separator(..) => true,
_ => false,
}
matches!(*self, MacroArgKind::Separator(..))
}
fn has_meta_var(&self) -> bool {
@ -1162,10 +1159,10 @@ fn force_space_before(tok: &TokenKind) -> bool {
}
fn ident_like(tok: &Token) -> bool {
match tok.kind {
TokenKind::Ident(..) | TokenKind::Literal(..) | TokenKind::Lifetime(_) => true,
_ => false,
}
matches!(
tok.kind,
TokenKind::Ident(..) | TokenKind::Literal(..) | TokenKind::Lifetime(_)
)
}
fn next_space(tok: &TokenKind) -> SpaceState {
@ -1399,7 +1396,7 @@ impl MacroBranch {
// Undo our replacement of macro variables.
// FIXME: this could be *much* more efficient.
for (old, new) in &substs {
if old_body.find(new).is_some() {
if old_body.contains(new) {
debug!("rewrite_macro_def: bailing matching variable: `{}`", new);
return None;
}

7
src/matches.rs
View File

@ -19,7 +19,7 @@ use crate::source_map::SpanUtils;
use crate::spanned::Spanned;
use crate::utils::{
contains_skip, extra_offset, first_line_width, inner_attributes, last_line_extendable, mk_sp,
mk_sp_lo_plus_one, semicolon_for_expr, trimmed_last_line_width, unicode_str_width,
semicolon_for_expr, trimmed_last_line_width, unicode_str_width,
};
/// A simple wrapper type against `ast::Arm`. Used inside `write_list()`.
@ -167,8 +167,9 @@ fn collect_beginning_verts(
arms.iter()
.map(|a| {
context
.snippet_provider
.opt_span_before(mk_sp_lo_plus_one(a.pat.span.lo()), "|")
.snippet(a.pat.span)
.starts_with("|")
.then(|| a.pat.span().lo())
})
.collect()
}

8
src/missed_spans.rs
View File

@ -230,8 +230,7 @@ impl<'a> FmtVisitor<'a> {
let last_char = big_snippet
.chars()
.rev()
.skip_while(|rev_c| [' ', '\t'].contains(rev_c))
.next();
.find(|rev_c| ![' ', '\t'].contains(rev_c));
let fix_indent = last_char.map_or(true, |rev_c| ['{', '\n'].contains(&rev_c));
let mut on_same_line = false;
@ -262,7 +261,7 @@ impl<'a> FmtVisitor<'a> {
let comment_shape = Shape::legacy(comment_width, comment_indent);
if on_same_line {
match subslice.find("\n") {
match subslice.find('\n') {
None => {
self.push_str(subslice);
}
@ -299,8 +298,7 @@ impl<'a> FmtVisitor<'a> {
match snippet[status.line_start..]
.chars()
// skip trailing whitespaces
.skip_while(|c| *c == ' ' || *c == '\t')
.next()
.find(|c| !(*c == ' ' || *c == '\t'))
{
Some('\n') | Some('\r') => {
if !is_last_comment_block(subslice) {

28
src/overflow.rs
View File

@ -126,21 +126,19 @@ impl<'a> OverflowableItem<'a> {
OverflowableItem::MacroArg(MacroArg::Expr(expr)) => is_simple_expr(expr),
OverflowableItem::NestedMetaItem(nested_meta_item) => match nested_meta_item {
ast::NestedMetaItem::Literal(..) => true,
ast::NestedMetaItem::MetaItem(ref meta_item) => match meta_item.kind {
ast::MetaItemKind::Word => true,
_ => false,
},
ast::NestedMetaItem::MetaItem(ref meta_item) => {
matches!(meta_item.kind, ast::MetaItemKind::Word)
}
},
_ => false,
}
}
pub(crate) fn is_expr(&self) -> bool {
match self {
OverflowableItem::Expr(..) => true,
OverflowableItem::MacroArg(MacroArg::Expr(..)) => true,
_ => false,
}
matches!(
self,
OverflowableItem::Expr(..) | OverflowableItem::MacroArg(MacroArg::Expr(..))
)
}
pub(crate) fn is_nested_call(&self) -> bool {
@ -154,10 +152,7 @@ impl<'a> OverflowableItem<'a> {
pub(crate) fn to_expr(&self) -> Option<&'a ast::Expr> {
match self {
OverflowableItem::Expr(expr) => Some(expr),
OverflowableItem::MacroArg(macro_arg) => match macro_arg {
MacroArg::Expr(ref expr) => Some(expr),
_ => None,
},
OverflowableItem::MacroArg(MacroArg::Expr(ref expr)) => Some(expr),
_ => None,
}
}
@ -178,10 +173,9 @@ impl<'a> OverflowableItem<'a> {
ast::NestedMetaItem::MetaItem(..) => true,
}
}
OverflowableItem::SegmentParam(seg) => match seg {
SegmentParam::Type(ty) => can_be_overflowed_type(context, ty, len),
_ => false,
},
OverflowableItem::SegmentParam(SegmentParam::Type(ty)) => {
can_be_overflowed_type(context, ty, len)
}
OverflowableItem::TuplePatField(pat) => can_be_overflowed_pat(context, pat, len),
OverflowableItem::Ty(ty) => can_be_overflowed_type(context, ty, len),
_ => false,

25
src/patterns.rs
View File

@ -238,7 +238,7 @@ impl Rewrite for Pat {
if let Some(rw) = p.rewrite(context, shape) {
rw
} else {
format!("{}", context.snippet(p.span))
context.snippet(p.span).to_string()
}
})
.collect();
@ -310,23 +310,22 @@ fn rewrite_struct_pat(
if fields_str.contains('\n') || fields_str.len() > one_line_width {
// Add a missing trailing comma.
if context.config.trailing_comma() == SeparatorTactic::Never {
fields_str.push_str(",");
fields_str.push(',');
}
fields_str.push_str("\n");
fields_str.push('\n');
fields_str.push_str(&nested_shape.indent.to_string(context.config));
fields_str.push_str("..");
} else {
if !fields_str.is_empty() {
// there are preceding struct fields being matched on
if tactic == DefinitiveListTactic::Vertical {
// if the tactic is Vertical, write_list already added a trailing ,
fields_str.push_str(" ");
fields_str.push(' ');
} else {
fields_str.push_str(", ");
}
}
fields_str.push_str("..");
}
fields_str.push_str("..");
}
// ast::Pat doesn't have attrs so use &[]
@ -411,10 +410,7 @@ impl<'a> Spanned for TuplePatField<'a> {
impl<'a> TuplePatField<'a> {
fn is_dotdot(&self) -> bool {
match self {
TuplePatField::Pat(pat) => match pat.kind {
ast::PatKind::Rest => true,
_ => false,
},
TuplePatField::Pat(pat) => matches!(pat.kind, ast::PatKind::Rest),
TuplePatField::Dotdot(_) => true,
}
}
@ -510,10 +506,11 @@ fn count_wildcard_suffix_len(
)
.collect();
for item in items.iter().rev().take_while(|i| match i.item {
Some(ref internal_string) if internal_string == "_" => true,
_ => false,
}) {
for item in items
.iter()
.rev()
.take_while(|i| matches!(i.item, Some(ref internal_string) if internal_string == "_"))
{
suffix_len += 1;
if item.has_comment() {

7
src/rustfmt_diff.rs
View File

@ -56,10 +56,7 @@ impl From<Vec<Mismatch>> for ModifiedLines {
let chunks = mismatches.into_iter().map(|mismatch| {
let lines = mismatch.lines.iter();
let num_removed = lines
.filter(|line| match line {
DiffLine::Resulting(_) => true,
_ => false,
})
.filter(|line| matches!(line, DiffLine::Resulting(_)))
.count();
let new_lines = mismatch.lines.into_iter().filter_map(|line| match line {
@ -94,7 +91,7 @@ impl fmt::Display for ModifiedLines {
"{} {} {}",
chunk.line_number_orig,
chunk.lines_removed,
chunk.lines.iter().count()
chunk.lines.len()
)?;
for line in &chunk.lines {

6
src/skip.rs
View File

@ -32,8 +32,8 @@ impl SkipContext {
}
}
static RUSTFMT: &'static str = "rustfmt";
static SKIP: &'static str = "skip";
static RUSTFMT: &str = "rustfmt";
static SKIP: &str = "skip";
/// Say if you're playing with `rustfmt`'s skip attribute
pub(crate) fn is_skip_attr(segments: &[ast::PathSegment]) -> bool {
@ -46,7 +46,7 @@ pub(crate) fn is_skip_attr(segments: &[ast::PathSegment]) -> bool {
segments[1].ident.to_string() == SKIP
&& ["macros", "attributes"]
.iter()
.any(|&n| n == &pprust::path_segment_to_string(&segments[2]))
.any(|&n| n == pprust::path_segment_to_string(&segments[2]))
}
_ => false,
}

2
src/source_file.rs
View File

@ -18,7 +18,7 @@ use rustc_data_structures::sync::Lrc;
// Append a newline to the end of each file.
pub(crate) fn append_newline(s: &mut String) {
s.push_str("\n");
s.push('\n');
}
#[cfg(test)]

4
src/string.rs
View File

@ -57,7 +57,7 @@ impl<'a> StringFormat<'a> {
/// This allows to fit more graphemes from the string on a line when
/// SnippetState::EndWithLineFeed.
fn max_width_without_indent(&self) -> Option<usize> {
Some(self.config.max_width().checked_sub(self.line_end.len())?)
self.config.max_width().checked_sub(self.line_end.len())
}
}
@ -99,7 +99,7 @@ pub(crate) fn rewrite_string<'a>(
if is_new_line(grapheme) {
// take care of blank lines
result = trim_end_but_line_feed(fmt.trim_end, result);
result.push_str("\n");
result.push('\n');
if !is_bareline_ok && cur_start + i + 1 < graphemes.len() {
result.push_str(&indent_without_newline);
result.push_str(fmt.line_start);

5
src/syntux/parser.rs
View File

@ -79,7 +79,7 @@ impl<'a> ParserBuilder<'a> {
rustc_span::FileName::Custom("stdin".to_owned()),
text,
)
.map_err(|db| Some(db)),
.map_err(Some),
}
}
}
@ -196,8 +196,7 @@ impl<'a> Parser<'a> {
mac: &'a ast::MacCall,
) -> Result<Vec<ast::Item>, &'static str> {
let token_stream = mac.args.inner_tokens();
let mut parser =
rustc_parse::stream_to_parser(sess.inner(), token_stream.clone(), Some(""));
let mut parser = rustc_parse::stream_to_parser(sess.inner(), token_stream, Some(""));
let mut items = vec![];
let mut process_if_cfg = true;

15
src/types.rs
View File

@ -662,7 +662,7 @@ impl Rewrite for ast::Ty {
let mut_str = format_mutability(mt.mutbl);
let mut_len = mut_str.len();
let mut result = String::with_capacity(128);
result.push_str("&");
result.push('&');
let ref_hi = context.snippet_provider.span_after(self.span(), "&");
let mut cmnt_lo = ref_hi;
@ -685,7 +685,7 @@ impl Rewrite for ast::Ty {
} else {
result.push_str(&lt_str);
}
result.push_str(" ");
result.push(' ');
cmnt_lo = lifetime.ident.span.hi();
}
@ -1048,11 +1048,7 @@ fn join_bounds_inner(
true,
)
.map(|v| (v, trailing_span, extendable)),
_ => Some((
String::from(strs) + &trailing_str,
trailing_span,
extendable,
)),
_ => Some((strs + &trailing_str, trailing_span, extendable)),
}
},
)?;
@ -1089,10 +1085,7 @@ fn rewrite_lifetime_param(
) -> Option<String> {
let result = generic_params
.iter()
.filter(|p| match p.kind {
ast::GenericParamKind::Lifetime => true,
_ => false,
})
.filter(|p| matches!(p.kind, ast::GenericParamKind::Lifetime))
.map(|lt| lt.rewrite(context, shape))
.collect::<Option<Vec<_>>>()?
.join(", ");

5
src/utils.rs
View File

@ -191,7 +191,7 @@ pub(crate) fn outer_attributes(attrs: &[ast::Attribute]) -> Vec<ast::Attribute>
#[inline]
pub(crate) fn is_single_line(s: &str) -> bool {
s.chars().find(|&c| c == '\n').is_none()
!s.chars().any(|c| c == '\n')
}
#[inline]
@ -260,8 +260,7 @@ fn is_skip(meta_item: &MetaItem) -> bool {
match meta_item.kind {
MetaItemKind::Word => {
let path_str = pprust::path_to_string(&meta_item.path);
path_str == &*skip_annotation().as_str()
|| path_str == &*depr_skip_annotation().as_str()
path_str == *skip_annotation().as_str() || path_str == *depr_skip_annotation().as_str()
}
MetaItemKind::List(ref l) => {
meta_item.has_name(sym::cfg_attr) && l.len() == 2 && is_skip_nested(&l[1])

18
src/visitor.rs
View File

@ -198,7 +198,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
let missing_span = self.next_span(hi);
let snippet = self.snippet(missing_span);
let len = CommentCodeSlices::new(snippet)
.nth(0)
.next()
.and_then(|(kind, _, s)| {
if kind == CodeCharKind::Normal {
s.rfind('\n')
@ -293,7 +293,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
}
let span_in_between = mk_sp(last_hi, span.lo() + BytePos::from_usize(offset));
let snippet_in_between = self.snippet(span_in_between);
let mut comment_on_same_line = !snippet_in_between.contains("\n");
let mut comment_on_same_line = !snippet_in_between.contains('\n');
let mut comment_shape =
Shape::indented(self.block_indent, config).comment(config);
@ -301,7 +301,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
self.push_str(" ");
// put the first line of the comment on the same line as the
// block's last line
match sub_slice.find("\n") {
match sub_slice.find('\n') {
None => {
self.push_str(&sub_slice);
}
@ -764,7 +764,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
let hi = self.snippet_provider.span_before(search_span, ";");
let target_span = mk_sp(mac.span().lo(), hi + BytePos(1));
let rewrite = rewrite.map(|rw| {
if !rw.ends_with(";") {
if !rw.ends_with(';') {
format!("{};", rw)
} else {
rw
@ -921,7 +921,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
!is_skip_attr(segments)
}
fn walk_mod_items(&mut self, items: &Vec<rustc_ast::ptr::P<ast::Item>>) {
fn walk_mod_items(&mut self, items: &[rustc_ast::ptr::P<ast::Item>]) {
self.visit_items_with_reordering(&ptr_vec_to_ref_vec(&items));
}
@ -953,10 +953,10 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
// break the Stability Guarantee
// N.B. This could be updated to utilize the version gates.
let include_next_empty = if stmts.len() > 1 {
match (&stmts[0].as_ast_node().kind, &stmts[1].as_ast_node().kind) {
(ast::StmtKind::Item(_), ast::StmtKind::Empty) => true,
_ => false,
}
matches!(
(&stmts[0].as_ast_node().kind, &stmts[1].as_ast_node().kind),
(ast::StmtKind::Item(_), ast::StmtKind::Empty)
)
} else {
false
};

8
tests/source/configs/match_arm_leading_pipes/preserve.rs
View File

@ -26,3 +26,11 @@ fn bar() {
_ => {}
}
}
fn f(x: NonAscii) -> bool {
match x {
// foo
| Éfgh => true,
_ => false,
}
}

8
tests/target/configs/match_arm_leading_pipes/preserve.rs
View File

@ -25,3 +25,11 @@ fn bar() {
_ => {}
}
}
fn f(x: NonAscii) -> bool {
match x {
// foo
| Éfgh => true,
_ => false,
}
}

17
tests/target/issue_4868.rs Normal file
View File

@ -0,0 +1,17 @@
enum NonAscii {
Abcd,
Éfgh,
}
use NonAscii::*;
fn f(x: NonAscii) -> bool {
match x {
Éfgh => true,
_ => false,
}
}
fn main() {
dbg!(f(Abcd));
}