Merge branch 'master' into subtree-push-nightly-2025-10-07

Author: shulaoda

CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [Unreleased]
+
+
+## [1.9.0] 2025-01-03
+
+### Fixed
+- No longer strip `r#` prefix from `break` and `continue` labels [#6411](https://github.com/rust-lang/rustfmt/issues/6411)
+  ```rust
+  fn main() {
+      'r#if: {
+          break 'r#if;
+      }
+  }
+  ```
+- Fix panic when sorting imports [#6333](https://github.com/rust-lang/rustfmt/issues/6333)
+- Fix issue with `wrap_comments` invalidating code blocks [#6417](https://github.com/rust-lang/rustfmt/pull/6417)
+- No longer remove closure block label within a macro call [#6465](https://github.com/rust-lang/rustfmt/issues/6465)
+
+### Changed
+- Stabilize `style_edition=2024` and stabilize the `style_edition` command line option [#6431](https://github.com/rust-lang/rustfmt/pull/6431) [rust-lang/rust#134929](https://github.com/rust-lang/rust/pull/134929)
+- Apply version sorting to module declarations when using `style_edition=2024` [#6368](https://github.com/rust-lang/rustfmt/pull/6368)
+- When users set the deprecated `version` config, rustfmt now gives a hint about which equivalent `style_edition` they should use [#6361](https://github.com/rust-lang/rustfmt/pull/6361)
+- Correct version chunk splitting in the internal version sort algorithm [#6407](https://github.com/rust-lang/rustfmt/pull/6407)
+- Extend support for single line let-chain formatting to include cases where the left hand side operand is a literal, in alignment with finalized style rules as part of let-chain stabilization [#6492](https://github.com/rust-lang/rustfmt/pull/6492)
+- Begin initial formatting for `use closures` and `use chains` (`#![feature(ergonomic_clones)]`). Previously, the closure and chain was left as the developer wrote it [#6532](https://github.com/rust-lang/rustfmt/pull/6532)
+
+### Added
+- Add `style_edition=2027` to gate unstable formatting [#6324](https://github.com/rust-lang/rustfmt/pull/6324)
+- Support discovering and formatting files via external mods imported within `cfg_match`, similar to `cfg_if` behavior [#6522](https://github.com/rust-lang/rustfmt/pull/6522)
+- Add new nightly-only `match_arm_indent` option [#6525](https://github.com/rust-lang/rustfmt/pull/6525)
+  - more details in the [configuration section for this new option](https://github.com/rust-lang/rustfmt/blob/master/Configurations.md#match_arm_indent)
+
+
 ## [1.8.0] 2024-09-20
 
 ### Fixed

Configurations.md

@@ -1862,6 +1862,42 @@ fn foo() {
 }
 ```
 
+## `match_arm_indent`
+
+Controls whether match arms are indented.  If disabled, match arms will be formatted at the same indentation level as the outer `match` statement.  Meaning that match blocks will only be indented once, not twice.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: [#6533](https://github.com/rust-lang/rustfmt/issues/6533))
+
+#### `true` (default):
+
+```rust
+fn main() {
+    match value {
+        Enum::A => {
+            let mut work = first();
+            work += second();
+        }
+        Enum::B => short_work(),
+    }
+}
+```
+
+#### `false`:
+
+```rust
+fn main() {
+    match value {
+    Enum::A => {
+        let mut work = first();
+        work += second();
+    }
+    Enum::B => short_work(),
+    }
+}
+```
+
 ## `match_block_trailing_comma`
 
 Put a trailing comma after a block based match arm (non-block arms are not affected)
@@ -2209,7 +2245,7 @@ fn example() {
 
 Remove nested parens.
 
-- **Default value**: `true`,
+- **Default value**: `true`
 - **Possible values**: `true`, `false`
 - **Stable**: Yes
 
@@ -3010,6 +3046,7 @@ fn main() {
     let y = 2;
     let z = 3;
     let a = Foo { x, y, z };
+    let b = Foo { x, y, z };
 }
 ```
 

README.md

@@ -172,8 +172,7 @@ See [GitHub page](https://rust-lang.github.io/rustfmt/) for details.
 
 The `edition` option determines the Rust language edition used for parsing the code. This is important for syntax compatibility but does not directly control formatting behavior (see [Style Editions](#style-editions)).
 
-When running `cargo fmt`, the `edition` is automatically read from the `Cargo.toml` file. However, when running `rustfmt` directly the `edition` defaults to 2015 if not explicitly configured. For consistent parsing between rustfmt and `cargo fmt` you should configure the `edition`.
-For example in your `rustfmt.toml` file:
+When running `cargo fmt`, the `edition` is automatically read from the `Cargo.toml` file. However, when running `rustfmt` directly, the `edition` defaults to 2015. For consistent parsing between rustfmt and `cargo fmt`, you should configure the `edition` in your `rustfmt.toml` file:
 
 ```toml
 edition = "2018"

src/cargo-fmt/main.rs

@@ -6,7 +6,6 @@
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, BTreeSet};
 use std::env;
-use std::ffi::OsStr;
 use std::fs;
 use std::hash::{Hash, Hasher};
 use std::io::{self, Write};
@@ -151,11 +150,13 @@ fn execute() -> i32 {
 }
 
 fn rustfmt_command() -> Command {
-    let rustfmt_var = env::var_os("RUSTFMT");
-    let rustfmt = match &rustfmt_var {
-        Some(rustfmt) => rustfmt,
-        None => OsStr::new("rustfmt"),
+    let rustfmt = match env::var_os("RUSTFMT") {
+        Some(rustfmt) => PathBuf::from(rustfmt),
+        None => env::current_exe()
+            .expect("current executable path invalid")
+            .with_file_name("rustfmt"),
     };
+
     Command::new(rustfmt)
 }
 

src/chains.rs

@@ -195,6 +195,7 @@ enum ChainItemKind {
     StructField(symbol::Ident),
     TupleField(symbol::Ident, bool),
     Await,
+    Use,
     Yield,
     Comment(String, CommentPosition),
 }
@@ -207,6 +208,7 @@ impl ChainItemKind {
             | ChainItemKind::StructField(..)
             | ChainItemKind::TupleField(..)
             | ChainItemKind::Await
+            | ChainItemKind::Use
             | ChainItemKind::Yield
             | ChainItemKind::Comment(..) => false,
         }
@@ -262,6 +264,10 @@ impl ChainItemKind {
                 let span = mk_sp(nested.span.hi(), expr.span.hi());
                 (ChainItemKind::Await, span)
             }
+            ast::ExprKind::Use(ref nested, _) => {
+                let span = mk_sp(nested.span.hi(), expr.span.hi());
+                (ChainItemKind::Use, span)
+            }
             ast::ExprKind::Yield(ast::YieldKind::Postfix(ref nested)) => {
                 let span = mk_sp(nested.span.hi(), expr.span.hi());
                 (ChainItemKind::Yield, span)
@@ -313,6 +319,7 @@ impl Rewrite for ChainItem {
                 rewrite_ident(context, ident)
             ),
             ChainItemKind::Await => ".await".to_owned(),
+            ChainItemKind::Use => ".use".to_owned(),
             ChainItemKind::Yield => ".yield".to_owned(),
             ChainItemKind::Comment(ref comment, _) => {
                 rewrite_comment(comment, false, shape, context.config)?
@@ -517,6 +524,7 @@ impl Chain {
             ast::ExprKind::Field(ref subexpr, _)
             | ast::ExprKind::Try(ref subexpr)
             | ast::ExprKind::Await(ref subexpr, _)
+            | ast::ExprKind::Use(ref subexpr, _)
             | ast::ExprKind::Yield(ast::YieldKind::Postfix(ref subexpr)) => Some(SubExpr {
                 expr: Self::convert_try(subexpr, context),
                 is_method_call_receiver: false,

src/closures.rs

@@ -294,14 +294,14 @@ fn rewrite_closure_fn_decl(
         Some(ast::CoroutineKind::AsyncGen { .. }) => "async gen ",
         None => "",
     };
-    let mover = if matches!(capture, ast::CaptureBy::Value { .. }) {
-        "move "
-    } else {
-        ""
+    let capture_str = match capture {
+        ast::CaptureBy::Value { .. } => "move ",
+        ast::CaptureBy::Use { .. } => "use ",
+        ast::CaptureBy::Ref => "",
     };
     // 4 = "|| {".len(), which is overconservative when the closure consists of
     // a single expression.
-    let offset = binder.len() + const_.len() + immovable.len() + coro.len() + mover.len();
+    let offset = binder.len() + const_.len() + immovable.len() + coro.len() + capture_str.len();
     let nested_shape = shape.shrink_left(offset, span)?.sub_width(4, span)?;
 
     // 1 = |
@@ -339,7 +339,7 @@ fn rewrite_closure_fn_decl(
         .tactic(tactic)
         .preserve_newline(true);
     let list_str = write_list(&item_vec, &fmt)?;
-    let mut prefix = format!("{binder}{const_}{immovable}{coro}{mover}|{list_str}|");
+    let mut prefix = format!("{binder}{const_}{immovable}{coro}{capture_str}|{list_str}|");
 
     if !ret_str.is_empty() {
         if prefix.contains('\n') {

src/config/mod.rs

@@ -131,6 +131,8 @@ create_config! {
         on the same line with the pattern of arms";
     match_arm_leading_pipes: MatchArmLeadingPipeConfig, true,
         "Determines whether leading pipes are emitted on match arms";
+    match_arm_indent: MatchArmIndent, false,
+        "Determines whether match arms are indented";
     force_multiline_blocks: ForceMultilineBlocks, false,
         "Force multiline closure bodies and match arms to be wrapped in a block";
     fn_args_layout: FnArgsLayout, true,
@@ -802,6 +804,7 @@ struct_field_align_threshold = 0
 enum_discrim_align_threshold = 0
 match_arm_blocks = true
 match_arm_leading_pipes = "Never"
+match_arm_indent = true
 force_multiline_blocks = false
 fn_params_layout = "Tall"
 brace_style = "SameLineWhere"
@@ -893,6 +896,7 @@ struct_field_align_threshold = 0
 enum_discrim_align_threshold = 0
 match_arm_blocks = true
 match_arm_leading_pipes = "Never"
+match_arm_indent = true
 force_multiline_blocks = false
 fn_params_layout = "Tall"
 brace_style = "SameLineWhere"

src/config/options.rs

@@ -665,6 +665,7 @@ config_option_with_style_edition_default!(
     EnumDiscrimAlignThreshold, usize, _ => 0;
     MatchArmBlocks, bool, _ => true;
     MatchArmLeadingPipeConfig, MatchArmLeadingPipe, _ => MatchArmLeadingPipe::Never;
+    MatchArmIndent, bool, _ => true;
     ForceMultilineBlocks, bool, _ => false;
     FnArgsLayout, Density, _ => Density::Tall;
     FnParamsLayout, Density, _ => Density::Tall;

src/expr.rs

@@ -161,10 +161,6 @@ pub(crate) fn format_expr(
         ast::ExprKind::Tup(ref items) => {
             rewrite_tuple(context, items.iter(), expr.span, shape, items.len() == 1)
         }
-        ast::ExprKind::Use(_, _) => {
-            // FIXME: properly implement this
-            Ok(context.snippet(expr.span()).to_owned())
-        }
         ast::ExprKind::Let(ref pat, ref expr, _span, _) => rewrite_let(context, shape, pat, expr),
         ast::ExprKind::If(..)
         | ast::ExprKind::ForLoop { .. }
@@ -276,6 +272,7 @@ pub(crate) fn format_expr(
         | ast::ExprKind::Field(..)
         | ast::ExprKind::MethodCall(..)
         | ast::ExprKind::Await(_, _)
+        | ast::ExprKind::Use(_, _)
         | ast::ExprKind::Yield(ast::YieldKind::Postfix(_)) => rewrite_chain(expr, context, shape),
         ast::ExprKind::MacCall(ref mac) => {
             rewrite_macro(mac, context, shape, MacroPosition::Expression).or_else(|_| {
@@ -1999,7 +1996,11 @@ fn rewrite_let(
     // TODO(ytmimi) comments could appear between `let` and the `pat`
 
     // 4 = "let ".len()
-    let pat_shape = shape.offset_left(4, pat.span)?;
+    let mut pat_shape = shape.offset_left(4, pat.span)?;
+    if context.config.style_edition() >= StyleEdition::Edition2027 {
+        // 2 for the length of " ="
+        pat_shape = pat_shape.sub_width(2, pat.span)?;
+    }
     let pat_str = pat.rewrite_result(context, pat_shape)?;
     result.push_str(&pat_str);
 

src/imports.rs

@@ -566,8 +566,13 @@ impl UseTree {
 
         // Normalise foo::self -> foo.
         if let UseSegmentKind::Slf(None) = last.kind {
-            if !self.path.is_empty() {
-                return self;
+            if let Some(second_last) = self.path.pop() {
+                if matches!(second_last.kind, UseSegmentKind::Slf(_)) {
+                    self.path.push(second_last);
+                } else {
+                    self.path.push(second_last);
+                    return self;
+                }
             }
         }