src/tools/rustfmt/Configurations.md

   1 # Configuring Rustfmt
   2
   3 Rustfmt is designed to be very configurable. You can create a TOML file called `rustfmt.toml` or `.rustfmt.toml`, place it in the project or any other parent directory and it will apply the options in that file. If none of these directories contain such a file, both your home directory and a directory called `rustfmt` in your [global config directory](https://docs.rs/dirs/4.0.0/dirs/fn.config_dir.html) (e.g. `.config/rustfmt/`) are checked as well.
   4
   5 A possible content of `rustfmt.toml` or `.rustfmt.toml` might look like this:
   6
   7 ```toml
   8 indent_style = "Block"
   9 reorder_imports = false
  10 ```
  11
  12 Each configuration option is either stable or unstable.
  13 Stable options can always be used, while unstable options are only available on a nightly toolchain and must be opted into.
  14 To enable unstable options, set `unstable_features = true` in `rustfmt.toml` or pass `--unstable-features` to rustfmt.
  15
  16 # Configuration Options
  17
  18 Below you find a detailed visual guide on all the supported configuration options of rustfmt:
  19
  20 ## `array_width`
  21
  22 Maximum width of an array literal before falling back to vertical formatting.
  23
  24 - **Default value**: `60`
  25 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
  26 - **Stable**: Yes
  27
  28 By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `array_width` will take precedence.
  29
  30 See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
  31
  32 ## `attr_fn_like_width`
  33
  34 Maximum width of the args of a function-like attributes before falling back to vertical formatting.
  35
  36 - **Default value**: `70`
  37 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
  38 - **Stable**: Yes
  39
  40 By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `attr_fn_like_width` will take precedence.
  41
  42 See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
  43
  44 ## `binop_separator`
  45
  46 Where to put a binary operator when a binary expression goes multiline.
  47
  48 - **Default value**: `"Front"`
  49 - **Possible values**: `"Front"`, `"Back"`
  50 - **Stable**: No (tracking issue: [#3368](https://github.com/rust-lang/rustfmt/issues/3368))
  51
  52 #### `"Front"` (default):
  53
  54 ```rust
  55 fn main() {
  56     let or = foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo
  57         || barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar;
  58
  59     let sum = 123456789012345678901234567890
  60         + 123456789012345678901234567890
  61         + 123456789012345678901234567890;
  62
  63     let range = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  64         ..bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
  65 }
  66 ```
  67
  68 #### `"Back"`:
  69
  70 ```rust
  71 fn main() {
  72     let or = foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo ||
  73         barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar;
  74
  75     let sum = 123456789012345678901234567890 +
  76         123456789012345678901234567890 +
  77         123456789012345678901234567890;
  78
  79     let range = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..
  80         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
  81 }
  82 ```
  83
  84 ## `blank_lines_lower_bound`
  85
  86 Minimum number of blank lines which must be put between items. If two items have fewer blank lines between
  87 them, additional blank lines are inserted.
  88
  89 - **Default value**: `0`
  90 - **Possible values**: *unsigned integer*
  91 - **Stable**: No (tracking issue: [#3382](https://github.com/rust-lang/rustfmt/issues/3382))
  92
  93 ### Example
  94 Original Code (rustfmt will not change it with the default value of `0`):
  95
  96 ```rust
  97 #![rustfmt::skip]
  98
  99 fn foo() {
 100     println!("a");
 101 }
 102 fn bar() {
 103     println!("b");
 104     println!("c");
 105 }
 106 ```
 107
 108 #### `1`
 109 ```rust
 110 fn foo() {
 111
 112     println!("a");
 113 }
 114
 115 fn bar() {
 116
 117     println!("b");
 118
 119     println!("c");
 120 }
 121 ```
 122
 123
 124 ## `blank_lines_upper_bound`
 125
 126 Maximum number of blank lines which can be put between items. If more than this number of consecutive empty
 127 lines are found, they are trimmed down to match this integer.
 128
 129 - **Default value**: `1`
 130 - **Possible values**: any non-negative integer
 131 - **Stable**: No (tracking issue: [#3381](https://github.com/rust-lang/rustfmt/issues/3381))
 132
 133 ### Example
 134 Original Code:
 135
 136 ```rust
 137 #![rustfmt::skip]
 138
 139 fn foo() {
 140     println!("a");
 141 }
 142
 143
 144
 145 fn bar() {
 146     println!("b");
 147
 148
 149     println!("c");
 150 }
 151 ```
 152
 153 #### `1` (default):
 154 ```rust
 155 fn foo() {
 156     println!("a");
 157 }
 158
 159 fn bar() {
 160     println!("b");
 161
 162     println!("c");
 163 }
 164 ```
 165
 166 #### `2`:
 167 ```rust
 168 fn foo() {
 169     println!("a");
 170 }
 171
 172
 173 fn bar() {
 174     println!("b");
 175
 176
 177     println!("c");
 178 }
 179 ```
 180
 181 See also: [`blank_lines_lower_bound`](#blank_lines_lower_bound)
 182
 183 ## `brace_style`
 184
 185 Brace style for items
 186
 187 - **Default value**: `"SameLineWhere"`
 188 - **Possible values**: `"AlwaysNextLine"`, `"PreferSameLine"`, `"SameLineWhere"`
 189 - **Stable**: No (tracking issue: [#3376](https://github.com/rust-lang/rustfmt/issues/3376))
 190
 191 ### Functions
 192
 193 #### `"SameLineWhere"` (default):
 194
 195 ```rust
 196 fn lorem() {
 197     // body
 198 }
 199
 200 fn lorem(ipsum: usize) {
 201     // body
 202 }
 203
 204 fn lorem<T>(ipsum: T)
 205 where
 206     T: Add + Sub + Mul + Div,
 207 {
 208     // body
 209 }
 210 ```
 211
 212 #### `"AlwaysNextLine"`:
 213
 214 ```rust
 215 fn lorem()
 216 {
 217     // body
 218 }
 219
 220 fn lorem(ipsum: usize)
 221 {
 222     // body
 223 }
 224
 225 fn lorem<T>(ipsum: T)
 226 where
 227     T: Add + Sub + Mul + Div,
 228 {
 229     // body
 230 }
 231 ```
 232
 233 #### `"PreferSameLine"`:
 234
 235 ```rust
 236 fn lorem() {
 237     // body
 238 }
 239
 240 fn lorem(ipsum: usize) {
 241     // body
 242 }
 243
 244 fn lorem<T>(ipsum: T)
 245 where
 246     T: Add + Sub + Mul + Div, {
 247     // body
 248 }
 249 ```
 250
 251 ### Structs and enums
 252
 253 #### `"SameLineWhere"` (default):
 254
 255 ```rust
 256 struct Lorem {
 257     ipsum: bool,
 258 }
 259
 260 struct Dolor<T>
 261 where
 262     T: Eq,
 263 {
 264     sit: T,
 265 }
 266 ```
 267
 268 #### `"AlwaysNextLine"`:
 269
 270 ```rust
 271 struct Lorem
 272 {
 273     ipsum: bool,
 274 }
 275
 276 struct Dolor<T>
 277 where
 278     T: Eq,
 279 {
 280     sit: T,
 281 }
 282 ```
 283
 284 #### `"PreferSameLine"`:
 285
 286 ```rust
 287 struct Lorem {
 288     ipsum: bool,
 289 }
 290
 291 struct Dolor<T>
 292 where
 293     T: Eq, {
 294     sit: T,
 295 }
 296 ```
 297
 298 ## `chain_width`
 299
 300 Maximum width of a chain to fit on one line.
 301
 302 - **Default value**: `60`
 303 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
 304 - **Stable**: Yes
 305
 306 By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `chain_width` will take precedence.
 307
 308 See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
 309
 310 ## `color`
 311
 312 Whether to use colored output or not.
 313
 314 - **Default value**: `"Auto"`
 315 - **Possible values**: "Auto", "Always", "Never"
 316 - **Stable**: No (tracking issue: [#3385](https://github.com/rust-lang/rustfmt/issues/3385))
 317
 318 ## `combine_control_expr`
 319
 320 Combine control expressions with function calls.
 321
 322 - **Default value**: `true`
 323 - **Possible values**: `true`, `false`
 324 - **Stable**: No (tracking issue: [#3369](https://github.com/rust-lang/rustfmt/issues/3369))
 325
 326 #### `true` (default):
 327
 328 ```rust
 329 fn example() {
 330     // If
 331     foo!(if x {
 332         foo();
 333     } else {
 334         bar();
 335     });
 336
 337     // IfLet
 338     foo!(if let Some(..) = x {
 339         foo();
 340     } else {
 341         bar();
 342     });
 343
 344     // While
 345     foo!(while x {
 346         foo();
 347         bar();
 348     });
 349
 350     // WhileLet
 351     foo!(while let Some(..) = x {
 352         foo();
 353         bar();
 354     });
 355
 356     // ForLoop
 357     foo!(for x in y {
 358         foo();
 359         bar();
 360     });
 361
 362     // Loop
 363     foo!(loop {
 364         foo();
 365         bar();
 366     });
 367 }
 368 ```
 369
 370 #### `false`:
 371
 372 ```rust
 373 fn example() {
 374     // If
 375     foo!(
 376         if x {
 377             foo();
 378         } else {
 379             bar();
 380         }
 381     );
 382
 383     // IfLet
 384     foo!(
 385         if let Some(..) = x {
 386             foo();
 387         } else {
 388             bar();
 389         }
 390     );
 391
 392     // While
 393     foo!(
 394         while x {
 395             foo();
 396             bar();
 397         }
 398     );
 399
 400     // WhileLet
 401     foo!(
 402         while let Some(..) = x {
 403             foo();
 404             bar();
 405         }
 406     );
 407
 408     // ForLoop
 409     foo!(
 410         for x in y {
 411             foo();
 412             bar();
 413         }
 414     );
 415
 416     // Loop
 417     foo!(
 418         loop {
 419             foo();
 420             bar();
 421         }
 422     );
 423 }
 424 ```
 425
 426 ## `comment_width`
 427
 428 Maximum length of comments. No effect unless `wrap_comments = true`.
 429
 430 - **Default value**: `80`
 431 - **Possible values**: any positive integer
 432 - **Stable**: No (tracking issue: [#3349](https://github.com/rust-lang/rustfmt/issues/3349))
 433
 434 **Note:** A value of `0` results in [`wrap_comments`](#wrap_comments) being applied regardless of a line's width.
 435
 436 #### `80` (default; comments shorter than `comment_width`):
 437 ```rust
 438 // Lorem ipsum dolor sit amet, consectetur adipiscing elit.
 439 ```
 440
 441 #### `60` (comments longer than `comment_width`):
 442 ```rust
 443 // Lorem ipsum dolor sit amet,
 444 // consectetur adipiscing elit.
 445 ```
 446
 447 See also [`wrap_comments`](#wrap_comments).
 448
 449 ## `condense_wildcard_suffixes`
 450
 451 Replace strings of _ wildcards by a single .. in tuple patterns
 452
 453 - **Default value**: `false`
 454 - **Possible values**: `true`, `false`
 455 - **Stable**: No (tracking issue: [#3384](https://github.com/rust-lang/rustfmt/issues/3384))
 456
 457 #### `false` (default):
 458
 459 ```rust
 460 fn main() {
 461     let (lorem, ipsum, _, _) = (1, 2, 3, 4);
 462     let (lorem, ipsum, ..) = (1, 2, 3, 4);
 463 }
 464 ```
 465
 466 #### `true`:
 467
 468 ```rust
 469 fn main() {
 470     let (lorem, ipsum, ..) = (1, 2, 3, 4);
 471 }
 472 ```
 473
 474 ## `control_brace_style`
 475
 476 Brace style for control flow constructs
 477
 478 - **Default value**: `"AlwaysSameLine"`
 479 - **Possible values**: `"AlwaysNextLine"`, `"AlwaysSameLine"`, `"ClosingNextLine"`
 480 - **Stable**: No (tracking issue: [#3377](https://github.com/rust-lang/rustfmt/issues/3377))
 481
 482 #### `"AlwaysSameLine"` (default):
 483
 484 ```rust
 485 fn main() {
 486     if lorem {
 487         println!("ipsum!");
 488     } else {
 489         println!("dolor!");
 490     }
 491 }
 492 ```
 493
 494 #### `"AlwaysNextLine"`:
 495
 496 ```rust
 497 fn main() {
 498     if lorem
 499     {
 500         println!("ipsum!");
 501     }
 502     else
 503     {
 504         println!("dolor!");
 505     }
 506 }
 507 ```
 508
 509 #### `"ClosingNextLine"`:
 510
 511 ```rust
 512 fn main() {
 513     if lorem {
 514         println!("ipsum!");
 515     }
 516     else {
 517         println!("dolor!");
 518     }
 519 }
 520 ```
 521
 522 ## `disable_all_formatting`
 523
 524 Don't reformat anything.
 525
 526 Note that this option may be soft-deprecated in the future once the [ignore](#ignore) option is stabilized. Nightly toolchain users are encouraged to use [ignore](#ignore) instead when possible.
 527
 528 - **Default value**: `false`
 529 - **Possible values**: `true`, `false`
 530 - **Stable**: Yes
 531
 532 ## `edition`
 533
 534 Specifies which edition is used by the parser.
 535
 536 - **Default value**: `"2015"`
 537 - **Possible values**: `"2015"`, `"2018"`, `"2021"`
 538 - **Stable**: Yes
 539
 540 Rustfmt is able to pick up the edition used by reading the `Cargo.toml` file if executed
 541 through the Cargo's formatting tool `cargo fmt`. Otherwise, the edition needs to be specified
 542 in your config file:
 543
 544 ```toml
 545 edition = "2018"
 546 ```
 547
 548 ## `empty_item_single_line`
 549
 550 Put empty-body functions and impls on a single line
 551
 552 - **Default value**: `true`
 553 - **Possible values**: `true`, `false`
 554 - **Stable**: No (tracking issue: [#3356](https://github.com/rust-lang/rustfmt/issues/3356))
 555
 556 #### `true` (default):
 557
 558 ```rust
 559 fn lorem() {}
 560
 561 impl Lorem {}
 562 ```
 563
 564 #### `false`:
 565
 566 ```rust
 567 fn lorem() {
 568 }
 569
 570 impl Lorem {
 571 }
 572 ```
 573
 574 See also [`brace_style`](#brace_style), [`control_brace_style`](#control_brace_style).
 575
 576
 577 ## `enum_discrim_align_threshold`
 578
 579 The maximum length of enum variant having discriminant, that gets vertically aligned with others.
 580 Variants without discriminants would be ignored for the purpose of alignment.
 581
 582 Note that this is not how much whitespace is inserted, but instead the longest variant name that
 583 doesn't get ignored when aligning.
 584
 585 - **Default value** : 0
 586 - **Possible values**: any positive integer
 587 - **Stable**: No (tracking issue: [#3372](https://github.com/rust-lang/rustfmt/issues/3372))
 588
 589 #### `0` (default):
 590
 591 ```rust
 592 enum Foo {
 593     A = 0,
 594     Bb = 1,
 595     RandomLongVariantGoesHere = 10,
 596     Ccc = 71,
 597 }
 598
 599 enum Bar {
 600     VeryLongVariantNameHereA = 0,
 601     VeryLongVariantNameHereBb = 1,
 602     VeryLongVariantNameHereCcc = 2,
 603 }
 604 ```
 605
 606 #### `20`:
 607
 608 ```rust
 609 enum Foo {
 610     A   = 0,
 611     Bb  = 1,
 612     RandomLongVariantGoesHere = 10,
 613     Ccc = 2,
 614 }
 615
 616 enum Bar {
 617     VeryLongVariantNameHereA = 0,
 618     VeryLongVariantNameHereBb = 1,
 619     VeryLongVariantNameHereCcc = 2,
 620 }
 621 ```
 622
 623
 624 ## `error_on_line_overflow`
 625
 626 Error if Rustfmt is unable to get all lines within `max_width`, except for comments and string
 627 literals. If this happens, then it is a bug in Rustfmt. You might be able to work around the bug by
 628 refactoring your code to avoid long/complex expressions, usually by extracting a local variable or
 629 using a shorter name.
 630
 631 - **Default value**: `false`
 632 - **Possible values**: `true`, `false`
 633 - **Stable**: No (tracking issue: [#3391](https://github.com/rust-lang/rustfmt/issues/3391))
 634
 635 See also [`max_width`](#max_width).
 636
 637 ## `error_on_unformatted`
 638
 639 Error if unable to get comments or string literals within `max_width`, or they are left with
 640 trailing whitespaces.
 641
 642 - **Default value**: `false`
 643 - **Possible values**: `true`, `false`
 644 - **Stable**: No (tracking issue: [#3392](https://github.com/rust-lang/rustfmt/issues/3392))
 645
 646 ## `fn_args_layout`
 647
 648 This option is deprecated and has been renamed to `fn_params_layout` to better communicate that
 649 it affects the layout of parameters in function signatures.
 650
 651 - **Default value**: `"Tall"`
 652 - **Possible values**: `"Compressed"`, `"Tall"`, `"Vertical"`
 653 - **Stable**: Yes
 654
 655 #### `"Tall"` (default):
 656
 657 ```rust
 658 trait Lorem {
 659     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet);
 660
 661     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet) {
 662         // body
 663     }
 664
 665     fn lorem(
 666         ipsum: Ipsum,
 667         dolor: Dolor,
 668         sit: Sit,
 669         amet: Amet,
 670         consectetur: Consectetur,
 671         adipiscing: Adipiscing,
 672         elit: Elit,
 673     );
 674
 675     fn lorem(
 676         ipsum: Ipsum,
 677         dolor: Dolor,
 678         sit: Sit,
 679         amet: Amet,
 680         consectetur: Consectetur,
 681         adipiscing: Adipiscing,
 682         elit: Elit,
 683     ) {
 684         // body
 685     }
 686 }
 687 ```
 688
 689 #### `"Compressed"`:
 690
 691 ```rust
 692 trait Lorem {
 693     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet);
 694
 695     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet) {
 696         // body
 697     }
 698
 699     fn lorem(
 700         ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
 701         adipiscing: Adipiscing, elit: Elit,
 702     );
 703
 704     fn lorem(
 705         ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
 706         adipiscing: Adipiscing, elit: Elit,
 707     ) {
 708         // body
 709     }
 710 }
 711 ```
 712
 713 #### `"Vertical"`:
 714
 715 ```rust
 716 trait Lorem {
 717     fn lorem(
 718         ipsum: Ipsum,
 719         dolor: Dolor,
 720         sit: Sit,
 721         amet: Amet,
 722     );
 723
 724     fn lorem(
 725         ipsum: Ipsum,
 726         dolor: Dolor,
 727         sit: Sit,
 728         amet: Amet,
 729     ) {
 730         // body
 731     }
 732
 733     fn lorem(
 734         ipsum: Ipsum,
 735         dolor: Dolor,
 736         sit: Sit,
 737         amet: Amet,
 738         consectetur: Consectetur,
 739         adipiscing: Adipiscing,
 740         elit: Elit,
 741     );
 742
 743     fn lorem(
 744         ipsum: Ipsum,
 745         dolor: Dolor,
 746         sit: Sit,
 747         amet: Amet,
 748         consectetur: Consectetur,
 749         adipiscing: Adipiscing,
 750         elit: Elit,
 751     ) {
 752         // body
 753     }
 754 }
 755 ```
 756
 757 See also [`fn_params_layout`](#fn_params_layout)
 758
 759 ## `fn_call_width`
 760
 761 Maximum width of the args of a function call before falling back to vertical formatting.
 762
 763 - **Default value**: `60`
 764 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
 765 - **Stable**: Yes
 766
 767 By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `fn_call_width` will take precedence.
 768
 769 See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
 770
 771 ## `fn_params_layout`
 772
 773 Control the layout of parameters in function signatures.
 774
 775 - **Default value**: `"Tall"`
 776 - **Possible values**: `"Compressed"`, `"Tall"`, `"Vertical"`
 777 - **Stable**: Yes
 778
 779 #### `"Tall"` (default):
 780
 781 ```rust
 782 trait Lorem {
 783     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet);
 784
 785     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet) {
 786         // body
 787     }
 788
 789     fn lorem(
 790         ipsum: Ipsum,
 791         dolor: Dolor,
 792         sit: Sit,
 793         amet: Amet,
 794         consectetur: Consectetur,
 795         adipiscing: Adipiscing,
 796         elit: Elit,
 797     );
 798
 799     fn lorem(
 800         ipsum: Ipsum,
 801         dolor: Dolor,
 802         sit: Sit,
 803         amet: Amet,
 804         consectetur: Consectetur,
 805         adipiscing: Adipiscing,
 806         elit: Elit,
 807     ) {
 808         // body
 809     }
 810 }
 811 ```
 812
 813 #### `"Compressed"`:
 814
 815 ```rust
 816 trait Lorem {
 817     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet);
 818
 819     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet) {
 820         // body
 821     }
 822
 823     fn lorem(
 824         ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
 825         adipiscing: Adipiscing, elit: Elit,
 826     );
 827
 828     fn lorem(
 829         ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
 830         adipiscing: Adipiscing, elit: Elit,
 831     ) {
 832         // body
 833     }
 834 }
 835 ```
 836
 837 #### `"Vertical"`:
 838
 839 ```rust
 840 trait Lorem {
 841     fn lorem(
 842         ipsum: Ipsum,
 843         dolor: Dolor,
 844         sit: Sit,
 845         amet: Amet,
 846     );
 847
 848     fn lorem(
 849         ipsum: Ipsum,
 850         dolor: Dolor,
 851         sit: Sit,
 852         amet: Amet,
 853     ) {
 854         // body
 855     }
 856
 857     fn lorem(
 858         ipsum: Ipsum,
 859         dolor: Dolor,
 860         sit: Sit,
 861         amet: Amet,
 862         consectetur: Consectetur,
 863         adipiscing: Adipiscing,
 864         elit: Elit,
 865     );
 866
 867     fn lorem(
 868         ipsum: Ipsum,
 869         dolor: Dolor,
 870         sit: Sit,
 871         amet: Amet,
 872         consectetur: Consectetur,
 873         adipiscing: Adipiscing,
 874         elit: Elit,
 875     ) {
 876         // body
 877     }
 878 }
 879 ```
 880
 881
 882 ## `fn_single_line`
 883
 884 Put single-expression functions on a single line
 885
 886 - **Default value**: `false`
 887 - **Possible values**: `true`, `false`
 888 - **Stable**: No (tracking issue: [#3358](https://github.com/rust-lang/rustfmt/issues/3358))
 889
 890 #### `false` (default):
 891
 892 ```rust
 893 fn lorem() -> usize {
 894     42
 895 }
 896
 897 fn lorem() -> usize {
 898     let ipsum = 42;
 899     ipsum
 900 }
 901 ```
 902
 903 #### `true`:
 904
 905 ```rust
 906 fn lorem() -> usize { 42 }
 907
 908 fn lorem() -> usize {
 909     let ipsum = 42;
 910     ipsum
 911 }
 912 ```
 913
 914 See also [`control_brace_style`](#control_brace_style).
 915
 916
 917 ## `force_explicit_abi`
 918
 919 Always print the abi for extern items
 920
 921 - **Default value**: `true`
 922 - **Possible values**: `true`, `false`
 923 - **Stable**: Yes
 924
 925 **Note:** Non-"C" ABIs are always printed. If `false` then "C" is removed.
 926
 927 #### `true` (default):
 928
 929 ```rust
 930 extern "C" {
 931     pub static lorem: c_int;
 932 }
 933 ```
 934
 935 #### `false`:
 936
 937 ```rust
 938 extern {
 939     pub static lorem: c_int;
 940 }
 941 ```
 942
 943 ## `force_multiline_blocks`
 944
 945 Force multiline closure and match arm bodies to be wrapped in a block
 946
 947 - **Default value**: `false`
 948 - **Possible values**: `false`, `true`
 949 - **Stable**: No (tracking issue: [#3374](https://github.com/rust-lang/rustfmt/issues/3374))
 950
 951 #### `false` (default):
 952
 953 ```rust
 954 fn main() {
 955     result.and_then(|maybe_value| match maybe_value {
 956         None => foo(),
 957         Some(value) => bar(),
 958     });
 959
 960     match lorem {
 961         None => |ipsum| {
 962             println!("Hello World");
 963         },
 964         Some(dolor) => foo(),
 965     }
 966 }
 967 ```
 968
 969 #### `true`:
 970
 971 ```rust
 972 fn main() {
 973     result.and_then(|maybe_value| {
 974         match maybe_value {
 975             None => foo(),
 976             Some(value) => bar(),
 977         }
 978     });
 979
 980     match lorem {
 981         None => {
 982             |ipsum| {
 983                 println!("Hello World");
 984             }
 985         }
 986         Some(dolor) => foo(),
 987     }
 988 }
 989 ```
 990
 991
 992 ## `format_code_in_doc_comments`
 993
 994 Format code snippet included in doc comments.
 995
 996 - **Default value**: `false`
 997 - **Possible values**: `true`, `false`
 998 - **Stable**: No (tracking issue: [#3348](https://github.com/rust-lang/rustfmt/issues/3348))
 999
1000 #### `false` (default):
1001
1002 ```rust
1003 /// Adds one to the number given.
1004 ///
1005 /// # Examples
1006 ///
1007 /// ```rust
1008 /// let five=5;
1009 ///
1010 /// assert_eq!(
1011 ///     6,
1012 ///     add_one(5)
1013 /// );
1014 /// # fn add_one(x: i32) -> i32 {
1015 /// #     x + 1
1016 /// # }
1017 /// ```
1018 fn add_one(x: i32) -> i32 {
1019     x + 1
1020 }
1021 ```
1022
1023 #### `true`
1024
1025 ```rust
1026 /// Adds one to the number given.
1027 ///
1028 /// # Examples
1029 ///
1030 /// ```rust
1031 /// let five = 5;
1032 ///
1033 /// assert_eq!(6, add_one(5));
1034 /// # fn add_one(x: i32) -> i32 {
1035 /// #     x + 1
1036 /// # }
1037 /// ```
1038 fn add_one(x: i32) -> i32 {
1039     x + 1
1040 }
1041 ```
1042
1043 ## `doc_comment_code_block_width`
1044
1045 Max width for code snippets included in doc comments. Only used if [`format_code_in_doc_comments`](#format_code_in_doc_comments) is true.
1046
1047 - **Default value**: `100`
1048 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
1049 - **Stable**: No (tracking issue: [#5359](https://github.com/rust-lang/rustfmt/issues/5359))
1050
1051 ## `format_generated_files`
1052
1053 Format generated files. A file is considered generated
1054 if any of the first five lines contain a `@generated` comment marker.
1055 By default, generated files are reformatted, i. e. `@generated` marker is ignored.
1056 This option is currently ignored for stdin (`@generated` in stdin is ignored.)
1057
1058 - **Default value**: `true`
1059 - **Possible values**: `true`, `false`
1060 - **Stable**: No (tracking issue: [#5080](https://github.com/rust-lang/rustfmt/issues/5080))
1061
1062 ## `format_macro_matchers`
1063
1064 Format the metavariable matching patterns in macros.
1065
1066 - **Default value**: `false`
1067 - **Possible values**: `true`, `false`
1068 - **Stable**: No (tracking issue: [#3354](https://github.com/rust-lang/rustfmt/issues/3354))
1069
1070 #### `false` (default):
1071
1072 ```rust
1073 macro_rules! foo {
1074     ($a: ident : $b: ty) => {
1075         $a(42): $b;
1076     };
1077     ($a: ident $b: ident $c: ident) => {
1078         $a = $b + $c;
1079     };
1080 }
1081 ```
1082
1083 #### `true`:
1084
1085 ```rust
1086 macro_rules! foo {
1087     ($a:ident : $b:ty) => {
1088         $a(42): $b;
1089     };
1090     ($a:ident $b:ident $c:ident) => {
1091         $a = $b + $c;
1092     };
1093 }
1094 ```
1095
1096 See also [`format_macro_bodies`](#format_macro_bodies).
1097
1098
1099 ## `format_macro_bodies`
1100
1101 Format the bodies of macros.
1102
1103 - **Default value**: `true`
1104 - **Possible values**: `true`, `false`
1105 - **Stable**: No (tracking issue: [#3355](https://github.com/rust-lang/rustfmt/issues/3355))
1106
1107 #### `true` (default):
1108
1109 ```rust
1110 macro_rules! foo {
1111     ($a: ident : $b: ty) => {
1112         $a(42): $b;
1113     };
1114     ($a: ident $b: ident $c: ident) => {
1115         $a = $b + $c;
1116     };
1117 }
1118 ```
1119
1120 #### `false`:
1121
1122 ```rust
1123 macro_rules! foo {
1124     ($a: ident : $b: ty) => { $a(42): $b; };
1125     ($a: ident $b: ident $c: ident) => { $a=$b+$c; };
1126 }
1127 ```
1128
1129 See also [`format_macro_matchers`](#format_macro_matchers).
1130
1131 ## `skip_macro_invocations`
1132
1133 Skip formatting the bodies of macro invocations with the following names.
1134
1135 rustfmt will not format any macro invocation for macros with names set in this list.
1136 Including the special value "*" will prevent any macro invocations from being formatted.
1137
1138 Note: This option does not have any impact on how rustfmt formats macro definitions.
1139
1140 - **Default value**: `[]`
1141 - **Possible values**: a list of macro name idents, `["name_0", "name_1", ..., "*"]`
1142 - **Stable**: No (tracking issue: [#5346](https://github.com/rust-lang/rustfmt/issues/5346))
1143
1144 #### `[]` (default):
1145
1146 rustfmt will follow its standard approach to formatting macro invocations.
1147
1148 No macro invocations will be skipped based on their name. More information about rustfmt's standard macro invocation formatting behavior can be found in [#5437](https://github.com/rust-lang/rustfmt/discussions/5437).
1149
1150 ```rust
1151 lorem!(
1152     const _: u8 = 0;
1153 );
1154
1155 ipsum!(
1156     const _: u8 = 0;
1157 );
1158 ```
1159
1160 #### `["lorem"]`:
1161
1162 The named macro invocations will be skipped.
1163
1164 ```rust
1165 lorem!(
1166         const _: u8 = 0;
1167 );
1168
1169 ipsum!(
1170     const _: u8 = 0;
1171 );
1172 ```
1173
1174 #### `["*"]`:
1175
1176 The special selector `*` will skip all macro invocations.
1177
1178 ```rust
1179 lorem!(
1180         const _: u8 = 0;
1181 );
1182
1183 ipsum!(
1184         const _: u8 = 0;
1185 );
1186 ```
1187
1188 ## `format_strings`
1189
1190 Format string literals where necessary
1191
1192 - **Default value**: `false`
1193 - **Possible values**: `true`, `false`
1194 - **Stable**: No (tracking issue: [#3353](https://github.com/rust-lang/rustfmt/issues/3353))
1195
1196 #### `false` (default):
1197
1198 ```rust
1199 fn main() {
1200     let lorem = "ipsum dolor sit amet consectetur adipiscing elit lorem ipsum dolor sit amet consectetur adipiscing";
1201 }
1202 ```
1203
1204 #### `true`:
1205
1206 ```rust
1207 fn main() {
1208     let lorem = "ipsum dolor sit amet consectetur adipiscing elit lorem ipsum dolor sit amet \
1209                  consectetur adipiscing";
1210 }
1211 ```
1212
1213 See also [`max_width`](#max_width).
1214
1215 ## `hard_tabs`
1216
1217 Use tab characters for indentation, spaces for alignment
1218
1219 - **Default value**: `false`
1220 - **Possible values**: `true`, `false`
1221 - **Stable**: Yes
1222
1223 #### `false` (default):
1224
1225 ```rust
1226 fn lorem() -> usize {
1227     42 // spaces before 42
1228 }
1229 ```
1230
1231 #### `true`:
1232
1233 ```rust
1234 fn lorem() -> usize {
1235         42 // tabs before 42
1236 }
1237 ```
1238
1239 See also: [`tab_spaces`](#tab_spaces).
1240
1241 ## `hex_literal_case`
1242
1243 Control the case of the letters in hexadecimal literal values
1244
1245 - **Default value**: `Preserve`
1246 - **Possible values**: `Preserve`, `Upper`, `Lower`
1247 - **Stable**: No (tracking issue: [#5081](https://github.com/rust-lang/rustfmt/issues/5081))
1248
1249 ## `hide_parse_errors`
1250
1251 Do not show parse errors if the parser failed to parse files.
1252
1253 - **Default value**: `false`
1254 - **Possible values**: `true`, `false`
1255 - **Stable**: No (tracking issue: [#3390](https://github.com/rust-lang/rustfmt/issues/3390))
1256
1257 ## `ignore`
1258
1259 Skip formatting files and directories that match the specified pattern.
1260 The pattern format is the same as [.gitignore](https://git-scm.com/docs/gitignore#_pattern_format). Be sure to use Unix/forwardslash `/` style  paths. This path style will work on all platforms. Windows style paths with backslashes `\` are not supported.
1261
1262 - **Default value**: format every file
1263 - **Possible values**: See an example below
1264 - **Stable**: No (tracking issue: [#3395](https://github.com/rust-lang/rustfmt/issues/3395))
1265
1266 ### Example
1267
1268 If you want to ignore specific files, put the following to your config file:
1269
1270 ```toml
1271 ignore = [
1272     "src/types.rs",
1273     "src/foo/bar.rs",
1274 ]
1275 ```
1276
1277 If you want to ignore every file under `examples/`, put the following to your config file:
1278
1279 ```toml
1280 ignore = [
1281     "examples",
1282 ]
1283 ```
1284
1285 If you want to ignore every file under the directory where you put your rustfmt.toml:
1286
1287 ```toml
1288 ignore = ["/"]
1289 ```
1290
1291 ## `imports_indent`
1292
1293 Indent style of imports
1294
1295 - **Default Value**: `"Block"`
1296 - **Possible values**: `"Block"`, `"Visual"`
1297 - **Stable**: No (tracking issue: [#3360](https://github.com/rust-lang/rustfmt/issues/3360))
1298
1299 #### `"Block"` (default):
1300
1301 ```rust
1302 use foo::{
1303     xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,
1304     zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
1305 };
1306 ```
1307
1308 #### `"Visual"`:
1309
1310 ```rust
1311 use foo::{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,
1312           zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz};
1313 ```
1314
1315 See also: [`imports_layout`](#imports_layout).
1316
1317 ## `imports_layout`
1318
1319 Item layout inside a imports block
1320
1321 - **Default value**: "Mixed"
1322 - **Possible values**: "Horizontal", "HorizontalVertical", "Mixed", "Vertical"
1323 - **Stable**: No (tracking issue: [#3361](https://github.com/rust-lang/rustfmt/issues/3361))
1324
1325 #### `"Mixed"` (default):
1326
1327 ```rust
1328 use foo::{xxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzzzz};
1329
1330 use foo::{
1331     aaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbb, cccccccccccccccccc, dddddddddddddddddd,
1332     eeeeeeeeeeeeeeeeee, ffffffffffffffffff,
1333 };
1334 ```
1335
1336 #### `"Horizontal"`:
1337
1338 **Note**: This option forces all imports onto one line and may exceed `max_width`.
1339
1340 ```rust
1341 use foo::{xxx, yyy, zzz};
1342
1343 use foo::{aaa, bbb, ccc, ddd, eee, fff};
1344 ```
1345
1346 #### `"HorizontalVertical"`:
1347
1348 ```rust
1349 use foo::{xxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzzzz};
1350
1351 use foo::{
1352     aaaaaaaaaaaaaaaaaa,
1353     bbbbbbbbbbbbbbbbbb,
1354     cccccccccccccccccc,
1355     dddddddddddddddddd,
1356     eeeeeeeeeeeeeeeeee,
1357     ffffffffffffffffff,
1358 };
1359 ```
1360
1361 #### `"Vertical"`:
1362
1363 ```rust
1364 use foo::{
1365     xxx,
1366     yyy,
1367     zzz,
1368 };
1369
1370 use foo::{
1371     aaa,
1372     bbb,
1373     ccc,
1374     ddd,
1375     eee,
1376     fff,
1377 };
1378 ```
1379
1380 ## `indent_style`
1381
1382 Indent on expressions or items.
1383
1384 - **Default value**: `"Block"`
1385 - **Possible values**: `"Block"`, `"Visual"`
1386 - **Stable**: No (tracking issue: [#3346](https://github.com/rust-lang/rustfmt/issues/3346))
1387
1388 ### Array
1389
1390 #### `"Block"` (default):
1391
1392 ```rust
1393 fn main() {
1394     let lorem = vec![
1395         "ipsum",
1396         "dolor",
1397         "sit",
1398         "amet",
1399         "consectetur",
1400         "adipiscing",
1401         "elit",
1402     ];
1403 }
1404 ```
1405
1406 #### `"Visual"`:
1407
1408 ```rust
1409 fn main() {
1410     let lorem = vec!["ipsum",
1411                      "dolor",
1412                      "sit",
1413                      "amet",
1414                      "consectetur",
1415                      "adipiscing",
1416                      "elit"];
1417 }
1418 ```
1419
1420 ### Control flow
1421
1422 #### `"Block"` (default):
1423
1424 ```rust
1425 fn main() {
1426     if lorem_ipsum
1427         && dolor_sit
1428         && amet_consectetur
1429         && lorem_sit
1430         && dolor_consectetur
1431         && amet_ipsum
1432         && lorem_consectetur
1433     {
1434         // ...
1435     }
1436 }
1437 ```
1438
1439 #### `"Visual"`:
1440
1441 ```rust
1442 fn main() {
1443     if lorem_ipsum
1444        && dolor_sit
1445        && amet_consectetur
1446        && lorem_sit
1447        && dolor_consectetur
1448        && amet_ipsum
1449        && lorem_consectetur
1450     {
1451         // ...
1452     }
1453 }
1454 ```
1455
1456 See also: [`control_brace_style`](#control_brace_style).
1457
1458 ### Function arguments
1459
1460 #### `"Block"` (default):
1461
1462 ```rust
1463 fn lorem() {}
1464
1465 fn lorem(ipsum: usize) {}
1466
1467 fn lorem(
1468     ipsum: usize,
1469     dolor: usize,
1470     sit: usize,
1471     amet: usize,
1472     consectetur: usize,
1473     adipiscing: usize,
1474     elit: usize,
1475 ) {
1476     // body
1477 }
1478 ```
1479
1480 #### `"Visual"`:
1481
1482 ```rust
1483 fn lorem() {}
1484
1485 fn lorem(ipsum: usize) {}
1486
1487 fn lorem(ipsum: usize,
1488          dolor: usize,
1489          sit: usize,
1490          amet: usize,
1491          consectetur: usize,
1492          adipiscing: usize,
1493          elit: usize) {
1494     // body
1495 }
1496 ```
1497
1498 ### Function calls
1499
1500 #### `"Block"` (default):
1501
1502 ```rust
1503 fn main() {
1504     lorem(
1505         "lorem",
1506         "ipsum",
1507         "dolor",
1508         "sit",
1509         "amet",
1510         "consectetur",
1511         "adipiscing",
1512         "elit",
1513     );
1514 }
1515 ```
1516
1517 #### `"Visual"`:
1518
1519 ```rust
1520 fn main() {
1521     lorem("lorem",
1522           "ipsum",
1523           "dolor",
1524           "sit",
1525           "amet",
1526           "consectetur",
1527           "adipiscing",
1528           "elit");
1529 }
1530 ```
1531
1532 ### Generics
1533
1534 #### `"Block"` (default):
1535
1536 ```rust
1537 fn lorem<
1538     Ipsum: Eq = usize,
1539     Dolor: Eq = usize,
1540     Sit: Eq = usize,
1541     Amet: Eq = usize,
1542     Adipiscing: Eq = usize,
1543     Consectetur: Eq = usize,
1544     Elit: Eq = usize,
1545 >(
1546     ipsum: Ipsum,
1547     dolor: Dolor,
1548     sit: Sit,
1549     amet: Amet,
1550     adipiscing: Adipiscing,
1551     consectetur: Consectetur,
1552     elit: Elit,
1553 ) -> T {
1554     // body
1555 }
1556 ```
1557
1558 #### `"Visual"`:
1559
1560 ```rust
1561 fn lorem<Ipsum: Eq = usize,
1562          Dolor: Eq = usize,
1563          Sit: Eq = usize,
1564          Amet: Eq = usize,
1565          Adipiscing: Eq = usize,
1566          Consectetur: Eq = usize,
1567          Elit: Eq = usize>(
1568     ipsum: Ipsum,
1569     dolor: Dolor,
1570     sit: Sit,
1571     amet: Amet,
1572     adipiscing: Adipiscing,
1573     consectetur: Consectetur,
1574     elit: Elit)
1575     -> T {
1576     // body
1577 }
1578 ```
1579
1580 #### Struct
1581
1582 #### `"Block"` (default):
1583
1584 ```rust
1585 fn main() {
1586     let lorem = Lorem {
1587         ipsum: dolor,
1588         sit: amet,
1589     };
1590 }
1591 ```
1592
1593 #### `"Visual"`:
1594
1595 ```rust
1596 fn main() {
1597     let lorem = Lorem { ipsum: dolor,
1598                         sit: amet };
1599 }
1600 ```
1601
1602 See also: [`struct_lit_single_line`](#struct_lit_single_line), [`indent_style`](#indent_style).
1603
1604 ### Where predicates
1605
1606 #### `"Block"` (default):
1607
1608 ```rust
1609 fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
1610 where
1611     Ipsum: Eq,
1612     Dolor: Eq,
1613     Sit: Eq,
1614     Amet: Eq,
1615 {
1616     // body
1617 }
1618 ```
1619
1620 #### `"Visual"`:
1621
1622 ```rust
1623 fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
1624     where Ipsum: Eq,
1625           Dolor: Eq,
1626           Sit: Eq,
1627           Amet: Eq
1628 {
1629     // body
1630 }
1631 ```
1632
1633 ## `inline_attribute_width`
1634
1635 Write an item and its attribute on the same line if their combined width is below a threshold
1636
1637 - **Default value**: 0
1638 - **Possible values**: any positive integer
1639 - **Stable**: No (tracking issue: [#3343](https://github.com/rust-lang/rustfmt/issues/3343))
1640
1641 ### Example
1642
1643 #### `0` (default):
1644 ```rust
1645 #[cfg(feature = "alloc")]
1646 use core::slice;
1647 ```
1648
1649 #### `50`:
1650 ```rust
1651 #[cfg(feature = "alloc")] use core::slice;
1652 ```
1653
1654 ## `match_arm_blocks`
1655
1656 Controls whether arm bodies are wrapped in cases where the first line of the body cannot fit on the same line as the `=>` operator.
1657
1658 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.
1659
1660 - **Default value**: `true`
1661 - **Possible values**: `true`, `false`
1662 - **Stable**: No (tracking issue: [#3373](https://github.com/rust-lang/rustfmt/issues/3373))
1663
1664 #### `true` (default):
1665
1666 ```rust
1667 fn main() {
1668     match lorem {
1669         ipsum => {
1670             foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x)
1671         }
1672         dolor => println!("{}", sit),
1673         sit => foo(
1674             "foooooooooooooooooooooooo",
1675             "baaaaaaaaaaaaaaaaaaaaaaaarr",
1676             "baaaaaaaaaaaaaaaaaaaazzzzzzzzzzzzz",
1677             "qqqqqqqqquuuuuuuuuuuuuuuuuuuuuuuuuuxxx",
1678         ),
1679     }
1680 }
1681 ```
1682
1683 #### `false`:
1684
1685 ```rust
1686 fn main() {
1687     match lorem {
1688         lorem =>
1689             foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x),
1690         ipsum => println!("{}", sit),
1691         sit => foo(
1692             "foooooooooooooooooooooooo",
1693             "baaaaaaaaaaaaaaaaaaaaaaaarr",
1694             "baaaaaaaaaaaaaaaaaaaazzzzzzzzzzzzz",
1695             "qqqqqqqqquuuuuuuuuuuuuuuuuuuuuuuuuuxxx",
1696         ),
1697     }
1698 }
1699 ```
1700
1701 See also: [`match_block_trailing_comma`](#match_block_trailing_comma).
1702
1703 ## `match_arm_leading_pipes`
1704
1705 Controls whether to include a leading pipe on match arms
1706
1707 - **Default value**: `Never`
1708 - **Possible values**: `Always`, `Never`, `Preserve`
1709 - **Stable**: Yes
1710
1711 #### `Never` (default):
1712 ```rust
1713 // Leading pipes are removed from this:
1714 // fn foo() {
1715 //     match foo {
1716 //         | "foo" | "bar" => {}
1717 //         | "baz"
1718 //         | "something relatively long"
1719 //         | "something really really really realllllllllllllly long" => println!("x"),
1720 //         | "qux" => println!("y"),
1721 //         _ => {}
1722 //     }
1723 // }
1724
1725 // Becomes
1726 fn foo() {
1727     match foo {
1728         "foo" | "bar" => {}
1729         "baz"
1730         | "something relatively long"
1731         | "something really really really realllllllllllllly long" => println!("x"),
1732         "qux" => println!("y"),
1733         _ => {}
1734     }
1735 }
1736 ```
1737
1738 #### `Always`:
1739 ```rust
1740 // Leading pipes are emitted on all arms of this:
1741 // fn foo() {
1742 //     match foo {
1743 //         "foo" | "bar" => {}
1744 //         "baz"
1745 //         | "something relatively long"
1746 //         | "something really really really realllllllllllllly long" => println!("x"),
1747 //         "qux" => println!("y"),
1748 //         _ => {}
1749 //     }
1750 // }
1751
1752 // Becomes:
1753 fn foo() {
1754     match foo {
1755         | "foo" | "bar" => {}
1756         | "baz"
1757         | "something relatively long"
1758         | "something really really really realllllllllllllly long" => println!("x"),
1759         | "qux" => println!("y"),
1760         | _ => {}
1761     }
1762 }
1763 ```
1764
1765 #### `Preserve`:
1766 ```rust
1767 fn foo() {
1768     match foo {
1769         | "foo" | "bar" => {}
1770         | "baz"
1771         | "something relatively long"
1772         | "something really really really realllllllllllllly long" => println!("x"),
1773         | "qux" => println!("y"),
1774         _ => {}
1775     }
1776
1777     match baz {
1778         "qux" => {}
1779         "foo" | "bar" => {}
1780         _ => {}
1781     }
1782 }
1783 ```
1784
1785 ## `match_block_trailing_comma`
1786
1787 Put a trailing comma after a block based match arm (non-block arms are not affected)
1788
1789 - **Default value**: `false`
1790 - **Possible values**: `true`, `false`
1791 - **Stable**: Yes
1792
1793 #### `false` (default):
1794
1795 ```rust
1796 fn main() {
1797     match lorem {
1798         Lorem::Ipsum => {
1799             println!("ipsum");
1800         }
1801         Lorem::Dolor => println!("dolor"),
1802     }
1803 }
1804 ```
1805
1806 #### `true`:
1807
1808 ```rust
1809 fn main() {
1810     match lorem {
1811         Lorem::Ipsum => {
1812             println!("ipsum");
1813         },
1814         Lorem::Dolor => println!("dolor"),
1815     }
1816 }
1817 ```
1818
1819 See also: [`trailing_comma`](#trailing_comma), [`match_arm_blocks`](#match_arm_blocks).
1820
1821 ## `max_width`
1822
1823 Maximum width of each line
1824
1825 - **Default value**: `100`
1826 - **Possible values**: any positive integer
1827 - **Stable**: Yes
1828
1829 See also [`error_on_line_overflow`](#error_on_line_overflow).
1830
1831 ## `merge_derives`
1832
1833 Merge multiple derives into a single one.
1834
1835 - **Default value**: `true`
1836 - **Possible values**: `true`, `false`
1837 - **Stable**: Yes
1838
1839 #### `true` (default):
1840
1841 ```rust
1842 #[derive(Eq, PartialEq, Debug, Copy, Clone)]
1843 pub enum Foo {}
1844 ```
1845
1846 #### `false`:
1847
1848 ```rust
1849 #[derive(Eq, PartialEq, Debug, Copy, Clone)]
1850 pub enum Bar {}
1851
1852 #[derive(Eq, PartialEq)]
1853 #[derive(Debug)]
1854 #[derive(Copy, Clone)]
1855 pub enum Foo {}
1856 ```
1857
1858 ## `imports_granularity`
1859
1860 Controls how imports are structured in `use` statements. Imports will be merged or split to the configured level of granularity.
1861
1862 Similar to other `import` related configuration options, this option operates within the bounds of user-defined groups of imports. See [`group_imports`](#group_imports) for more information on import groups.
1863
1864 Note that rustfmt will not modify the granularity of imports containing comments if doing so could potentially lose or misplace said comments.
1865
1866 - **Default value**: `Preserve`
1867 - **Possible values**: `Preserve`, `Crate`, `Module`, `Item`, `One`
1868 - **Stable**: No (tracking issue: [#4991](https://github.com/rust-lang/rustfmt/issues/4991))
1869
1870
1871 #### `Preserve` (default):
1872
1873 Do not change the granularity of any imports and preserve the original structure written by the developer.
1874
1875 ```rust
1876 use foo::b;
1877 use foo::b::{f, g};
1878 use foo::{a, c, d::e};
1879 use qux::{h, i};
1880 ```
1881
1882 #### `Crate`:
1883
1884 Merge imports from the same crate into a single `use` statement. Conversely, imports from different crates are split into separate statements.
1885
1886 ```rust
1887 use foo::{
1888     a, b,
1889     b::{f, g},
1890     c,
1891     d::e,
1892 };
1893 use qux::{h, i};
1894 ```
1895
1896 #### `Module`:
1897
1898 Merge imports from the same module into a single `use` statement. Conversely, imports from different modules are split into separate statements.
1899
1900 ```rust
1901 use foo::b::{f, g};
1902 use foo::d::e;
1903 use foo::{a, b, c};
1904 use qux::{h, i};
1905 ```
1906
1907 #### `Item`:
1908
1909 Flatten imports so that each has its own `use` statement.
1910
1911 ```rust
1912 use foo::a;
1913 use foo::b;
1914 use foo::b::f;
1915 use foo::b::g;
1916 use foo::c;
1917 use foo::d::e;
1918 use qux::h;
1919 use qux::i;
1920 ```
1921
1922 #### `One`:
1923
1924 Merge all imports into a single `use` statement as long as they have the same visibility.
1925
1926 ```rust
1927 pub use foo::{x, y};
1928 use {
1929     bar::{
1930         a,
1931         b::{self, f, g},
1932         c,
1933         d::e,
1934     },
1935     qux::{h, i},
1936 };
1937 ```
1938
1939 ## `merge_imports`
1940
1941 This option is deprecated. Use `imports_granularity = "Crate"` instead.
1942
1943 - **Default value**: `false`
1944 - **Possible values**: `true`, `false`
1945
1946 #### `false` (default):
1947
1948 ```rust
1949 use foo::{a, c, d};
1950 use foo::{b, g};
1951 use foo::{e, f};
1952 ```
1953
1954 #### `true`:
1955
1956 ```rust
1957 use foo::{a, b, c, d, e, f, g};
1958 ```
1959
1960
1961 ## `newline_style`
1962
1963 Unix or Windows line endings
1964
1965 - **Default value**: `"Auto"`
1966 - **Possible values**: `"Auto"`, `"Native"`, `"Unix"`, `"Windows"`
1967 - **Stable**: Yes
1968
1969 #### `Auto` (default):
1970
1971 The newline style is detected automatically on a per-file basis. Files
1972 with mixed line endings will be converted to the first detected line
1973 ending style.
1974
1975 #### `Native`
1976
1977 Line endings will be converted to `\r\n` on Windows and `\n` on all
1978 other platforms.
1979
1980 #### `Unix`
1981
1982 Line endings will be converted to `\n`.
1983
1984 #### `Windows`
1985
1986 Line endings will be converted to `\r\n`.
1987
1988 ## `normalize_comments`
1989
1990 Convert /* */ comments to // comments where possible
1991
1992 - **Default value**: `false`
1993 - **Possible values**: `true`, `false`
1994 - **Stable**: No (tracking issue: [#3350](https://github.com/rust-lang/rustfmt/issues/3350))
1995
1996 #### `false` (default):
1997
1998 ```rust
1999 // Lorem ipsum:
2000 fn dolor() -> usize {}
2001
2002 /* sit amet: */
2003 fn adipiscing() -> usize {}
2004 ```
2005
2006 #### `true`:
2007
2008 ```rust
2009 // Lorem ipsum:
2010 fn dolor() -> usize {}
2011
2012 // sit amet:
2013 fn adipiscing() -> usize {}
2014 ```
2015
2016 ## `normalize_doc_attributes`
2017
2018 Convert `#![doc]` and `#[doc]` attributes to `//!` and `///` doc comments.
2019
2020 - **Default value**: `false`
2021 - **Possible values**: `true`, `false`
2022 - **Stable**: No (tracking issue: [#3351](https://github.com/rust-lang/rustfmt/issues/3351))
2023
2024 #### `false` (default):
2025
2026 ```rust
2027 #![doc = "Example documentation"]
2028
2029 #[doc = "Example item documentation"]
2030 pub enum Bar {}
2031
2032 /// Example item documentation
2033 pub enum Foo {}
2034 ```
2035
2036 #### `true`:
2037
2038 ```rust
2039 //! Example documentation
2040
2041 /// Example item documentation
2042 pub enum Foo {}
2043 ```
2044
2045 ## `overflow_delimited_expr`
2046
2047 When structs, slices, arrays, and block/array-like macros are used as the last
2048 argument in an expression list, allow them to overflow (like blocks/closures)
2049 instead of being indented on a new line.
2050
2051 - **Default value**: `false`
2052 - **Possible values**: `true`, `false`
2053 - **Stable**: No (tracking issue: [#3370](https://github.com/rust-lang/rustfmt/issues/3370))
2054
2055 #### `false` (default):
2056
2057 ```rust
2058 fn example() {
2059     foo(ctx, |param| {
2060         action();
2061         foo(param)
2062     });
2063
2064     foo(
2065         ctx,
2066         Bar {
2067             x: value,
2068             y: value2,
2069         },
2070     );
2071
2072     foo(
2073         ctx,
2074         &[
2075             MAROON_TOMATOES,
2076             PURPLE_POTATOES,
2077             ORGANE_ORANGES,
2078             GREEN_PEARS,
2079             RED_APPLES,
2080         ],
2081     );
2082
2083     foo(
2084         ctx,
2085         vec![
2086             MAROON_TOMATOES,
2087             PURPLE_POTATOES,
2088             ORGANE_ORANGES,
2089             GREEN_PEARS,
2090             RED_APPLES,
2091         ],
2092     );
2093 }
2094 ```
2095
2096 #### `true`:
2097
2098 ```rust
2099 fn example() {
2100     foo(ctx, |param| {
2101         action();
2102         foo(param)
2103     });
2104
2105     foo(ctx, Bar {
2106         x: value,
2107         y: value2,
2108     });
2109
2110     foo(ctx, &[
2111         MAROON_TOMATOES,
2112         PURPLE_POTATOES,
2113         ORGANE_ORANGES,
2114         GREEN_PEARS,
2115         RED_APPLES,
2116     ]);
2117
2118     foo(ctx, vec![
2119         MAROON_TOMATOES,
2120         PURPLE_POTATOES,
2121         ORGANE_ORANGES,
2122         GREEN_PEARS,
2123         RED_APPLES,
2124     ]);
2125 }
2126 ```
2127
2128 ## `remove_nested_parens`
2129
2130 Remove nested parens.
2131
2132 - **Default value**: `true`,
2133 - **Possible values**: `true`, `false`
2134 - **Stable**: Yes
2135
2136
2137 #### `true` (default):
2138 ```rust
2139 fn main() {
2140     (foo());
2141 }
2142 ```
2143
2144 #### `false`:
2145 ```rust
2146 fn main() {
2147     (foo());
2148
2149     ((((foo()))));
2150 }
2151 ```
2152
2153
2154 ## `reorder_impl_items`
2155
2156 Reorder impl items. `type` and `const` are put first, then macros and methods.
2157
2158 - **Default value**: `false`
2159 - **Possible values**: `true`, `false`
2160 - **Stable**: No (tracking issue: [#3363](https://github.com/rust-lang/rustfmt/issues/3363))
2161
2162 #### `false` (default)
2163
2164 ```rust
2165 struct Dummy;
2166
2167 impl Iterator for Dummy {
2168     fn next(&mut self) -> Option<Self::Item> {
2169         None
2170     }
2171
2172     type Item = i32;
2173 }
2174
2175 impl Iterator for Dummy {
2176     type Item = i32;
2177
2178     fn next(&mut self) -> Option<Self::Item> {
2179         None
2180     }
2181 }
2182 ```
2183
2184 #### `true`
2185
2186 ```rust
2187 struct Dummy;
2188
2189 impl Iterator for Dummy {
2190     type Item = i32;
2191
2192     fn next(&mut self) -> Option<Self::Item> {
2193         None
2194     }
2195 }
2196 ```
2197
2198 ## `reorder_imports`
2199
2200 Reorder import and extern crate statements alphabetically in groups (a group is
2201 separated by a newline).
2202
2203 - **Default value**: `true`
2204 - **Possible values**: `true`, `false`
2205 - **Stable**: Yes
2206
2207 #### `true` (default):
2208
2209 ```rust
2210 use dolor;
2211 use ipsum;
2212 use lorem;
2213 use sit;
2214 ```
2215
2216 #### `false`:
2217
2218 ```rust
2219 use lorem;
2220 use ipsum;
2221 use dolor;
2222 use sit;
2223 ```
2224
2225 ## `group_imports`
2226
2227 Controls the strategy for how consecutive imports are grouped together.
2228
2229 Controls the strategy for grouping sets of consecutive imports. Imports may contain newlines between imports and still be grouped together as a single set, but other statements between imports will result in different grouping sets.
2230
2231 - **Default value**: `Preserve`
2232 - **Possible values**: `Preserve`, `StdExternalCrate`, `One`
2233 - **Stable**: No (tracking issue: [#5083](https://github.com/rust-lang/rustfmt/issues/5083))
2234
2235 Each set of imports (one or more `use` statements, optionally separated by newlines) will be formatted independently. Other statements such as `mod ...` or `extern crate ...` will cause imports to not be grouped together.
2236
2237 #### `Preserve` (default):
2238
2239 Preserve the source file's import groups.
2240
2241 ```rust
2242 use super::update::convert_publish_payload;
2243 use chrono::Utc;
2244
2245 use alloc::alloc::Layout;
2246 use juniper::{FieldError, FieldResult};
2247 use uuid::Uuid;
2248
2249 use std::sync::Arc;
2250
2251 use broker::database::PooledConnection;
2252
2253 use super::schema::{Context, Payload};
2254 use crate::models::Event;
2255 use core::f32;
2256 ```
2257
2258 #### `StdExternalCrate`:
2259
2260 Discard existing import groups, and create three groups for:
2261 1. `std`, `core` and `alloc`,
2262 2. external crates,
2263 3. `self`, `super` and `crate` imports.
2264
2265 ```rust
2266 use alloc::alloc::Layout;
2267 use core::f32;
2268 use std::sync::Arc;
2269
2270 use broker::database::PooledConnection;
2271 use chrono::Utc;
2272 use juniper::{FieldError, FieldResult};
2273 use uuid::Uuid;
2274
2275 use super::schema::{Context, Payload};
2276 use super::update::convert_publish_payload;
2277 use crate::models::Event;
2278 ```
2279
2280 #### `One`:
2281
2282 Discard existing import groups, and create a single group for everything
2283
2284 ```rust
2285 use super::schema::{Context, Payload};
2286 use super::update::convert_publish_payload;
2287 use crate::models::Event;
2288 use alloc::alloc::Layout;
2289 use broker::database::PooledConnection;
2290 use chrono::Utc;
2291 use core::f32;
2292 use juniper::{FieldError, FieldResult};
2293 use std::sync::Arc;
2294 use uuid::Uuid;
2295 ```
2296
2297 ## `reorder_modules`
2298
2299 Reorder `mod` declarations alphabetically in group.
2300
2301 - **Default value**: `true`
2302 - **Possible values**: `true`, `false`
2303 - **Stable**: Yes
2304
2305 #### `true` (default)
2306
2307 ```rust
2308 mod a;
2309 mod b;
2310
2311 mod dolor;
2312 mod ipsum;
2313 mod lorem;
2314 mod sit;
2315 ```
2316
2317 #### `false`
2318
2319 ```rust
2320 mod b;
2321 mod a;
2322
2323 mod lorem;
2324 mod ipsum;
2325 mod dolor;
2326 mod sit;
2327 ```
2328
2329 **Note** `mod` with `#[macro_export]` will not be reordered since that could change the semantics
2330 of the original source code.
2331
2332 ## `required_version`
2333
2334 Require a specific version of rustfmt. If you want to make sure that the
2335 specific version of rustfmt is used in your CI, use this option.
2336
2337 - **Default value**: `CARGO_PKG_VERSION`
2338 - **Possible values**: any published version (e.g. `"0.3.8"`)
2339 - **Stable**: No (tracking issue: [#3386](https://github.com/rust-lang/rustfmt/issues/3386))
2340
2341 ## `short_array_element_width_threshold`
2342
2343 The width threshold for an array element to be considered "short".
2344
2345 The layout of an array is dependent on the length of each of its elements.
2346 If the length of every element in an array is below this threshold (all elements are "short") then the array can be formatted in the mixed/compressed style, but if any one element has a length that exceeds this threshold then the array elements will have to be formatted vertically.
2347
2348 - **Default value**: `10`
2349 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
2350 - **Stable**: Yes
2351
2352 #### `10` (default):
2353 ```rust
2354 fn main() {
2355     pub const FORMAT_TEST: [u64; 5] = [
2356         0x0000000000000000,
2357         0xaaaaaaaaaaaaaaaa,
2358         0xbbbbbbbbbbbbbbbb,
2359         0xcccccccccccccccc,
2360         0xdddddddddddddddd,
2361     ];
2362 }
2363 ```
2364 #### `20`:
2365 ```rust
2366 fn main() {
2367     pub const FORMAT_TEST: [u64; 5] = [
2368         0x0000000000000000, 0xaaaaaaaaaaaaaaaa, 0xbbbbbbbbbbbbbbbb, 0xcccccccccccccccc,
2369         0xdddddddddddddddd,
2370     ];
2371 }
2372 ```
2373 See also [`max_width`](#max_width).
2374
2375 ## `skip_children`
2376
2377 Don't reformat out of line modules
2378
2379 - **Default value**: `false`
2380 - **Possible values**: `true`, `false`
2381 - **Stable**: No (tracking issue: [#3389](https://github.com/rust-lang/rustfmt/issues/3389))
2382
2383 ## `single_line_if_else_max_width`
2384
2385 Maximum line length for single line if-else expressions. A value of `0` (zero) results in if-else expressions always being broken into multiple lines. Note this occurs when `use_small_heuristics` is set to `Off`.
2386
2387 - **Default value**: `50`
2388 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
2389 - **Stable**: Yes
2390
2391 By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `single_line_if_else_max_width` will take precedence.
2392
2393 See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
2394
2395 ## `space_after_colon`
2396
2397 Leave a space after the colon.
2398
2399 - **Default value**: `true`
2400 - **Possible values**: `true`, `false`
2401 - **Stable**: No (tracking issue: [#3366](https://github.com/rust-lang/rustfmt/issues/3366))
2402
2403 #### `true` (default):
2404
2405 ```rust
2406 fn lorem<T: Eq>(t: T) {
2407     let lorem: Dolor = Lorem {
2408         ipsum: dolor,
2409         sit: amet,
2410     };
2411 }
2412 ```
2413
2414 #### `false`:
2415
2416 ```rust
2417 fn lorem<T:Eq>(t:T) {
2418     let lorem:Dolor = Lorem {
2419         ipsum:dolor,
2420         sit:amet,
2421     };
2422 }
2423 ```
2424
2425 See also: [`space_before_colon`](#space_before_colon).
2426
2427 ## `space_before_colon`
2428
2429 Leave a space before the colon.
2430
2431 - **Default value**: `false`
2432 - **Possible values**: `true`, `false`
2433 - **Stable**: No (tracking issue: [#3365](https://github.com/rust-lang/rustfmt/issues/3365))
2434
2435 #### `false` (default):
2436
2437 ```rust
2438 fn lorem<T: Eq>(t: T) {
2439     let lorem: Dolor = Lorem {
2440         ipsum: dolor,
2441         sit: amet,
2442     };
2443 }
2444 ```
2445
2446 #### `true`:
2447
2448 ```rust
2449 fn lorem<T : Eq>(t : T) {
2450     let lorem : Dolor = Lorem {
2451         ipsum : dolor,
2452         sit : amet,
2453     };
2454 }
2455 ```
2456
2457 See also: [`space_after_colon`](#space_after_colon).
2458
2459 ## `spaces_around_ranges`
2460
2461 Put spaces around the .., ..=, and ... range operators
2462
2463 - **Default value**: `false`
2464 - **Possible values**: `true`, `false`
2465 - **Stable**: No (tracking issue: [#3367](https://github.com/rust-lang/rustfmt/issues/3367))
2466
2467 #### `false` (default):
2468
2469 ```rust
2470 fn main() {
2471     let lorem = 0..10;
2472     let ipsum = 0..=10;
2473
2474     match lorem {
2475         1..5 => foo(),
2476         _ => bar,
2477     }
2478
2479     match lorem {
2480         1..=5 => foo(),
2481         _ => bar,
2482     }
2483
2484     match lorem {
2485         1...5 => foo(),
2486         _ => bar,
2487     }
2488 }
2489 ```
2490
2491 #### `true`:
2492
2493 ```rust
2494 fn main() {
2495     let lorem = 0 .. 10;
2496     let ipsum = 0 ..= 10;
2497
2498     match lorem {
2499         1 .. 5 => foo(),
2500         _ => bar,
2501     }
2502
2503     match lorem {
2504         1 ..= 5 => foo(),
2505         _ => bar,
2506     }
2507
2508     match lorem {
2509         1 ... 5 => foo(),
2510         _ => bar,
2511     }
2512 }
2513 ```
2514
2515 ## `struct_field_align_threshold`
2516
2517 The maximum diff of width between struct fields to be aligned with each other.
2518
2519 - **Default value** : 0
2520 - **Possible values**: any non-negative integer
2521 - **Stable**: No (tracking issue: [#3371](https://github.com/rust-lang/rustfmt/issues/3371))
2522
2523 #### `0` (default):
2524
2525 ```rust
2526 struct Foo {
2527     x: u32,
2528     yy: u32,
2529     zzz: u32,
2530 }
2531 ```
2532
2533 #### `20`:
2534
2535 ```rust
2536 struct Foo {
2537     x:   u32,
2538     yy:  u32,
2539     zzz: u32,
2540 }
2541 ```
2542
2543 ## `struct_lit_single_line`
2544
2545 Put small struct literals on a single line
2546
2547 - **Default value**: `true`
2548 - **Possible values**: `true`, `false`
2549 - **Stable**: No (tracking issue: [#3357](https://github.com/rust-lang/rustfmt/issues/3357))
2550
2551 #### `true` (default):
2552
2553 ```rust
2554 fn main() {
2555     let lorem = Lorem { foo: bar, baz: ofo };
2556 }
2557 ```
2558
2559 #### `false`:
2560
2561 ```rust
2562 fn main() {
2563     let lorem = Lorem {
2564         foo: bar,
2565         baz: ofo,
2566     };
2567 }
2568 ```
2569
2570 See also: [`indent_style`](#indent_style).
2571
2572 ## `struct_lit_width`
2573
2574 Maximum width in the body of a struct literal before falling back to vertical formatting. A value of `0` (zero) results in struct literals always being broken into multiple lines. Note this occurs when `use_small_heuristics` is set to `Off`.
2575
2576 - **Default value**: `18`
2577 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
2578 - **Stable**: Yes
2579
2580 By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `struct_lit_width` will take precedence.
2581
2582 See also [`max_width`](#max_width), [`use_small_heuristics`](#use_small_heuristics), and [`struct_lit_single_line`](#struct_lit_single_line)
2583
2584 ## `struct_variant_width`
2585
2586 Maximum width in the body of a struct variant before falling back to vertical formatting. A value of `0` (zero) results in struct literals always being broken into multiple lines. Note this occurs when `use_small_heuristics` is set to `Off`.
2587
2588 - **Default value**: `35`
2589 - **Possible values**: any positive integer that is less than or equal to the value specified for [`max_width`](#max_width)
2590 - **Stable**: Yes
2591
2592 By default this option is set as a percentage of [`max_width`](#max_width) provided by [`use_small_heuristics`](#use_small_heuristics), but a value set directly for `struct_variant_width` will take precedence.
2593
2594 See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuristics)
2595
2596 ## `tab_spaces`
2597
2598 Number of spaces per tab
2599
2600 - **Default value**: `4`
2601 - **Possible values**: any positive integer
2602 - **Stable**: Yes
2603
2604 #### `4` (default):
2605
2606 ```rust
2607 fn lorem() {
2608     let ipsum = dolor();
2609     let sit = vec![
2610         "amet consectetur adipiscing elit amet",
2611         "consectetur adipiscing elit amet consectetur.",
2612     ];
2613 }
2614 ```
2615
2616 #### `2`:
2617
2618 ```rust
2619 fn lorem() {
2620   let ipsum = dolor();
2621   let sit = vec![
2622     "amet consectetur adipiscing elit amet",
2623     "consectetur adipiscing elit amet consectetur.",
2624   ];
2625 }
2626 ```
2627
2628 See also: [`hard_tabs`](#hard_tabs).
2629
2630
2631 ## `trailing_comma`
2632
2633 How to handle trailing commas for lists
2634
2635 - **Default value**: `"Vertical"`
2636 - **Possible values**: `"Always"`, `"Never"`, `"Vertical"`
2637 - **Stable**: No (tracking issue: [#3379](https://github.com/rust-lang/rustfmt/issues/3379))
2638
2639 #### `"Vertical"` (default):
2640
2641 ```rust
2642 fn main() {
2643     let Lorem { ipsum, dolor, sit } = amet;
2644     let Lorem {
2645         ipsum,
2646         dolor,
2647         sit,
2648         amet,
2649         consectetur,
2650         adipiscing,
2651     } = elit;
2652 }
2653 ```
2654
2655 #### `"Always"`:
2656
2657 ```rust
2658 fn main() {
2659     let Lorem { ipsum, dolor, sit, } = amet;
2660     let Lorem {
2661         ipsum,
2662         dolor,
2663         sit,
2664         amet,
2665         consectetur,
2666         adipiscing,
2667     } = elit;
2668 }
2669 ```
2670
2671 #### `"Never"`:
2672
2673 ```rust
2674 fn main() {
2675     let Lorem { ipsum, dolor, sit } = amet;
2676     let Lorem {
2677         ipsum,
2678         dolor,
2679         sit,
2680         amet,
2681         consectetur,
2682         adipiscing
2683     } = elit;
2684 }
2685 ```
2686
2687 See also: [`match_block_trailing_comma`](#match_block_trailing_comma).
2688
2689 ## `trailing_semicolon`
2690
2691 Add trailing semicolon after break, continue and return
2692
2693 - **Default value**: `true`
2694 - **Possible values**: `true`, `false`
2695 - **Stable**: No (tracking issue: [#3378](https://github.com/rust-lang/rustfmt/issues/3378))
2696
2697 #### `true` (default):
2698 ```rust
2699 fn foo() -> usize {
2700     return 0;
2701 }
2702 ```
2703
2704 #### `false`:
2705 ```rust
2706 fn foo() -> usize {
2707     return 0
2708 }
2709 ```
2710
2711 ## `type_punctuation_density`
2712
2713 Determines if `+` or `=` are wrapped in spaces in the punctuation of types
2714
2715 - **Default value**: `"Wide"`
2716 - **Possible values**: `"Compressed"`, `"Wide"`
2717 - **Stable**: No (tracking issue: [#3364](https://github.com/rust-lang/rustfmt/issues/3364))
2718
2719 #### `"Wide"` (default):
2720
2721 ```rust
2722 fn lorem<Ipsum: Dolor + Sit = Amet>() {
2723     // body
2724 }
2725 ```
2726
2727 #### `"Compressed"`:
2728
2729 ```rust
2730 fn lorem<Ipsum: Dolor+Sit=Amet>() {
2731     // body
2732 }
2733 ```
2734
2735 ## `unstable_features`
2736
2737 Enable unstable features on the unstable channel.
2738
2739 - **Default value**: `false`
2740 - **Possible values**: `true`, `false`
2741 - **Stable**: No (tracking issue: [#3387](https://github.com/rust-lang/rustfmt/issues/3387))
2742
2743 ## `use_field_init_shorthand`
2744
2745 Use field initialize shorthand if possible.
2746
2747 - **Default value**: `false`
2748 - **Possible values**: `true`, `false`
2749 - **Stable**: Yes
2750
2751 #### `false` (default):
2752
2753 ```rust
2754 struct Foo {
2755     x: u32,
2756     y: u32,
2757     z: u32,
2758 }
2759
2760 fn main() {
2761     let x = 1;
2762     let y = 2;
2763     let z = 3;
2764     let a = Foo { x, y, z };
2765     let b = Foo { x: x, y: y, z: z };
2766 }
2767 ```
2768
2769 #### `true`:
2770
2771 ```rust
2772 struct Foo {
2773     x: u32,
2774     y: u32,
2775     z: u32,
2776 }
2777
2778 fn main() {
2779     let x = 1;
2780     let y = 2;
2781     let z = 3;
2782     let a = Foo { x, y, z };
2783 }
2784 ```
2785
2786 ## `use_small_heuristics`
2787
2788 This option can be used to simplify the management and bulk updates of the granular width configuration settings ([`fn_call_width`](#fn_call_width), [`attr_fn_like_width`](#attr_fn_like_width), [`struct_lit_width`](#struct_lit_width), [`struct_variant_width`](#struct_variant_width), [`array_width`](#array_width), [`chain_width`](#chain_width), [`single_line_if_else_max_width`](#single_line_if_else_max_width)), that respectively control when formatted constructs are multi-lined/vertical based on width.
2789
2790 Note that explicitly provided values for the width configuration settings take precedence and override the calculated values determined by `use_small_heuristics`.
2791
2792 - **Default value**: `"Default"`
2793 - **Possible values**: `"Default"`, `"Off"`, `"Max"`
2794 - **Stable**: Yes
2795
2796 #### `Default` (default):
2797 When `use_small_heuristics` is set to `Default`, the values for the granular width settings are calculated as a ratio of the value for `max_width`.
2798
2799 The ratios are:
2800 * [`fn_call_width`](#fn_call_width) - `60%`
2801 * [`attr_fn_like_width`](#attr_fn_like_width) - `70%`
2802 * [`struct_lit_width`](#struct_lit_width) - `18%`
2803 * [`struct_variant_width`](#struct_variant_width) - `35%`
2804 * [`array_width`](#array_width) - `60%`
2805 * [`chain_width`](#chain_width) - `60%`
2806 * [`single_line_if_else_max_width`](#single_line_if_else_max_width) - `50%`
2807
2808 For example when `max_width` is set to `100`, the width settings are:
2809 * `fn_call_width=60`
2810 * `attr_fn_like_width=70`
2811 * `struct_lit_width=18`
2812 * `struct_variant_width=35`
2813 * `array_width=60`
2814 * `chain_width=60`
2815 * `single_line_if_else_max_width=50`
2816
2817 and when `max_width` is set to `200`:
2818 * `fn_call_width=120`
2819 * `attr_fn_like_width=140`
2820 * `struct_lit_width=36`
2821 * `struct_variant_width=70`
2822 * `array_width=120`
2823 * `chain_width=120`
2824 * `single_line_if_else_max_width=100`
2825
2826 ```rust
2827 enum Lorem {
2828     Ipsum,
2829     Dolor(bool),
2830     Sit { amet: Consectetur, adipiscing: Elit },
2831 }
2832
2833 fn main() {
2834     lorem(
2835         "lorem",
2836         "ipsum",
2837         "dolor",
2838         "sit",
2839         "amet",
2840         "consectetur",
2841         "adipiscing",
2842     );
2843
2844     let lorem = Lorem {
2845         ipsum: dolor,
2846         sit: amet,
2847     };
2848     let lorem = Lorem { ipsum: dolor };
2849
2850     let lorem = if ipsum { dolor } else { sit };
2851 }
2852 ```
2853
2854 #### `Off`:
2855 When `use_small_heuristics` is set to `Off`, the granular width settings are functionally disabled and ignored. See the documentation for the respective width config options for specifics.
2856
2857 ```rust
2858 enum Lorem {
2859     Ipsum,
2860     Dolor(bool),
2861     Sit {
2862         amet: Consectetur,
2863         adipiscing: Elit,
2864     },
2865 }
2866
2867 fn main() {
2868     lorem("lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing");
2869
2870     let lorem = Lorem {
2871         ipsum: dolor,
2872         sit: amet,
2873     };
2874
2875     let lorem = if ipsum {
2876         dolor
2877     } else {
2878         sit
2879     };
2880 }
2881 ```
2882
2883 #### `Max`:
2884 When `use_small_heuristics` is set to `Max`, then each granular width setting is set to the same value as `max_width`.
2885
2886 So if `max_width` is set to `200`, then all the width settings are also set to `200`.
2887 * `fn_call_width=200`
2888 * `attr_fn_like_width=200`
2889 * `struct_lit_width=200`
2890 * `struct_variant_width=200`
2891 * `array_width=200`
2892 * `chain_width=200`
2893 * `single_line_if_else_max_width=200`
2894
2895 ```rust
2896 enum Lorem {
2897     Ipsum,
2898     Dolor(bool),
2899     Sit { amet: Consectetur, adipiscing: Elit },
2900 }
2901
2902 fn main() {
2903     lorem("lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing");
2904
2905     let lorem = Lorem { ipsum: dolor, sit: amet };
2906
2907     let lorem = if ipsum { dolor } else { sit };
2908 }
2909 ```
2910
2911
2912 See also:
2913 * [`max_width`](#max_width)
2914 * [`fn_call_width`](#fn_call_width)
2915 * [`attr_fn_like_width`](#attr_fn_like_width)
2916 * [`struct_lit_width`](#struct_lit_width)
2917 * [`struct_variant_width`](#struct_variant_width)
2918 * [`array_width`](#array_width)
2919 * [`chain_width`](#chain_width)
2920 * [`single_line_if_else_max_width`](#single_line_if_else_max_width)
2921
2922 ## `use_try_shorthand`
2923
2924 Replace uses of the try! macro by the ? shorthand
2925
2926 - **Default value**: `false`
2927 - **Possible values**: `true`, `false`
2928 - **Stable**: Yes
2929
2930 #### `false` (default):
2931
2932 ```rust
2933 fn main() {
2934     let lorem = ipsum.map(|dolor| dolor.sit())?;
2935
2936     let lorem = try!(ipsum.map(|dolor| dolor.sit()));
2937 }
2938 ```
2939
2940 #### `true`:
2941
2942 ```rust
2943 fn main() {
2944     let lorem = ipsum.map(|dolor| dolor.sit())?;
2945 }
2946 ```
2947
2948 ## `version`
2949
2950 Which version of the formatting rules to use. `Version::One` is backwards-compatible
2951 with Rustfmt 1.0. Other versions are only backwards compatible within a major
2952 version number.
2953
2954 - **Default value**: `One`
2955 - **Possible values**: `One`, `Two`
2956 - **Stable**: No (tracking issue: [#3383](https://github.com/rust-lang/rustfmt/issues/3383))
2957
2958 ### Example
2959
2960 ```toml
2961 version = "Two"
2962 ```
2963
2964 ## `where_single_line`
2965
2966 Forces the `where` clause to be laid out on a single line.
2967
2968 - **Default value**: `false`
2969 - **Possible values**: `true`, `false`
2970 - **Stable**: No (tracking issue: [#3359](https://github.com/rust-lang/rustfmt/issues/3359))
2971
2972 #### `false` (default):
2973
2974 ```rust
2975 impl<T> Lorem for T
2976 where
2977     Option<T>: Ipsum,
2978 {
2979     // body
2980 }
2981 ```
2982
2983 #### `true`:
2984
2985 ```rust
2986 impl<T> Lorem for T
2987 where Option<T>: Ipsum
2988 {
2989     // body
2990 }
2991 ```
2992
2993 See also [`brace_style`](#brace_style), [`control_brace_style`](#control_brace_style).
2994
2995
2996 ## `wrap_comments`
2997
2998 Break comments to fit on the line
2999
3000 - **Default value**: `false`
3001 - **Possible values**: `true`, `false`
3002 - **Stable**: No (tracking issue: [#3347](https://github.com/rust-lang/rustfmt/issues/3347))
3003
3004 #### `false` (default):
3005
3006 ```rust
3007 // Lorem ipsum dolor sit amet, consectetur adipiscing elit,
3008 // sed do eiusmod tempor incididunt ut labore et dolore
3009 // magna aliqua. Ut enim ad minim veniam, quis nostrud
3010 // exercitation ullamco laboris nisi ut aliquip ex ea
3011 // commodo consequat.
3012
3013 // Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
3014 ```
3015
3016 #### `true`:
3017
3018 ```rust
3019 // Lorem ipsum dolor sit amet, consectetur adipiscing elit,
3020 // sed do eiusmod tempor incididunt ut labore et dolore
3021 // magna aliqua. Ut enim ad minim veniam, quis nostrud
3022 // exercitation ullamco laboris nisi ut aliquip ex ea
3023 // commodo consequat.
3024 ```
3025
3026 # Internal Options
3027
3028 ## `emit_mode`
3029
3030 Internal option
3031
3032 ## `make_backup`
3033
3034 Internal option, use `--backup`
3035
3036 ## `print_misformatted_file_names`
3037
3038 Internal option, use `-l` or `--files-with-diff`