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.
   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 be used directly, while unstable options are opt-in.
  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
  21 ## `indent_style`
  22
  23 Indent on expressions or items.
  24
  25 - **Default value**: `"Block"`
  26 - **Possible values**: `"Block"`, `"Visual"`
  27 - **Stable**: No
  28
  29 ### Array
  30
  31 #### `"Block"` (default):
  32
  33 ```rust
  34 fn main() {
  35     let lorem = vec![
  36         "ipsum",
  37         "dolor",
  38         "sit",
  39         "amet",
  40         "consectetur",
  41         "adipiscing",
  42         "elit",
  43     ];
  44 }
  45 ```
  46
  47 #### `"Visual"`:
  48
  49 ```rust
  50 fn main() {
  51     let lorem = vec!["ipsum",
  52                      "dolor",
  53                      "sit",
  54                      "amet",
  55                      "consectetur",
  56                      "adipiscing",
  57                      "elit"];
  58 }
  59 ```
  60
  61 ### Control flow
  62
  63 #### `"Block"` (default):
  64
  65 ```rust
  66 fn main() {
  67     if lorem_ipsum && dolor_sit && amet_consectetur && lorem_sit && dolor_consectetur && amet_ipsum
  68         && lorem_consectetur
  69     {
  70         // ...
  71     }
  72 }
  73 ```
  74
  75 #### `"Visual"`:
  76
  77 ```rust
  78 fn main() {
  79     if lorem_ipsum && dolor_sit && amet_consectetur && lorem_sit && dolor_consectetur && amet_ipsum
  80        && lorem_consectetur
  81     {
  82         // ...
  83     }
  84 }
  85 ```
  86
  87 See also: [`control_brace_style`](#control_brace_style).
  88
  89 ### Function arguments
  90
  91 #### `"Block"` (default):
  92
  93 ```rust
  94 fn lorem() {}
  95
  96 fn lorem(ipsum: usize) {}
  97
  98 fn lorem(
  99     ipsum: usize,
 100     dolor: usize,
 101     sit: usize,
 102     amet: usize,
 103     consectetur: usize,
 104     adipiscing: usize,
 105     elit: usize,
 106 ) {
 107     // body
 108 }
 109 ```
 110
 111 #### `"Visual"`:
 112
 113 ```rust
 114 fn lorem() {}
 115
 116 fn lorem(ipsum: usize) {}
 117
 118 fn lorem(ipsum: usize,
 119          dolor: usize,
 120          sit: usize,
 121          amet: usize,
 122          consectetur: usize,
 123          adipiscing: usize,
 124          elit: usize) {
 125     // body
 126 }
 127 ```
 128
 129 ### Function calls
 130
 131 #### `"Block"` (default):
 132
 133 ```rust
 134 fn main() {
 135     lorem(
 136         "lorem",
 137         "ipsum",
 138         "dolor",
 139         "sit",
 140         "amet",
 141         "consectetur",
 142         "adipiscing",
 143         "elit",
 144     );
 145 }
 146 ```
 147
 148 #### `"Visual"`:
 149
 150 ```rust
 151 fn main() {
 152     lorem("lorem",
 153           "ipsum",
 154           "dolor",
 155           "sit",
 156           "amet",
 157           "consectetur",
 158           "adipiscing",
 159           "elit");
 160 }
 161 ```
 162
 163 ### Generics
 164
 165 #### `"Block"` (default):
 166
 167 ```rust
 168 fn lorem<
 169     Ipsum: Eq = usize,
 170     Dolor: Eq = usize,
 171     Sit: Eq = usize,
 172     Amet: Eq = usize,
 173     Adipiscing: Eq = usize,
 174     Consectetur: Eq = usize,
 175     Elit: Eq = usize,
 176 >(
 177     ipsum: Ipsum,
 178     dolor: Dolor,
 179     sit: Sit,
 180     amet: Amet,
 181     adipiscing: Adipiscing,
 182     consectetur: Consectetur,
 183     elit: Elit,
 184 ) -> T {
 185     // body
 186 }
 187 ```
 188
 189 #### `"Visual"`:
 190
 191 ```rust
 192 fn lorem<Ipsum: Eq = usize,
 193          Dolor: Eq = usize,
 194          Sit: Eq = usize,
 195          Amet: Eq = usize,
 196          Adipiscing: Eq = usize,
 197          Consectetur: Eq = usize,
 198          Elit: Eq = usize>(
 199     ipsum: Ipsum,
 200     dolor: Dolor,
 201     sit: Sit,
 202     amet: Amet,
 203     adipiscing: Adipiscing,
 204     consectetur: Consectetur,
 205     elit: Elit)
 206     -> T {
 207     // body
 208 }
 209 ```
 210
 211 #### Struct
 212
 213 #### `"Block"` (default):
 214
 215 ```rust
 216 fn main() {
 217     let lorem = Lorem {
 218         ipsum: dolor,
 219         sit: amet,
 220     };
 221 }
 222 ```
 223
 224 #### `"Visual"`:
 225
 226 ```rust
 227 fn main() {
 228     let lorem = Lorem { ipsum: dolor,
 229                         sit: amet, };
 230 }
 231 ```
 232
 233 See also: [`struct_lit_single_line`](#struct_lit_single_line), [`indent_style`](#indent_style).
 234
 235 ### Where predicates
 236
 237 #### `"Block"` (default):
 238
 239 ```rust
 240 fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
 241 where
 242     Ipsum: Eq,
 243     Dolor: Eq,
 244     Sit: Eq,
 245     Amet: Eq,
 246 {
 247     // body
 248 }
 249 ```
 250
 251 #### `"Visual"`:
 252
 253 ```rust
 254 fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
 255     where Ipsum: Eq,
 256           Dolor: Eq,
 257           Sit: Eq,
 258           Amet: Eq
 259 {
 260     // body
 261 }
 262 ```
 263
 264 ## `use_small_heuristics`
 265
 266 Whether to use different formatting for items and expressions if they satisfy a heuristic notion of 'small'.
 267
 268 - **Default value**: `true`
 269 - **Possible values**: `true`, `false`
 270 - **Stable**: No
 271
 272 #### `true` (default):
 273
 274 ```rust
 275 enum Lorem {
 276     Ipsum,
 277     Dolor(bool),
 278     Sit { amet: Consectetur, adipiscing: Elit },
 279 }
 280
 281 fn main() {
 282     lorem(
 283         "lorem",
 284         "ipsum",
 285         "dolor",
 286         "sit",
 287         "amet",
 288         "consectetur",
 289         "adipiscing",
 290     );
 291
 292     let lorem = Lorem {
 293         ipsum: dolor,
 294         sit: amet,
 295     };
 296     let lorem = Lorem { ipsum: dolor };
 297
 298     let lorem = if ipsum { dolor } else { sit };
 299 }
 300 ```
 301
 302 #### `false`:
 303
 304 ```rust
 305 enum Lorem {
 306     Ipsum,
 307     Dolor(bool),
 308     Sit {
 309         amet: Consectetur,
 310         adipiscing: Elit,
 311     },
 312 }
 313
 314 fn main() {
 315     lorem("lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing");
 316
 317     let lorem = Lorem {
 318         ipsum: dolor,
 319         sit: amet,
 320     };
 321
 322     let lorem = if ipsum {
 323         dolor
 324     } else {
 325         sit
 326     };
 327 }
 328 ```
 329
 330 ## `binop_separator`
 331
 332 Where to put a binary operator when a binary expression goes multiline.
 333
 334 - **Default value**: `"Front"`
 335 - **Possible values**: `"Front"`, `"Back"`
 336 - **Stable**: No
 337
 338 #### `"Front"` (default):
 339
 340 ```rust
 341 fn main() {
 342     let or = foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo
 343         || barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar;
 344
 345     let sum = 123456789012345678901234567890 + 123456789012345678901234567890
 346         + 123456789012345678901234567890;
 347
 348     let range = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 349         ..bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
 350 }
 351 ```
 352
 353 #### `"Back"`:
 354
 355 ```rust
 356 fn main() {
 357     let or = foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo ||
 358         barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar;
 359
 360     let sum = 123456789012345678901234567890 + 123456789012345678901234567890 +
 361         123456789012345678901234567890;
 362
 363     let range = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..
 364         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
 365 }
 366 ```
 367
 368 ## `combine_control_expr`
 369
 370 Combine control expressions with function calls.
 371
 372 - **Default value**: `true`
 373 - **Possible values**: `true`, `false`
 374 - **Stable**: No
 375
 376 #### `true` (default):
 377
 378 ```rust
 379 fn example() {
 380     // If
 381     foo!(if x {
 382         foo();
 383     } else {
 384         bar();
 385     });
 386
 387     // IfLet
 388     foo!(if let Some(..) = x {
 389         foo();
 390     } else {
 391         bar();
 392     });
 393
 394     // While
 395     foo!(while x {
 396         foo();
 397         bar();
 398     });
 399
 400     // WhileLet
 401     foo!(while let Some(..) = x {
 402         foo();
 403         bar();
 404     });
 405
 406     // ForLoop
 407     foo!(for x in y {
 408         foo();
 409         bar();
 410     });
 411
 412     // Loop
 413     foo!(loop {
 414         foo();
 415         bar();
 416     });
 417 }
 418 ```
 419
 420 #### `false`:
 421
 422 ```rust
 423 fn example() {
 424     // If
 425     foo!(
 426         if x {
 427             foo();
 428         } else {
 429             bar();
 430         }
 431     );
 432
 433     // IfLet
 434     foo!(
 435         if let Some(..) = x {
 436             foo();
 437         } else {
 438             bar();
 439         }
 440     );
 441
 442     // While
 443     foo!(
 444         while x {
 445             foo();
 446             bar();
 447         }
 448     );
 449
 450     // WhileLet
 451     foo!(
 452         while let Some(..) = x {
 453             foo();
 454             bar();
 455         }
 456     );
 457
 458     // ForLoop
 459     foo!(
 460         for x in y {
 461             foo();
 462             bar();
 463         }
 464     );
 465
 466     // Loop
 467     foo!(
 468         loop {
 469             foo();
 470             bar();
 471         }
 472     );
 473 }
 474 ```
 475
 476 ## `comment_width`
 477
 478 Maximum length of comments. No effect unless`wrap_comments = true`.
 479
 480 - **Default value**: `80`
 481 - **Possible values**: any positive integer
 482 - **Stable**: No
 483
 484 **Note:** A value of `0` results in [`wrap_comments`](#wrap_comments) being applied regardless of a line's width.
 485
 486 #### `80` (default; comments shorter than `comment_width`):
 487 ```rust
 488 // Lorem ipsum dolor sit amet, consectetur adipiscing elit.
 489 ```
 490
 491 #### `60` (comments longer than `comment_width`):
 492 ```rust
 493 // Lorem ipsum dolor sit amet,
 494 // consectetur adipiscing elit.
 495 ```
 496
 497 See also [`wrap_comments`](#wrap_comments).
 498
 499 ## `condense_wildcard_suffixes`
 500
 501 Replace strings of _ wildcards by a single .. in tuple patterns
 502
 503 - **Default value**: `false`
 504 - **Possible values**: `true`, `false`
 505 - **Stable**: No
 506
 507 #### `false` (default):
 508
 509 ```rust
 510 fn main() {
 511     let (lorem, ipsum, _, _) = (1, 2, 3, 4);
 512     let (lorem, ipsum, ..) = (1, 2, 3, 4);
 513 }
 514 ```
 515
 516 #### `true`:
 517
 518 ```rust
 519 fn main() {
 520     let (lorem, ipsum, ..) = (1, 2, 3, 4);
 521 }
 522 ```
 523
 524 ## `control_brace_style`
 525
 526 Brace style for control flow constructs
 527
 528 - **Default value**: `"AlwaysSameLine"`
 529 - **Possible values**: `"AlwaysNextLine"`, `"AlwaysSameLine"`, `"ClosingNextLine"`
 530 - **Stable**: No
 531
 532 #### `"AlwaysSameLine"` (default):
 533
 534 ```rust
 535 fn main() {
 536     if lorem {
 537         println!("ipsum!");
 538     } else {
 539         println!("dolor!");
 540     }
 541 }
 542 ```
 543
 544 #### `"AlwaysNextLine"`:
 545
 546 ```rust
 547 fn main() {
 548     if lorem
 549     {
 550         println!("ipsum!");
 551     }
 552     else
 553     {
 554         println!("dolor!");
 555     }
 556 }
 557 ```
 558
 559 #### `"ClosingNextLine"`:
 560
 561 ```rust
 562 fn main() {
 563     if lorem {
 564         println!("ipsum!");
 565     }
 566     else {
 567         println!("dolor!");
 568     }
 569 }
 570 ```
 571
 572 ## `disable_all_formatting`
 573
 574 Don't reformat anything
 575
 576 - **Default value**: `false`
 577 - **Possible values**: `true`, `false`
 578 - **Stable**: No
 579
 580 ## `error_on_line_overflow`
 581
 582 Error if Rustfmt is unable to get all lines within `max_width`, except for comments and string
 583 literals. If this happens, then it is a bug in Rustfmt. You might be able to work around the bug by
 584 refactoring your code to avoid long/complex expressions, usually by extracting a local variable or
 585 using a shorter name.
 586
 587 - **Default value**: `false`
 588 - **Possible values**: `true`, `false`
 589 - **Stable**: No
 590
 591 See also [`max_width`](#max_width).
 592
 593 ## `error_on_unformatted`
 594
 595 Error if unable to get comments or string literals within `max_width`, or they are left with
 596 trailing whitespaces.
 597
 598 - **Default value**: `false`
 599 - **Possible values**: `true`, `false`
 600 - **Stable**: No
 601
 602 ## `fn_args_density`
 603
 604 Argument density in functions
 605
 606 - **Default value**: `"Tall"`
 607 - **Possible values**: `"Compressed"`, `"Tall"`, `"Vertical"`
 608 - **Stable**: No
 609
 610 #### `"Tall"` (default):
 611
 612 ```rust
 613 trait Lorem {
 614     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet);
 615
 616     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet) {
 617         // body
 618     }
 619
 620     fn lorem(
 621         ipsum: Ipsum,
 622         dolor: Dolor,
 623         sit: Sit,
 624         amet: Amet,
 625         consectetur: Consectetur,
 626         adipiscing: Adipiscing,
 627         elit: Elit,
 628     );
 629
 630     fn lorem(
 631         ipsum: Ipsum,
 632         dolor: Dolor,
 633         sit: Sit,
 634         amet: Amet,
 635         consectetur: Consectetur,
 636         adipiscing: Adipiscing,
 637         elit: Elit,
 638     ) {
 639         // body
 640     }
 641 }
 642 ```
 643
 644 #### `"Compressed"`:
 645
 646 ```rust
 647 trait Lorem {
 648     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet);
 649
 650     fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet) {
 651         // body
 652     }
 653
 654     fn lorem(
 655         ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
 656         adipiscing: Adipiscing, elit: Elit,
 657     );
 658
 659     fn lorem(
 660         ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
 661         adipiscing: Adipiscing, elit: Elit,
 662     ) {
 663         // body
 664     }
 665 }
 666 ```
 667
 668 #### `"Vertical"`:
 669
 670 ```rust
 671 trait Lorem {
 672     fn lorem(
 673         ipsum: Ipsum,
 674         dolor: Dolor,
 675         sit: Sit,
 676         amet: Amet,
 677     );
 678
 679     fn lorem(
 680         ipsum: Ipsum,
 681         dolor: Dolor,
 682         sit: Sit,
 683         amet: Amet,
 684     ) {
 685         // body
 686     }
 687
 688     fn lorem(
 689         ipsum: Ipsum,
 690         dolor: Dolor,
 691         sit: Sit,
 692         amet: Amet,
 693         consectetur: Consectetur,
 694         adipiscing: Adipiscing,
 695         elit: Elit,
 696     );
 697
 698     fn lorem(
 699         ipsum: Ipsum,
 700         dolor: Dolor,
 701         sit: Sit,
 702         amet: Amet,
 703         consectetur: Consectetur,
 704         adipiscing: Adipiscing,
 705         elit: Elit,
 706     ) {
 707         // body
 708     }
 709 }
 710 ```
 711
 712
 713 ## `brace_style`
 714
 715 Brace style for items
 716
 717 - **Default value**: `"SameLineWhere"`
 718 - **Possible values**: `"AlwaysNextLine"`, `"PreferSameLine"`, `"SameLineWhere"`
 719 - **Stable**: No
 720
 721 ### Functions
 722
 723 #### `"SameLineWhere"` (default):
 724
 725 ```rust
 726 fn lorem() {
 727     // body
 728 }
 729
 730 fn lorem(ipsum: usize) {
 731     // body
 732 }
 733
 734 fn lorem<T>(ipsum: T)
 735 where
 736     T: Add + Sub + Mul + Div,
 737 {
 738     // body
 739 }
 740 ```
 741
 742 #### `"AlwaysNextLine"`:
 743
 744 ```rust
 745 fn lorem()
 746 {
 747     // body
 748 }
 749
 750 fn lorem(ipsum: usize)
 751 {
 752     // body
 753 }
 754
 755 fn lorem<T>(ipsum: T)
 756 where
 757     T: Add + Sub + Mul + Div,
 758 {
 759     // body
 760 }
 761 ```
 762
 763 #### `"PreferSameLine"`:
 764
 765 ```rust
 766 fn lorem() {
 767     // body
 768 }
 769
 770 fn lorem(ipsum: usize) {
 771     // body
 772 }
 773
 774 fn lorem<T>(ipsum: T)
 775 where
 776     T: Add + Sub + Mul + Div, {
 777     // body
 778 }
 779 ```
 780
 781 ### Structs and enums
 782
 783 #### `"SameLineWhere"` (default):
 784
 785 ```rust
 786 struct Lorem {
 787     ipsum: bool,
 788 }
 789
 790 struct Dolor<T>
 791 where
 792     T: Eq,
 793 {
 794     sit: T,
 795 }
 796 ```
 797
 798 #### `"AlwaysNextLine"`:
 799
 800 ```rust
 801 struct Lorem
 802 {
 803     ipsum: bool,
 804 }
 805
 806 struct Dolor<T>
 807 where
 808     T: Eq,
 809 {
 810     sit: T,
 811 }
 812 ```
 813
 814 #### `"PreferSameLine"`:
 815
 816 ```rust
 817 struct Lorem {
 818     ipsum: bool,
 819 }
 820
 821 struct Dolor<T>
 822 where
 823     T: Eq, {
 824     sit: T,
 825 }
 826 ```
 827
 828
 829 ## `empty_item_single_line`
 830
 831 Put empty-body functions and impls on a single line
 832
 833 - **Default value**: `true`
 834 - **Possible values**: `true`, `false`
 835 - **Stable**: No
 836
 837 #### `true` (default):
 838
 839 ```rust
 840 fn lorem() {}
 841
 842 impl Lorem {}
 843 ```
 844
 845 #### `false`:
 846
 847 ```rust
 848 fn lorem() {
 849 }
 850
 851 impl Lorem {
 852 }
 853 ```
 854
 855 See also [`brace_style`](#brace_style), [`control_brace_style`](#control_brace_style).
 856
 857
 858 ## `fn_single_line`
 859
 860 Put single-expression functions on a single line
 861
 862 - **Default value**: `false`
 863 - **Possible values**: `true`, `false`
 864 - **Stable**: No
 865
 866 #### `false` (default):
 867
 868 ```rust
 869 fn lorem() -> usize {
 870     42
 871 }
 872
 873 fn lorem() -> usize {
 874     let ipsum = 42;
 875     ipsum
 876 }
 877 ```
 878
 879 #### `true`:
 880
 881 ```rust
 882 fn lorem() -> usize { 42 }
 883
 884 fn lorem() -> usize {
 885     let ipsum = 42;
 886     ipsum
 887 }
 888 ```
 889
 890 See also [`control_brace_style`](#control_brace_style).
 891
 892
 893 ## `where_single_line`
 894
 895 Forces the `where` clause to be laid out on a single line.
 896
 897 - **Default value**: `false`
 898 - **Possible values**: `true`, `false`
 899 - **Stable**: No
 900
 901 #### `false` (default):
 902
 903 ```rust
 904 impl<T> Lorem for T
 905 where
 906     Option<T>: Ipsum,
 907 {
 908     // body
 909 }
 910 ```
 911
 912 #### `true`:
 913
 914 ```rust
 915 impl<T> Lorem for T
 916 where Option<T>: Ipsum
 917 {
 918     // body
 919 }
 920 ```
 921
 922 See also [`brace_style`](#brace_style), [`control_brace_style`](#control_brace_style).
 923
 924
 925 ## `force_explicit_abi`
 926
 927 Always print the abi for extern items
 928
 929 - **Default value**: `true`
 930 - **Possible values**: `true`, `false`
 931 - **Stable**: Yes
 932
 933 **Note:** Non-"C" ABIs are always printed. If `false` then "C" is removed.
 934
 935 #### `true` (default):
 936
 937 ```rust
 938 extern "C" {
 939     pub static lorem: c_int;
 940 }
 941 ```
 942
 943 #### `false`:
 944
 945 ```rust
 946 extern {
 947     pub static lorem: c_int;
 948 }
 949 ```
 950
 951 ## `format_strings`
 952
 953 Format string literals where necessary
 954
 955 - **Default value**: `false`
 956 - **Possible values**: `true`, `false`
 957 - **Stable**: No
 958
 959 #### `false` (default):
 960
 961 ```rust
 962 fn main() {
 963     let lorem =
 964         "ipsum dolor sit amet consectetur adipiscing elit lorem ipsum dolor sit amet consectetur adipiscing";
 965 }
 966 ```
 967
 968 #### `true`:
 969
 970 ```rust
 971 fn main() {
 972     let lorem = "ipsum dolor sit amet consectetur adipiscing elit lorem ipsum dolor sit amet \
 973                  consectetur adipiscing";
 974 }
 975 ```
 976
 977 See also [`max_width`](#max_width).
 978
 979 ## `hard_tabs`
 980
 981 Use tab characters for indentation, spaces for alignment
 982
 983 - **Default value**: `false`
 984 - **Possible values**: `true`, `false`
 985 - **Stable**: Yes
 986
 987 #### `false` (default):
 988
 989 ```rust
 990 fn lorem() -> usize {
 991     42 // spaces before 42
 992 }
 993 ```
 994
 995 #### `true`:
 996
 997 ```rust
 998 fn lorem() -> usize {
 999         42 // tabs before 42
1000 }
1001 ```
1002
1003 See also: [`tab_spaces`](#tab_spaces).
1004
1005
1006 ## `imports_indent`
1007
1008 Indent style of imports
1009
1010 - **Default Value**: `"Visual"`
1011 - **Possible values**: `"Block"`, `"Visual"`
1012 - **Stable**: No
1013
1014 #### `"Visual"` (default):
1015
1016 ```rust
1017 use foo::{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,
1018           zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz};
1019 ```
1020
1021 #### `"Block"`:
1022
1023 ```rust
1024 use foo::{
1025     xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,
1026     zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
1027 };
1028 ```
1029
1030 See also: [`imports_layout`](#imports_layout).
1031
1032 ## `imports_layout`
1033
1034 Item layout inside a imports block
1035
1036 - **Default value**: "Mixed"
1037 - **Possible values**: "Horizontal", "HorizontalVertical", "Mixed", "Vertical"
1038 - **Stable**: No
1039
1040 #### `"Mixed"` (default):
1041
1042 ```rust
1043 use foo::{xxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzzzz};
1044
1045 use foo::{aaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbb, cccccccccccccccccc, dddddddddddddddddd,
1046           eeeeeeeeeeeeeeeeee, ffffffffffffffffff};
1047 ```
1048
1049 #### `"Horizontal"`:
1050
1051 **Note**: This option forces all imports onto one line and may exceed `max_width`.
1052
1053 ```rust
1054 use foo::{xxx, yyy, zzz};
1055
1056 use foo::{aaa, bbb, ccc, ddd, eee, fff};
1057 ```
1058
1059 #### `"HorizontalVertical"`:
1060
1061 ```rust
1062 use foo::{xxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzzzz};
1063
1064 use foo::{aaaaaaaaaaaaaaaaaa,
1065           bbbbbbbbbbbbbbbbbb,
1066           cccccccccccccccccc,
1067           dddddddddddddddddd,
1068           eeeeeeeeeeeeeeeeee,
1069           ffffffffffffffffff};
1070 ```
1071
1072 #### `"Vertical"`:
1073
1074 ```rust
1075 use foo::{xxx,
1076           yyy,
1077           zzz};
1078
1079 use foo::{aaa,
1080           bbb,
1081           ccc,
1082           ddd,
1083           eee,
1084           fff};
1085 ```
1086
1087 ## `merge_imports`
1088
1089 Merge multiple imports into a single nested import.
1090
1091 - **Default value**: `false`
1092 - **Possible values**: `true`, `false`
1093 - **Stable**: No
1094
1095 #### `false` (default):
1096
1097 ```rust
1098 use foo::{a, c, d};
1099 use foo::{b, g};
1100 use foo::{e, f};
1101 ```
1102
1103 #### `true`:
1104
1105 ```rust
1106 use foo::{a, b, c, d, e, f, g};
1107 ```
1108
1109
1110 ## `match_block_trailing_comma`
1111
1112 Put a trailing comma after a block based match arm (non-block arms are not affected)
1113
1114 - **Default value**: `false`
1115 - **Possible values**: `true`, `false`
1116 - **Stable**: No
1117
1118 #### `false` (default):
1119
1120 ```rust
1121 fn main() {
1122     match lorem {
1123         Lorem::Ipsum => {
1124             println!("ipsum");
1125         }
1126         Lorem::Dolor => println!("dolor"),
1127     }
1128 }
1129 ```
1130
1131 #### `true`:
1132
1133 ```rust
1134 fn main() {
1135     match lorem {
1136         Lorem::Ipsum => {
1137             println!("ipsum");
1138         },
1139         Lorem::Dolor => println!("dolor"),
1140     }
1141 }
1142 ```
1143
1144 See also: [`trailing_comma`](#trailing_comma), [`match_arm_blocks`](#match_arm_blocks).
1145
1146 ## `max_width`
1147
1148 Maximum width of each line
1149
1150 - **Default value**: `100`
1151 - **Possible values**: any positive integer
1152 - **Stable**: Yes
1153
1154 See also [`error_on_line_overflow`](#error_on_line_overflow).
1155
1156 ## `merge_derives`
1157
1158 Merge multiple derives into a single one.
1159
1160 - **Default value**: `true`
1161 - **Possible values**: `true`, `false`
1162 - **Stable**: Yes
1163
1164 #### `true` (default):
1165
1166 ```rust
1167 #[derive(Eq, PartialEq, Debug, Copy, Clone)]
1168 pub enum Foo {}
1169 ```
1170
1171 #### `false`:
1172
1173 ```rust
1174 #[derive(Eq, PartialEq)]
1175 #[derive(Debug)]
1176 #[derive(Copy, Clone)]
1177 pub enum Foo {}
1178 ```
1179
1180 ## `force_multiline_blocks`
1181
1182 Force multiline closure and match arm bodies to be wrapped in a block
1183
1184 - **Default value**: `false`
1185 - **Possible values**: `false`, `true`
1186 - **Stable**: No
1187
1188 #### `false` (default):
1189
1190 ```rust
1191 fn main() {
1192     result.and_then(|maybe_value| match maybe_value {
1193         None => foo(),
1194         Some(value) => bar(),
1195     });
1196
1197     match lorem {
1198         None => if ipsum {
1199             println!("Hello World");
1200         },
1201         Some(dolor) => foo(),
1202     }
1203 }
1204 ```
1205
1206 #### `true`:
1207
1208 ```rust
1209 fn main() {
1210     result.and_then(|maybe_value| {
1211         match maybe_value {
1212             None => foo(),
1213             Some(value) => bar(),
1214         }
1215     });
1216
1217     match lorem {
1218         None => {
1219             if ipsum {
1220                 println!("Hello World");
1221             }
1222         }
1223         Some(dolor) => foo(),
1224     }
1225 }
1226 ```
1227
1228
1229 ## `newline_style`
1230
1231 Unix or Windows line endings
1232
1233 - **Default value**: `"Unix"`
1234 - **Possible values**: `"Native"`, `"Unix"`, `"Windows"`
1235 - **Stable**: Yes
1236
1237 ## `normalize_comments`
1238
1239 Convert /* */ comments to // comments where possible
1240
1241 - **Default value**: `false`
1242 - **Possible values**: `true`, `false`
1243 - **Stable**: Yes
1244
1245 #### `false` (default):
1246
1247 ```rust
1248 // Lorem ipsum:
1249 fn dolor() -> usize {}
1250
1251 /* sit amet: */
1252 fn adipiscing() -> usize {}
1253 ```
1254
1255 #### `true`:
1256
1257 ```rust
1258 // Lorem ipsum:
1259 fn dolor() -> usize {}
1260
1261 // sit amet:
1262 fn adipiscing() -> usize {}
1263 ```
1264
1265
1266 ## `reorder_imports`
1267
1268 Reorder import and extern crate statements alphabetically in groups (a group is
1269 separated by a newline).
1270
1271 - **Default value**: `true`
1272 - **Possible values**: `true`, `false`
1273 - **Stable**: No
1274
1275 #### `false` (default):
1276
1277 ```rust
1278 use lorem;
1279 use ipsum;
1280 use dolor;
1281 use sit;
1282 ```
1283
1284 #### `true`:
1285
1286 ```rust
1287 use dolor;
1288 use ipsum;
1289 use lorem;
1290 use sit;
1291 ```
1292
1293
1294 ## `reorder_modules`
1295
1296 Reorder `mod` declarations alphabetically in group.
1297
1298 - **Default value**: `true`
1299 - **Possible values**: `true`, `false`
1300 - **Stable**: No
1301
1302 #### `true` (default)
1303
1304 ```rust
1305 mod a;
1306 mod b;
1307
1308 mod dolor;
1309 mod ipsum;
1310 mod lorem;
1311 mod sit;
1312 ```
1313
1314 #### `false`
1315
1316 ```rust
1317 mod b;
1318 mod a;
1319
1320 mod lorem;
1321 mod ipsum;
1322 mod dolor;
1323 mod sit;
1324 ```
1325
1326 **Note** `mod` with `#[macro_export]` will not be reordered since that could change the semantic
1327 of the original source code.
1328
1329 ## `reorder_impl_items`
1330
1331 Reorder impl items. `type` and `const` are put first, then macros and methods.
1332
1333 - **Default value**: `false`
1334 - **Possible values**: `true`, `false`
1335 - **Stable**: No
1336
1337 #### `false` (default)
1338
1339 ```rust
1340 struct Dummy;
1341
1342 impl Iterator for Dummy {
1343     fn next(&mut self) -> Option<Self::Item> {
1344         None
1345     }
1346
1347     type Item = i32;
1348 }
1349 ```
1350
1351 #### `true`
1352
1353 ```rust
1354 struct Dummy;
1355
1356 impl Iterator for Dummy {
1357     type Item = i32;
1358
1359     fn next(&mut self) -> Option<Self::Item> {
1360         None
1361     }
1362 }
1363 ```
1364
1365 ## `report_todo`
1366
1367 Report `TODO` items in comments.
1368
1369 - **Default value**: `"Never"`
1370 - **Possible values**: `"Always"`, `"Unnumbered"`, `"Never"`
1371 - **Stable**: No
1372
1373 Warns about any comments containing `TODO` in them when set to `"Always"`. If
1374 it contains a `#X` (with `X` being a number) in parentheses following the
1375 `TODO`, `"Unnumbered"` will ignore it.
1376
1377 See also [`report_fixme`](#report_fixme).
1378
1379 ## `report_fixme`
1380
1381 Report `FIXME` items in comments.
1382
1383 - **Default value**: `"Never"`
1384 - **Possible values**: `"Always"`, `"Unnumbered"`, `"Never"`
1385 - **Stable**: No
1386
1387 Warns about any comments containing `FIXME` in them when set to `"Always"`. If
1388 it contains a `#X` (with `X` being a number) in parentheses following the
1389 `FIXME`, `"Unnumbered"` will ignore it.
1390
1391 See also [`report_todo`](#report_todo).
1392
1393
1394 ## `skip_children`
1395
1396 Don't reformat out of line modules
1397
1398 - **Default value**: `false`
1399 - **Possible values**: `true`, `false`
1400 - **Stable**: No
1401
1402 ## `space_after_colon`
1403
1404 Leave a space after the colon.
1405
1406 - **Default value**: `true`
1407 - **Possible values**: `true`, `false`
1408 - **Stable**: No
1409
1410 #### `true` (default):
1411
1412 ```rust
1413 fn lorem<T: Eq>(t: T) {
1414     let lorem: Dolor = Lorem {
1415         ipsum: dolor,
1416         sit: amet,
1417     };
1418 }
1419 ```
1420
1421 #### `false`:
1422
1423 ```rust
1424 fn lorem<T:Eq>(t:T) {
1425     let lorem:Dolor = Lorem {
1426         ipsum:dolor,
1427         sit:amet,
1428     };
1429 }
1430 ```
1431
1432 See also: [`space_before_colon`](#space_before_colon).
1433
1434 ## `space_before_colon`
1435
1436 Leave a space before the colon.
1437
1438 - **Default value**: `false`
1439 - **Possible values**: `true`, `false`
1440 - **Stable**: No
1441
1442 #### `false` (default):
1443
1444 ```rust
1445 fn lorem<T: Eq>(t: T) {
1446     let lorem: Dolor = Lorem {
1447         ipsum: dolor,
1448         sit: amet,
1449     };
1450 }
1451 ```
1452
1453 #### `true`:
1454
1455 ```rust
1456 fn lorem<T : Eq>(t : T) {
1457     let lorem : Dolor = Lorem {
1458         ipsum : dolor,
1459         sit : amet,
1460     };
1461 }
1462 ```
1463
1464 See also: [`space_after_colon`](#space_after_colon).
1465
1466 ## `struct_field_align_threshold`
1467
1468 The maximum diff of width between struct fields to be aligned with each other.
1469
1470 - **Default value** : 0
1471 - **Possible values**: any positive integer
1472 - **Stable**: No
1473
1474 #### `0` (default):
1475
1476 ```rust
1477 struct Foo {
1478     x: u32,
1479     yy: u32,
1480     zzz: u32,
1481 }
1482 ```
1483
1484 #### `20`:
1485
1486 ```rust
1487 struct Foo {
1488     x:   u32,
1489     yy:  u32,
1490     zzz: u32,
1491 }
1492 ```
1493
1494 ## `spaces_around_ranges`
1495
1496 Put spaces around the .., ..=, and ... range operators
1497
1498 - **Default value**: `false`
1499 - **Possible values**: `true`, `false`
1500 - **Stable**: No
1501
1502 #### `false` (default):
1503
1504 ```rust
1505 fn main() {
1506     let lorem = 0..10;
1507     let ipsum = 0..=10;
1508
1509     match lorem {
1510         1..5 => foo(),
1511         _ => bar,
1512     }
1513
1514     match lorem {
1515         1..=5 => foo(),
1516         _ => bar,
1517     }
1518
1519     match lorem {
1520         1...5 => foo(),
1521         _ => bar,
1522     }
1523 }
1524 ```
1525
1526 #### `true`:
1527
1528 ```rust
1529 fn main() {
1530     let lorem = 0 .. 10;
1531     let ipsum = 0 ..= 10;
1532
1533     match lorem {
1534         1 .. 5 => foo(),
1535         _ => bar,
1536     }
1537
1538     match lorem {
1539         1 ..= 5 => foo(),
1540         _ => bar,
1541     }
1542
1543     match lorem {
1544         1 ... 5 => foo(),
1545         _ => bar,
1546     }
1547 }
1548 ```
1549
1550 ## `spaces_within_parens_and_brackets`
1551
1552 Put spaces within non-empty generic arguments, parentheses, and square brackets
1553
1554 - **Default value**: `false`
1555 - **Possible values**: `true`, `false`
1556 - **Stable**: No
1557
1558 #### `false` (default):
1559
1560 ```rust
1561 // generic arguments
1562 fn lorem<T: Eq>(t: T) {
1563     // body
1564 }
1565
1566 // non-empty parentheses
1567 fn lorem<T: Eq>(t: T) {
1568     let lorem = (ipsum, dolor);
1569 }
1570
1571 // non-empty square brackets
1572 fn lorem<T: Eq>(t: T) {
1573     let lorem: [usize; 2] = [ipsum, dolor];
1574 }
1575 ```
1576
1577 #### `true`:
1578
1579 ```rust
1580 // generic arguments
1581 fn lorem< T: Eq >( t: T ) {
1582     // body
1583 }
1584
1585 // non-empty parentheses
1586 fn lorem< T: Eq >( t: T ) {
1587     let lorem = ( ipsum, dolor );
1588 }
1589
1590 // non-empty square brackets
1591 fn lorem< T: Eq >( t: T ) {
1592     let lorem: [ usize; 2 ] = [ ipsum, dolor ];
1593 }
1594 ```
1595
1596 ## `struct_lit_single_line`
1597
1598 Put small struct literals on a single line
1599
1600 - **Default value**: `true`
1601 - **Possible values**: `true`, `false`
1602 - **Stable**: No
1603
1604 #### `true` (default):
1605
1606 ```rust
1607 fn main() {
1608     let lorem = Lorem { foo: bar, baz: ofo };
1609 }
1610 ```
1611
1612 #### `false`:
1613
1614 ```rust
1615 fn main() {
1616     let lorem = Lorem {
1617         foo: bar,
1618         baz: ofo,
1619     };
1620 }
1621 ```
1622
1623 See also: [`indent_style`](#indent_style).
1624
1625
1626 ## `tab_spaces`
1627
1628 Number of spaces per tab
1629
1630 - **Default value**: `4`
1631 - **Possible values**: any positive integer
1632 - **Stable**: Yes
1633
1634 #### `4` (default):
1635
1636 ```rust
1637 fn lorem() {
1638     let ipsum = dolor();
1639     let sit = vec![
1640         "amet consectetur adipiscing elit amet",
1641         "consectetur adipiscing elit amet consectetur.",
1642     ];
1643 }
1644 ```
1645
1646 #### `2`:
1647
1648 ```rust
1649 fn lorem() {
1650   let ipsum = dolor();
1651   let sit = vec![
1652     "amet consectetur adipiscing elit amet",
1653     "consectetur adipiscing elit amet consectetur.",
1654   ];
1655 }
1656 ```
1657
1658 See also: [`hard_tabs`](#hard_tabs).
1659
1660
1661 ## `trailing_comma`
1662
1663 How to handle trailing commas for lists
1664
1665 - **Default value**: `"Vertical"`
1666 - **Possible values**: `"Always"`, `"Never"`, `"Vertical"`
1667 - **Stable**: No
1668
1669 #### `"Vertical"` (default):
1670
1671 ```rust
1672 fn main() {
1673     let Lorem { ipsum, dolor, sit } = amet;
1674     let Lorem {
1675         ipsum,
1676         dolor,
1677         sit,
1678         amet,
1679         consectetur,
1680         adipiscing,
1681     } = elit;
1682 }
1683 ```
1684
1685 #### `"Always"`:
1686
1687 ```rust
1688 fn main() {
1689     let Lorem { ipsum, dolor, sit, } = amet;
1690     let Lorem {
1691         ipsum,
1692         dolor,
1693         sit,
1694         amet,
1695         consectetur,
1696         adipiscing,
1697     } = elit;
1698 }
1699 ```
1700
1701 #### `"Never"`:
1702
1703 ```rust
1704 fn main() {
1705     let Lorem { ipsum, dolor, sit } = amet;
1706     let Lorem {
1707         ipsum,
1708         dolor,
1709         sit,
1710         amet,
1711         consectetur,
1712         adipiscing
1713     } = elit;
1714 }
1715 ```
1716
1717 See also: [`match_block_trailing_comma`](#match_block_trailing_comma).
1718
1719 ## `trailing_semicolon`
1720
1721 Add trailing semicolon after break, continue and return
1722
1723 - **Default value**: `true`
1724 - **Possible values**: `true`, `false`
1725 - **Stable**: No
1726
1727 #### `true` (default):
1728 ```rust
1729 fn foo() -> usize {
1730     return 0;
1731 }
1732 ```
1733
1734 #### `false`:
1735 ```rust
1736 fn foo() -> usize {
1737     return 0
1738 }
1739 ```
1740
1741 ## `type_punctuation_density`
1742
1743 Determines if `+` or `=` are wrapped in spaces in the punctuation of types
1744
1745 - **Default value**: `"Wide"`
1746 - **Possible values**: `"Compressed"`, `"Wide"`
1747 - **Stable**: No
1748
1749 #### `"Wide"` (default):
1750
1751 ```rust
1752 fn lorem<Ipsum: Dolor + Sit = Amet>() {
1753     // body
1754 }
1755 ```
1756
1757 #### `"Compressed"`:
1758
1759 ```rust
1760 fn lorem<Ipsum: Dolor+Sit=Amet>() {
1761     // body
1762 }
1763 ```
1764
1765 ## `use_field_init_shorthand`
1766
1767 Use field initialize shorthand if possible.
1768
1769 - **Default value**: `false`
1770 - **Possible values**: `true`, `false`
1771 - **Stable**: No
1772
1773 #### `false` (default):
1774
1775 ```rust
1776 struct Foo {
1777     x: u32,
1778     y: u32,
1779     z: u32,
1780 }
1781
1782 fn main() {
1783     let x = 1;
1784     let y = 2;
1785     let z = 3;
1786     let a = Foo { x: x, y: y, z: z };
1787 }
1788 ```
1789
1790 #### `true`:
1791
1792 ```rust
1793 struct Foo {
1794     x: u32,
1795     y: u32,
1796     z: u32,
1797 }
1798
1799 fn main() {
1800     let x = 1;
1801     let y = 2;
1802     let z = 3;
1803     let a = Foo { x, y, z };
1804 }
1805 ```
1806
1807 ## `use_try_shorthand`
1808
1809 Replace uses of the try! macro by the ? shorthand
1810
1811 - **Default value**: `false`
1812 - **Possible values**: `true`, `false`
1813 - **Stable**: No
1814
1815 #### `false` (default):
1816
1817 ```rust
1818 fn main() {
1819     let lorem = try!(ipsum.map(|dolor| dolor.sit()));
1820 }
1821 ```
1822
1823 #### `true`:
1824
1825 ```rust
1826 fn main() {
1827     let lorem = ipsum.map(|dolor| dolor.sit())?;
1828 }
1829 ```
1830
1831
1832 ## `wrap_comments`
1833
1834 Break comments to fit on the line
1835
1836 - **Default value**: `false`
1837 - **Possible values**: `true`, `false`
1838 - **Stable**: Yes
1839
1840 #### `false` (default):
1841
1842 ```rust
1843 // 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.
1844 ```
1845
1846 #### `true`:
1847
1848 ```rust
1849 // Lorem ipsum dolor sit amet, consectetur adipiscing elit,
1850 // sed do eiusmod tempor incididunt ut labore et dolore
1851 // magna aliqua. Ut enim ad minim veniam, quis nostrud
1852 // exercitation ullamco laboris nisi ut aliquip ex ea
1853 // commodo consequat.
1854 ```
1855
1856 ## `match_arm_blocks`
1857
1858 Wrap the body of arms in blocks when it does not fit on the same line with the pattern of arms
1859
1860 - **Default value**: `true`
1861 - **Possible values**: `true`, `false`
1862 - **Stable**: No
1863
1864 #### `true` (default):
1865
1866 ```rust
1867 fn main() {
1868     match lorem {
1869         true => {
1870             foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x)
1871         }
1872         false => println!("{}", sit),
1873     }
1874 }
1875 ```
1876
1877 #### `false`:
1878
1879 ```rust
1880 fn main() {
1881     match lorem {
1882         true =>
1883             foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x),
1884         false => println!("{}", sit),
1885     }
1886 }
1887 ```
1888
1889 See also: [`match_block_trailing_comma`](#match_block_trailing_comma).
1890
1891 ## `write_mode`
1892
1893 What Write Mode to use when none is supplied: Replace, Overwrite, Display, Diff, Coverage
1894
1895 - **Default value**: `"Overwrite"`
1896 - **Possible values**: `"Checkstyle"`, `"Coverage"`, `"Diff"`, `"Display"`, `"Overwrite"`, `"Plain"`, `"Replace"`
1897 - **Stable**: No
1898
1899 ## `blank_lines_upper_bound`
1900
1901 Maximum number of blank lines which can be put between items. If more than this number of consecutive empty
1902 lines are found, they are trimmed down to match this integer.
1903
1904 - **Default value**: `1`
1905 - **Possible values**: *unsigned integer*
1906 - **Stable**: No
1907
1908 ### Example
1909 Original Code:
1910
1911 ```rust
1912 #![rustfmt_skip]
1913
1914 fn foo() {
1915     println!("a");
1916 }
1917
1918
1919
1920 fn bar() {
1921     println!("b");
1922
1923
1924     println!("c");
1925 }
1926 ```
1927
1928 #### `1` (default):
1929 ```rust
1930 fn foo() {
1931     println!("a");
1932 }
1933
1934 fn bar() {
1935     println!("b");
1936
1937     println!("c");
1938 }
1939 ```
1940
1941 #### `2` (default):
1942 ```rust
1943 fn foo() {
1944     println!("a");
1945 }
1946
1947
1948 fn bar() {
1949     println!("b");
1950
1951
1952     println!("c");
1953 }
1954 ```
1955
1956 See also: [`blank_lines_lower_bound`](#blank_lines_lower_bound)
1957
1958 ## `blank_lines_lower_bound`
1959
1960 Minimum number of blank lines which must be put between items. If two items have fewer blank lines between
1961 them, additional blank lines are inserted.
1962
1963 - **Default value**: `0`
1964 - **Possible values**: *unsigned integer*
1965 - **Stable**: No
1966
1967 ### Example
1968 Original Code (rustfmt will not change it with the default value of `0`):
1969
1970 ```rust
1971 #![rustfmt_skip]
1972
1973 fn foo() {
1974     println!("a");
1975 }
1976 fn bar() {
1977     println!("b");
1978     println!("c");
1979 }
1980 ```
1981
1982 #### `1`
1983 ```rust
1984 fn foo() {
1985
1986     println!("a");
1987 }
1988
1989 fn bar() {
1990
1991     println!("b");
1992
1993     println!("c");
1994 }
1995 ```
1996
1997 ## `remove_blank_lines_at_start_or_end_of_block`
1998
1999 Remove blank lines at the start or the end of a block.
2000
2001 - **Default value**: `true`
2002 - **Possible values**: `true`, `false`
2003 - **Stable**: No
2004
2005 #### `true`
2006
2007 ```rust
2008 fn foo() {
2009     let msg = {
2010         let mut str = String::new();
2011         str.push_str("hello, ");
2012         str.push_str("world!");
2013         str
2014     };
2015     println!("{}", msg);
2016 }
2017 ```
2018
2019 #### `false`
2020
2021 ```rust
2022 fn foo() {
2023
2024     let msg = {
2025
2026         let mut str = String::new();
2027         str.push_str("hello, ");
2028         str.push_str("world!");
2029         str
2030
2031     };
2032     println!("{}", msg);
2033
2034 }
2035 ```
2036
2037 ## `required_version`
2038
2039 Require a specific version of rustfmt. If you want to make sure that the
2040 specific version of rustfmt is used in your CI, use this option.
2041
2042 - **Default value**: `CARGO_PKG_VERSION`
2043 - **Possible values**: any published version (e.g. `"0.3.8"`)
2044 - **Stable**: No
2045
2046 ## `hide_parse_errors`
2047
2048 Do not show parse errors if the parser failed to parse files.
2049
2050 - **Default value**: `false`
2051 - **Possible values**: `true`, `false`
2052 - **Stable**: No
2053
2054 ## `color`
2055
2056 Whether to use colored output or not.
2057
2058 - **Default value**: `"Auto"`
2059 - **Possible values**: "Auto", "Always", "Never"
2060 - **Stable**: No
2061
2062 ## `unstable_features`
2063
2064 Enable unstable features on stable channel.
2065
2066 - **Default value**: `false`
2067 - **Possible values**: `true`, `false`
2068 - **Stable**: Yes
2069
2070 ## `license_template_path`
2071
2072 Check whether beginnings of files match a license template.
2073
2074 - **Default value**: `""``
2075 - **Possible values**: path to a license template file
2076 - **Stable**: No
2077
2078 A license template is a plain text file which is matched literally against the
2079 beginning of each source file, except for `{}`-delimited blocks, which are
2080 matched as regular expressions. The following license template therefore
2081 matches strings like `// Copyright 2017 The Rust Project Developers.`, `//
2082 Copyright 2018 The Rust Project Developers.`, etc.:
2083
2084 ```
2085 // Copyright {\d+} The Rust Project Developers.
2086 ```
2087
2088 `\{`, `\}` and `\\` match literal braces / backslashes.
2089
2090 ## `ignore`
2091
2092 Skip formatting the specified files and directories.
2093
2094 - **Default value**: format every files
2095 - **Possible values**: See an example below
2096 - **Stable**: No
2097
2098 ### Example
2099
2100 If you want to ignore specific files, put the following to your config file:
2101
2102 ```toml
2103 ignore = [
2104     "src/types.rs",
2105     "src/foo/bar.rs",
2106 ]
2107 ```
2108
2109 If you want to ignore every file under `examples/`, put the following to your config file:
2110
2111 ```toml
2112 ignore [
2113     "examples",
2114 ]
2115 ```