Below you find a detailed visual guide on all the supported configuration options of rustfmt:
+## `array_horizontal_layout_threshold`
+
+How many elements array must have before rustfmt uses horizontal layout.
+Use this option to prevent a huge array from being vertically formatted.
+
+- **Default value**: `0`
+- **Possible values**: any positive integer
+
+**Note:** A value of `0` results in [`array_layout`](#array_layout) being applied regardless of a line's width.
+
+#### `0`:
+
+```rust
+// Each element will be placed on its own line.
+let a = vec![
+ 0,
+ 1,
+ 2,
+ 3,
+ 4,
+ ...
+ 999,
+ 1000,
+];
+```
+
+#### `1000`:
+```rust
+// Each element will be placed on the same line as much as possible.
+let a = vec![0, 1, 2, 3, 4, ...
+ ..., 999, 1000];
+```
+
## `array_layout`
Indent on arrays
-- **Default value**: `"Visual"`
+- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
#### `"Block"`:
#### Lines longer than `chain_one_line_max`:
See [`chain_indent`](#chain_indent).
+## `chain_split_single_child`
+
+Split a chain with a single child if its length exceeds [`chain_one_line_max`](#chain_one_line_max).
+
+- **Default value**: `false`
+- **Possible values**: `false`, `true`
+
+#### `false`
+
+```rust
+let files = fs::read_dir("tests/coverage/source").expect("Couldn't read source dir");
+```
+
+#### `true`
+
+```rust
+let files = fs::read_dir("tests/coverage/source")
+ .expect("Couldn't read source dir");
+```
+
+See also [`chain_one_line_max`](#chain_one_line_max).
+
## `closure_block_indent_threshold`
How many lines a closure must have before it is block indented. -1 means never use block indent.
});
```
+## `combine_control_expr`
+
+Combine control expressions with function calls.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+
+#### `true`
+
+```rust
+fn example() {
+ // If
+ foo!(if x {
+ foo();
+ } else {
+ bar();
+ });
+
+ // IfLet
+ foo!(if let Some(..) = x {
+ foo();
+ } else {
+ bar();
+ });
+
+ // While
+ foo!(while x {
+ foo();
+ bar();
+ });
+
+ // WhileLet
+ foo!(while let Some(..) = x {
+ foo();
+ bar();
+ });
+
+ // ForLoop
+ foo!(for x in y {
+ foo();
+ bar();
+ });
+
+ // Loop
+ foo!(loop {
+ foo();
+ bar();
+ });
+}
+```
+
+#### `false`
+
+```rust
+```
+
## `comment_width`
Maximum length of comments. No effect unless`wrap_comments = true`.
let (lorem, ipsum, ..) = (1, 2, 3, 4);
```
+## `control_style`
+
+Indent style for control flow statements
+
+- **Default value**: `"Rfc"`
+- **Possible values**: `"Rfc"`, `"Legacy"`
+
+#### `"Rfc"`:
+
+```rust
+if lorem_ipsum &&
+ dolor_sit &&
+ amet_consectetur
+{
+ // ...
+}
+```
+
+#### `"Legacy"`:
+
+```rust
+if lorem_ipsum &&
+ dolor_sit &&
+ amet_consectetur {
+ // ...
+}
+```
+
+See also: [`control_brace_style`](#control_brace_style).
+
## `control_brace_style`
Brace style for control flow constructs
// body
}
- fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: onsectetur,
+ fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
adipiscing: Adipiscing, elit: Elit);
- fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: onsectetur,
+ fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
adipiscing: Adipiscing, elit: Elit) {
// body
}
// body
}
- fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: onsectetur,
+ fn lorem(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet, consectetur: Consectetur,
adipiscing: Adipiscing, elit: Elit);
fn lorem(ipsum: Ipsum,
Layout of function arguments and tuple structs
-- **Default value**: `"Visual"`
+- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
#### `"Block"`:
If function argument parenthesis goes on a newline
-- **Default value**: `true`
+- **Default value**: `false`
- **Possible values**: `true`, `false`
#### `false`:
Indentation for function calls, etc.
-- **Default value**: `"Visual"`
+- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
#### `"Block"`:
Indentation of generics
-- **Default value**: `"Visual"`
+- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
#### `"Block"`:
See also: [`match_block_trailing_comma`](#match_block_trailing_comma), [`wrap_match_arms`](#wrap_match_arms).
+## `imports_indent`
+
+Indent style of imports
+
+- **Default Value**: `"Visual"`
+- **Possible values**: `"Block"`, `"Visual"`
+
+#### `"Block"`
+
+```rust
+use foo::{
+ xxx,
+ yyy,
+ zzz,
+};
+```
+
+#### `"Visual"`
+
+```rust
+use foo::{xxx,
+ yyy,
+ zzz};
+```
+
+See also: [`imports_layout`](#imports_layout).
+
+## `imports_layout`
+
+Item layout inside a imports block
+
+- **Default value**: "Mixed"
+- **Possible values**: "Horizontal", "HorizontalVertical", "Mixed", "Vertical"
+
+#### `"Mixed"`
+
+```rust
+use foo::{xxx, yyy, zzz};
+
+use foo::{aaa, bbb, ccc,
+ ddd, eee, fff};
+```
+
+#### `"Horizontal"`
+
+**Note**: This option forces to put everything on one line and may exceeds `max_width`.
+
+```rust
+use foo::{xxx, yyy, zzz};
+
+use foo::{aaa, bbb, ccc, ddd, eee, fff};
+```
+
+#### `"HorizontalVertical"`
+
+```rust
+use foo::{xxx, yyy, zzz};
+
+use foo::{aaa,
+ bbb,
+ ccc,
+ ddd,
+ eee,
+ fff};
+```
+
+#### `"Vertical"`
+
+```rust
+use foo::{xxx,
+ yyy,
+ zzz};
+
+use foo::{aaa,
+ bbb,
+ ccc,
+ ddd,
+ eee,
+ fff};
+```
+
## `item_brace_style`
Brace style for structs and enums
See also: [`space_before_bound`](#space_before_bound).
+## `struct_field_align_threshold`
+
+The maximum diff of width between struct fields to be aligned with each other.
+
+- **Default value** : 0
+- **Possible values**: any positive integer
+
+#### `0`:
+
+```rust
+struct Foo {
+ x: u32,
+ yy: u32,
+ zzz: u32,
+}
+```
+
+#### `20`:
+
+```rust
+struct Foo {
+ x: u32,
+ yy: u32,
+ zzz: u32,
+}
+```
+
+## `space_after_struct_lit_field_colon`
+
+Leave a space after the colon in a struct literal field
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+
+#### `false`:
+
+```rust
+let lorem = Lorem {
+ ipsum:dolor,
+ sit:amet,
+};
+```
+
+#### `true`:
+
+```rust
+let lorem = Lorem {
+ ipsum: dolor,
+ sit: amet,
+};
+```
+
+See also: [`space_before_struct_lit_field_colon`](#space_before_struct_lit_field_colon).
+
## `space_after_type_annotation_colon`
Leave a space after the colon in a type annotation
See also: [`space_after_bound_colon`](#space_after_bound_colon).
+## `space_before_struct_lit_field_colon`
+
+Leave a space before the colon in a struct literal field
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+
+#### `false`:
+
+```rust
+let lorem = Lorem {
+ ipsum: dolor,
+ sit: amet,
+};
+```
+
+#### `true`:
+
+```rust
+let lorem = Lorem {
+ ipsum : dolor,
+ sit : amet,
+};
+```
+
+See also: [`space_after_struct_lit_field_colon`](#space_after_struct_lit_field_colon).
+
## `space_before_type_annotation`
Leave a space before the colon in a type annotation
```rust
let lorem = Lorem { ipsum: dolor,
- sit: amet, };
+ sit: amet, };
```
See also: [`struct_lit_multiline_style`](#struct_lit_multiline_style), [`struct_lit_style`](#struct_lit_style).
See also: [`match_block_trailing_comma`](#match_block_trailing_comma).
+## `trailing_semicolon`
+
+Add trailing semicolon after break, continue and return
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+
+#### `true`:
+```rust
+fn foo() -> usize {
+ return 0;
+}
+```
+
+#### `false`:
+```rust
+fn foo() -> usize {
+ return 0
+}
+```
+
## `type_punctuation_density`
Determines if `+` or `=` are wrapped in spaces in the punctuation of types
Overall strategy for where clauses
-- **Default value**: `"Default"`
-- **Possible values**: `"Default"`, `"Rfc"`
+- **Default value**: `"Rfc"`
+- **Possible values**: `"Rfc"`, `"Legacy"`
-#### `"Default"`:
+#### `"Rfc"`:
```rust
fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
- where Ipsum: Eq,
- Dolor: Eq,
- Sit: Eq,
- Amet: Eq
+where
+ Ipsum: Eq,
+ Dolor: Eq,
+ Sit: Eq,
+ Amet: Eq,
{
// body
}
```
-#### `"Rfc"`:
+#### `"Legacy"`:
```rust
fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
-where
- Ipsum: Eq,
- Dolor: Eq,
- Sit: Eq,
- Amet: Eq,
+ where Ipsum: Eq,
+ Dolor: Eq,
+ Sit: Eq,
+ Amet: Eq
{
// body
}
## `wrap_match_arms`
-Wrap multiline match arms in blocks
+Wrap the body of arms in blocks when it does not fit on the same line with the pattern of arms
- **Default value**: `true`
- **Possible values**: `true`, `false`
```rust
match lorem {
- true => {
- let ipsum = dolor;
- println!("{}", ipsum);
- }
- false => {
- println!("{}", sit)
- }
+ true =>
+ foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x),
+ false => println!("{}", sit),
}
```
```rust
match lorem {
true => {
- let ipsum = dolor;
- println!("{}", ipsum);
+ foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x)
}
false => println!("{}", sit),
}
What Write Mode to use when none is supplied: Replace, Overwrite, Display, Diff, Coverage
-- **Default value**: `"Replace"`
+- **Default value**: `"Overwrite"`
- **Possible values**: `"Checkstyle"`, `"Coverage"`, `"Diff"`, `"Display"`, `"Overwrite"`, `"Plain"`, `"Replace"`