cargo fmt

BenjaminBrienen · BenjaminBrienen · commit 42bc2b56691d · 2025-03-31T00:17:39.000+02:00
diff --git a/src/closures.rs b/src/closures.rs
@@ -124,9 +124,10 @@ fn needs_block(
     prefix: &str,
     context: &RewriteContext<'_>,
 ) -> bool {
-    let has_attributes = block.stmts.first().is_some_and(|first_stmt| {
-        !get_attrs_from_stmt(first_stmt).is_empty()
-    });
+    let has_attributes = block
+        .stmts
+        .first()
+        .is_some_and(|first_stmt| !get_attrs_from_stmt(first_stmt).is_empty());
 
     is_unsafe_block(block)
         || block.stmts.len() > 1
@@ -434,9 +435,8 @@ pub(crate) fn rewrite_last_closure(
 
         // When overflowing the closure which consists of a single control flow expression,
         // force to use block if its condition uses multi line.
-        let is_multi_lined_cond = rewrite_cond(context, body, body_shape).is_some_and(|cond| {
-            cond.contains('\n') || cond.len() > body_shape.width
-        });
+        let is_multi_lined_cond = rewrite_cond(context, body, body_shape)
+            .is_some_and(|cond| cond.contains('\n') || cond.len() > body_shape.width);
         if is_multi_lined_cond {
             return rewrite_closure_with_block(body, &prefix, context, body_shape);
         }
diff --git a/src/config/mod.rs b/src/config/mod.rs
@@ -1389,8 +1389,7 @@ make_backup = false
             for minor in current_version.minor..0 {
                 let toml = format!(
                     "required_version=\"^{}.{}.0\"",
-                    current_version.major,
-                    minor
+                    current_version.major, minor
                 );
                 let config = Config::from_toml(&toml, Path::new("./rustfmt.toml")).unwrap();
 
@@ -1443,10 +1442,7 @@ make_backup = false
         #[nightly_only_test]
         #[test]
         fn test_required_version_pre_release() {
-            let toml = format!(
-                "required_version=\"^{}-alpha\"",
-                get_current_version()
-            );
+            let toml = format!("required_version=\"^{}-alpha\"", get_current_version());
             let config = Config::from_toml(&toml, Path::new("./rustfmt.toml")).unwrap();
 
             assert!(config.version_meets_requirement());
@@ -1455,10 +1451,7 @@ make_backup = false
         #[nightly_only_test]
         #[test]
         fn test_required_version_with_build_metadata() {
-            let toml = format!(
-                "required_version=\"{}+build.1\"",
-                get_current_version()
-            );
+            let toml = format!("required_version=\"{}+build.1\"", get_current_version());
 
             let config = Config::from_toml(&toml, Path::new("./rustfmt.toml")).unwrap();
 
diff --git a/src/config/options.rs b/src/config/options.rs
@@ -327,7 +327,6 @@ impl ::std::str::FromStr for WidthHeuristics {
     }
 }
 
-
 /// A set of directories, files and modules that rustfmt should ignore.
 #[derive(Default, Clone, Debug, PartialEq)]
 pub struct IgnoreList {
@@ -459,7 +458,6 @@ pub enum Edition {
     Edition2024,
 }
 
-
 impl From<Edition> for rustc_span::edition::Edition {
     fn from(edition: Edition) -> Self {
         match edition {
diff --git a/src/expr.rs b/src/expr.rs
@@ -300,9 +300,7 @@ pub(crate) fn format_expr(
             shape,
             SeparatorPlace::Front,
         ),
-        ast::ExprKind::Index(ref expr, ref index, _) => {
-            rewrite_index(expr, index, context, shape)
-        }
+        ast::ExprKind::Index(ref expr, ref index, _) => rewrite_index(expr, index, context, shape),
         ast::ExprKind::Repeat(ref expr, ref repeats) => rewrite_pair(
             &**expr,
             &*repeats.value,
@@ -1765,13 +1763,14 @@ fn rewrite_struct_lit(
         )
         .unknown_error()?
     } else {
-        let field_iter = fields.iter().map(StructLitField::Regular).chain(
-            match struct_rest {
+        let field_iter = fields
+            .iter()
+            .map(StructLitField::Regular)
+            .chain(match struct_rest {
                 ast::StructRest::Base(expr) => Some(StructLitField::Base(expr)),
                 ast::StructRest::Rest(span) => Some(StructLitField::Rest(*span)),
                 ast::StructRest::None => None,
-            },
-        );
+            });
 
         let span_lo = |item: &StructLitField<'_>| match *item {
             StructLitField::Regular(field) => field.span().lo(),
diff --git a/src/imports.rs b/src/imports.rs
@@ -1034,9 +1034,10 @@ fn rewrite_nested_use_tree(
         }
     }
     let has_nested_list = use_tree_list.iter().any(|use_segment| {
-        use_segment.path.last().is_some_and(|last_segment| {
-            matches!(last_segment.kind, UseSegmentKind::List(..))
-        })
+        use_segment
+            .path
+            .last()
+            .is_some_and(|last_segment| matches!(last_segment.kind, UseSegmentKind::List(..)))
     });
 
     let remaining_width = if has_nested_list {
diff --git a/src/items.rs b/src/items.rs
@@ -235,7 +235,8 @@ fn same_line_else_kw_and_brace(
         .lines()
         .last()
         .expect("initializer expression is multi-lined")
-        .strip_prefix(indent.as_ref()).is_some_and(|l| !l.starts_with(char::is_whitespace))
+        .strip_prefix(indent.as_ref())
+        .is_some_and(|l| !l.starts_with(char::is_whitespace))
 }
 
 fn allow_single_line_let_else_block(result: &str, block: &ast::Block) -> bool {
@@ -767,7 +768,8 @@ impl FmtVisitor<'_> {
                 // Make sure that there are at least a single empty line between
                 // different impl items.
                 if prev_kind
-                    .as_ref().is_some_and(|prev_kind| need_empty_line(prev_kind, &item.kind))
+                    .as_ref()
+                    .is_some_and(|prev_kind| need_empty_line(prev_kind, &item.kind))
                 {
                     self.push_str("\n");
                 }
@@ -2483,7 +2485,8 @@ fn rewrite_fn_base(
 
     let snuggle_angle_bracket = generics_str
         .lines()
-        .last().is_some_and(|l| l.trim_start().len() == 1);
+        .last()
+        .is_some_and(|l| l.trim_start().len() == 1);
 
     // Note that the width and indent don't really matter, we'll re-layout the
     // return type later anyway.
@@ -2568,7 +2571,8 @@ fn rewrite_fn_base(
         // on the same line.
         params_last_line_contains_comment = param_str
             .lines()
-            .last().is_some_and(|last_line| last_line.contains("//"));
+            .last()
+            .is_some_and(|last_line| last_line.contains("//"));
 
         if context.config.style_edition() >= StyleEdition::Edition2027 {
             if closing_paren_overflow_max_width {
@@ -2676,9 +2680,11 @@ fn rewrite_fn_base(
             let snippet = context.snippet(mk_sp(snippet_lo, snippet_hi));
             // Try to preserve the layout of the original snippet.
             let original_starts_with_newline = snippet
-                .find(|c| c != ' ').is_some_and(|i| starts_with_newline(&snippet[i..]));
+                .find(|c| c != ' ')
+                .is_some_and(|i| starts_with_newline(&snippet[i..]));
             let original_ends_with_newline = snippet
-                .rfind(|c| c != ' ').is_some_and(|i| snippet[i..].ends_with('\n'));
+                .rfind(|c| c != ' ')
+                .is_some_and(|i| snippet[i..].ends_with('\n'));
             let snippet = snippet.trim();
             if !snippet.is_empty() {
                 result.push(if original_starts_with_newline {
@@ -3381,7 +3387,8 @@ fn format_generics(
     };
     // add missing comments
     let missed_line_comments = missed_comments
-        .filter(|missed_comments| !missed_comments.is_empty()).is_some_and(|missed_comments| {
+        .filter(|missed_comments| !missed_comments.is_empty())
+        .is_some_and(|missed_comments| {
             let is_block = is_last_comment_block(&missed_comments);
             let sep = if is_block { " " } else { "\n" };
             result.push_str(sep);
diff --git a/src/lib.rs b/src/lib.rs
@@ -517,9 +517,7 @@ impl<'b, T: Write + 'b> Session<'b, T> {
 
 pub(crate) fn create_emitter<'a>(config: &Config) -> Box<dyn Emitter + 'a> {
     match config.emit_mode() {
-        EmitMode::Files if config.make_backup() => {
-            Box::new(emitter::FilesWithBackupEmitter)
-        }
+        EmitMode::Files if config.make_backup() => Box::new(emitter::FilesWithBackupEmitter),
         EmitMode::Files => Box::new(emitter::FilesEmitter::new(
             config.print_misformatted_file_names(),
         )),
diff --git a/src/lists.rs b/src/lists.rs
@@ -149,27 +149,23 @@ impl ListItem {
     pub(crate) fn is_different_group(&self) -> bool {
         self.inner_as_ref().contains('\n')
             || self.pre_comment.is_some()
-            || self
-                .post_comment
-                .as_ref().is_some_and(|s| s.contains('\n'))
+            || self.post_comment.as_ref().is_some_and(|s| s.contains('\n'))
     }
 
     pub(crate) fn is_multiline(&self) -> bool {
         self.inner_as_ref().contains('\n')
-            || self
-                .pre_comment
-                .as_ref().is_some_and(|s| s.contains('\n'))
-            || self
-                .post_comment
-                .as_ref().is_some_and(|s| s.contains('\n'))
+            || self.pre_comment.as_ref().is_some_and(|s| s.contains('\n'))
+            || self.post_comment.as_ref().is_some_and(|s| s.contains('\n'))
     }
 
     pub(crate) fn has_single_line_comment(&self) -> bool {
         self.pre_comment
-            .as_ref().is_some_and(|comment| comment.trim_start().starts_with("//"))
+            .as_ref()
+            .is_some_and(|comment| comment.trim_start().starts_with("//"))
             || self
                 .post_comment
-                .as_ref().is_some_and(|comment| comment.trim_start().starts_with("//"))
+                .as_ref()
+                .is_some_and(|comment| comment.trim_start().starts_with("//"))
     }
 
     pub(crate) fn has_comment(&self) -> bool {
@@ -720,9 +716,7 @@ pub(crate) fn has_extra_newline(post_snippet: &str, comment_end: usize) -> bool
         .len_utf8();
     // Everything from the separator to the next item.
     let test_snippet = &post_snippet[comment_end - len_last..];
-    let first_newline = test_snippet
-        .find('\n')
-        .unwrap_or(test_snippet.len());
+    let first_newline = test_snippet.find('\n').unwrap_or(test_snippet.len());
     // From the end of the first line of comments.
     let test_snippet = &test_snippet[first_newline..];
     let first = test_snippet
diff --git a/src/matches.rs b/src/matches.rs
@@ -370,7 +370,8 @@ fn flatten_arm_body<'a>(
                 }
             } else {
                 let cond_becomes_multi_line = opt_shape
-                    .and_then(|shape| rewrite_cond(context, expr, shape)).is_some_and(|cond| cond.contains('\n'));
+                    .and_then(|shape| rewrite_cond(context, expr, shape))
+                    .is_some_and(|cond| cond.contains('\n'));
                 if cond_becomes_multi_line {
                     (false, body)
                 } else {
diff --git a/src/overflow.rs b/src/overflow.rs
@@ -445,7 +445,8 @@ impl<'a> Context<'a> {
                     | ast::ExprKind::Loop(..)
                     | ast::ExprKind::While(..)
                     | ast::ExprKind::Match(..) => {
-                        let multi_line = rewrite_cond(self.context, expr, shape).is_some_and(|cond| cond.contains('\n'));
+                        let multi_line = rewrite_cond(self.context, expr, shape)
+                            .is_some_and(|cond| cond.contains('\n'));
 
                         if multi_line {
                             None
@@ -738,13 +739,15 @@ impl<'a> Context<'a> {
 
 fn need_block_indent(s: &str, shape: Shape) -> bool {
     s.lines().skip(1).any(|s| {
-        s.find(|c| !char::is_whitespace(c)).is_some_and(|w| w + 1 < shape.indent.width())
+        s.find(|c| !char::is_whitespace(c))
+            .is_some_and(|w| w + 1 < shape.indent.width())
     })
 }
 
 fn can_be_overflowed(context: &RewriteContext<'_>, items: &[OverflowableItem<'_>]) -> bool {
     items
-        .last().is_some_and(|x| x.can_be_overflowed(context, items.len()))
+        .last()
+        .is_some_and(|x| x.can_be_overflowed(context, items.len()))
 }
 
 /// Returns a shape for the last argument which is going to be overflowed.
@@ -804,7 +807,8 @@ pub(crate) fn maybe_get_args_offset(
     args: &[OverflowableItem<'_>],
     config: &Config,
 ) -> Option<(bool, usize)> {
-    if let Some(&(_, num_args_before)) = args.first()?
+    if let Some(&(_, num_args_before)) = args
+        .first()?
         .special_cases(config)
         .find(|&&(s, _)| s == callee_str)
     {
diff --git a/src/reorder.rs b/src/reorder.rs
@@ -148,10 +148,7 @@ fn rewrite_reorderable_or_regroupable_items(
                         .map(|use_tree| {
                             let item = use_tree.rewrite_top_level(context, nested_shape);
                             if let Some(list_item) = use_tree.list_item {
-                                ListItem {
-                                    item,
-                                    ..list_item
-                                }
+                                ListItem { item, ..list_item }
                             } else {
                                 ListItem::from_item(item)
                             }
diff --git a/src/rewrite.rs b/src/rewrite.rs
@@ -93,10 +93,7 @@ impl<T> RewriteErrorExt<T> for Option<T> {
     }
 
     fn macro_error(self, kind: MacroErrorKind, span: Span) -> Result<T, RewriteError> {
-        self.ok_or(RewriteError::MacroFailure {
-            kind,
-            span,
-        })
+        self.ok_or(RewriteError::MacroFailure { kind, span })
     }
 
     fn unknown_error(self) -> Result<T, RewriteError> {
diff --git a/src/sort.rs b/src/sort.rs
@@ -50,10 +50,7 @@ impl<'a> VersionChunkIter<'a> {
         })
     }
 
-    fn parse_str_chunk(
-        &mut self,
-        chars: std::str::CharIndices<'a>,
-    ) -> Option<VersionChunk<'a>> {
+    fn parse_str_chunk(&mut self, chars: std::str::CharIndices<'a>) -> Option<VersionChunk<'a>> {
         let mut end = self.start;
         let mut is_end_of_chunk = false;
 
diff --git a/src/test/mod.rs b/src/test/mod.rs
@@ -105,8 +105,8 @@ fn is_file_skip(path: &Path) -> bool {
 fn get_test_files(path: &Path, recursive: bool) -> Vec<PathBuf> {
     let mut files = vec![];
     if path.is_dir() {
-        for entry in
-            fs::read_dir(path).unwrap_or_else(|_| panic!("couldn't read directory {}", path.display()))
+        for entry in fs::read_dir(path)
+            .unwrap_or_else(|_| panic!("couldn't read directory {}", path.display()))
         {
             let entry = entry.expect("couldn't get `DirEntry`");
             let path = entry.path();
@@ -121,7 +121,9 @@ fn get_test_files(path: &Path, recursive: bool) -> Vec<PathBuf> {
 }
 
 fn verify_config_used(path: &Path, config_name: &str) {
-    for entry in fs::read_dir(path).unwrap_or_else(|_| panic!("couldn't read {} directory", path.display())) {
+    for entry in
+        fs::read_dir(path).unwrap_or_else(|_| panic!("couldn't read {} directory", path.display()))
+    {
         let entry = entry.expect("couldn't get directory entry");
         let path = entry.path();
         if path.extension().is_some_and(|f| f == "rs") {
@@ -762,15 +764,16 @@ fn get_editions_from_comments(
     comments: &HashMap<String, String>,
 ) -> (Option<Edition>, Option<StyleEdition>, Option<Version>) {
     (
-        comments
-            .get("edition")
-            .map(|e| Edition::from_str(e).unwrap_or_else(|_| panic!("invalid edition value: '{}'", e))),
+        comments.get("edition").map(|e| {
+            Edition::from_str(e).unwrap_or_else(|_| panic!("invalid edition value: '{}'", e))
+        }),
         comments.get("style_edition").map(|se| {
-            StyleEdition::from_str(se).unwrap_or_else(|_| panic!("invalid style_edition value: '{}'", se))
+            StyleEdition::from_str(se)
+                .unwrap_or_else(|_| panic!("invalid style_edition value: '{}'", se))
+        }),
+        comments.get("version").map(|v| {
+            Version::from_str(v).unwrap_or_else(|_| panic!("invalid version value: '{}'", v))
         }),
-        comments
-            .get("version")
-            .map(|v| Version::from_str(v).unwrap_or_else(|_| panic!("invalid version value: '{}'", v))),
     )
 }
 
diff --git a/src/utils.rs b/src/utils.rs
@@ -266,9 +266,7 @@ fn is_skip_nested(meta_item: &MetaItemInner) -> bool {
 
 #[inline]
 pub(crate) fn contains_skip(attrs: &[Attribute]) -> bool {
-    attrs
-        .iter()
-        .any(|a| a.meta().is_some_and(|a| is_skip(&a)))
+    attrs.iter().any(|a| a.meta().is_some_and(|a| is_skip(&a)))
 }
 
 #[inline]
diff --git a/src/visitor.rs b/src/visitor.rs
@@ -120,7 +120,8 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
             // snippet preceding the semicolon is picked up.
             let snippet = self.snippet(mk_sp(self.last_pos, stmt.span().lo()));
             let original_starts_with_newline = snippet
-                .find(|c| c != ' ').is_some_and(|i| starts_with_newline(&snippet[i..]));
+                .find(|c| c != ' ')
+                .is_some_and(|i| starts_with_newline(&snippet[i..]));
             let snippet = snippet.trim();
             if !snippet.is_empty() {
                 // FIXME(calebcartwright 2021-01-03) - This exists strictly to maintain legacy

Original file line number	Diff line number	Diff line change
`@@ -327,7 +327,6 @@ impl ::std::str::FromStr for WidthHeuristics {`
`327`	`327`	`}`
`328`	`328`	`}`
`329`	`329`
`330`		`-`
`331`	`330`	`/// A set of directories, files and modules that rustfmt should ignore.`
`332`	`331`	`#[derive(Default, Clone, Debug, PartialEq)]`
`333`	`332`	`pub struct IgnoreList {`
`@@ -459,7 +458,6 @@ pub enum Edition {`
`459`	`458`	`Edition2024,`
`460`	`459`	`}`
`461`	`460`
`462`		`-`
`463`	`461`	`impl From<Edition> for rustc_span::edition::Edition {`
`464`	`462`	`fn from(edition: Edition) -> Self {`
`465`	`463`	`match edition {`
Original file line number	Diff line number	Diff line change
`@@ -1034,9 +1034,10 @@ fn rewrite_nested_use_tree(`
`1034`	`1034`	`}`
`1035`	`1035`	`}`
`1036`	`1036`	`let has_nested_list = use_tree_list.iter().any(\|use_segment\| {`
`1037`		`- use_segment.path.last().is_some_and(\|last_segment\| {`
`1038`		`- matches!(last_segment.kind, UseSegmentKind::List(..))`
`1039`		`- })`
	`1037`	`+ use_segment`
	`1038`	`+ .path`
	`1039`	`+ .last()`
	`1040`	`+ .is_some_and(\|last_segment\| matches!(last_segment.kind, UseSegmentKind::List(..)))`
`1040`	`1041`	`});`
`1041`	`1042`
`1042`	`1043`	`let remaining_width = if has_nested_list {`