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 shorter than `array_width`:
```rust
-let lorem =
- vec!["ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit"];
+let lorem = vec!["ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit"];
```
#### Lines longer than `array_width`:
See [`array_layout`](#array_layout).
+## `attributes_on_same_line_as_field`
+
+Try to put attributes on the same line as fields
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+
+#### `true`
+
+```rust
+struct Lorem {
+ #[serde(rename = "Ipsum")] ipsum: usize,
+ #[serde(rename = "Dolor")] dolor: usize,
+ #[serde(rename = "Amet")] amet: usize,
+}
+```
+
+#### `false`
+
+```rust
+struct Lorem {
+ #[serde(rename = "Ipsum")]
+ ipsum: usize,
+ #[serde(rename = "Dolor")]
+ dolor: usize,
+ #[serde(rename = "Amet")]
+ amet: usize,
+}
+```
+
+## `attributes_on_same_line_as_variant`
+
+Try to put attributes on the same line as variants
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+
+#### `true`
+
+```rust
+enum Lorem {
+ #[serde(skip_serializing)] Ipsum,
+ #[serde(skip_serializing)] Dolor,
+ #[serde(skip_serializing)] Amet,
+}
+```
+
+#### `false`
+
+```rust
+enum Lorem {
+ #[serde(skip_serializing)]
+ Ipsum,
+ #[serde(skip_serializing)]
+ Dolor,
+ #[serde(skip_serializing)]
+ Amet,
+}
+```
+
## `chain_indent`
Indentation of chain
});
```
+**Note**: This option only takes effect when `fn_call_style` is set to `"Visual"`.
+
## `combine_control_expr`
Combine control expressions with function calls.
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: Consectetur,
- adipiscing: Adipiscing, elit: Elit);
+ 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: Consectetur,
- adipiscing: Adipiscing, elit: Elit) {
+ 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: Consectetur,
- adipiscing: Adipiscing, elit: Elit);
-
- fn lorem(ipsum: Ipsum,
- dolor: Dolor,
- sit: Sit,
- amet: Amet,
- consectetur: onsectetur,
- adipiscing: Adipiscing,
- elit: Elit) {
+ 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,
+ adipiscing: Adipiscing,
+ elit: Elit,
+ ) {
// body
}
}
// body
}
- fn lorem(ipsum: Ipsum,
- dolor: Dolor,
- sit: Sit,
- amet: Amet,
- consectetur: onsectetur,
- adipiscing: Adipiscing,
- elit: Elit);
-
- fn lorem(ipsum: Ipsum,
- dolor: Dolor,
- sit: Sit,
- amet: Amet,
- consectetur: onsectetur,
- adipiscing: Adipiscing,
- elit: Elit) {
+ fn lorem(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ consectetur: onsectetur,
+ adipiscing: Adipiscing,
+ elit: Elit,
+ );
+
+ fn lorem(
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+ consectetur: onsectetur,
+ adipiscing: Adipiscing,
+ elit: Elit,
+ ) {
// body
}
}
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`:
ipsum: Ipsum,
dolor: Dolor,
sit: Sit,
- amet: Amet)
- -> DolorSitAmetConsecteturAdipiscingElitLoremIpsumDolorSitAmetConsecteturAdipiscingElit {
+ amet: Amet,
+) -> DolorSitAmetConsecteturAdipiscingElitLoremIpsumDolorSitAmetConsecteturAdipiscingElit {
// body
}
```
```rust
fn lorem
- (ipsum: Ipsum,
- dolor: Dolor,
- sit: Sit,
- amet: Amet)
- -> DolorSitAmetConsecteturAdipiscingElitLoremIpsumDolorSitAmetConsecteturAdipiscingElit {
+ (
+ ipsum: Ipsum,
+ dolor: Dolor,
+ sit: Sit,
+ amet: Amet,
+) -> DolorSitAmetConsecteturAdipiscingElitLoremIpsumDolorSitAmetConsecteturAdipiscingElit {
// body
}
```
}
fn lorem<T>(ipsum: T)
- where T: Add + Sub + Mul + Div
+where
+ T: Add + Sub + Mul + Div,
{
// body
}
}
fn lorem<T>(ipsum: T)
- where T: Add + Sub + Mul + Div {
+where
+ T: Add + Sub + Mul + Div, {
// body
}
```
}
fn lorem<T>(ipsum: T)
- where T: Add + Sub + Mul + Div
+where
+ T: Add + Sub + Mul + Div,
{
// body
}
Indentation for function calls, etc.
-- **Default value**: `"Visual"`
+- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
#### `"Block"`:
```
+**Note**: This option only takes effect when `fn_call_style` is set to `"Visual"`.
+
## `fn_single_line`
Put single-expression functions on a single line
Indentation of generics
-- **Default value**: `"Visual"`
+- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
#### `"Block"`:
Adipiscing: Eq = usize,
Consectetur: Eq = usize,
Elit: Eq = usize
->(ipsum: Ipsum,
+>(
+ ipsum: Ipsum,
dolor: Dolor,
sit: Sit,
amet: Amet,
adipiscing: Adipiscing,
consectetur: Consectetur,
- elit: Elit)
- -> T {
+ elit: Elit,
+) -> T {
// body
}
```
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: [`indent_match_arms`](#indent_match_arms), [`trailing_comma`](#trailing_comma), [`wrap_match_arms`](#wrap_match_arms).
+## `match_pattern_separator_break_point`
+
+Put a match sub-patterns' separator (`|`) in front or back.
+
+- **Default value**: `"Back"`
+- **Possible values**: `"Back"`, `"Front"`
+
+#### `"Back"`:
+
+```rust
+match m {
+ Variant::Tag |
+ Variant::Tag2 |
+ Variant::Tag3 |
+ Variant::Tag4 |
+ Variant::Tag5 |
+ Variant::Tag6 => {}
+}
+```
+
+#### `Front`:
+
+```rust
+match m {
+ Variant::Tag
+ | Variant::Tag2
+ | Variant::Tag3
+ | Variant::Tag4
+ | Variant::Tag5
+ | Variant::Tag6 => {}
+}
+```
+
## `max_width`
Maximum width of each line
See also [`error_on_line_overflow`](#error_on_line_overflow).
+## `merge_derives`
+
+Merge multiple derives into a single one.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+
+#### `true`:
+
+```rust
+#[derive(Eq, PartialEq, Debug, Copy, Clone)]
+pub enum Foo {}
+```
+
+#### `false`:
+
+```rust
+#[derive(Eq, PartialEq)]
+#[derive(Debug)]
+#[derive(Copy, Clone)]
+pub enum Foo {}
+```
+
+## `multiline_closure_forces_block`
+
+Force multiline closure bodies to be wrapped in a block
+
+- **Default value**: `false`
+- **Possible values**: `false`, `true`
+
+#### `true`:
+
+```rust
+
+result.and_then(|maybe_value| {
+ match maybe_value {
+ None => ...,
+ Some(value) => ...,
+ }
+})
+```
+
+#### `false`:
+
+```rust
+result.and_then(|maybe_value| match maybe_value {
+ None => ...,
+ Some(value) => ...,
+})
+```
+
+## `multiline_match_arm_forces_block`
+
+Force multiline match arm bodies to be wrapped in a block
+
+- **Default value**: `false`
+- **Possible values**: `false`, `true`
+
+#### `false`:
+
+```rust
+match lorem {
+ None => if ipsum {
+ println!("Hello World");
+ },
+ Some(dolor) => ...,
+}
+```
+
+#### `true`:
+
+```rust
+match lorem {
+ None => {
+ if ipsum {
+ println!("Hello World");
+ }
+ }
+ Some(dolor) => ...,
+}
+```
+
## `newline_style`
Unix or Windows line endings
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
Leave a space before the colon in a struct literal field
-- **Default value**: `true`
+- **Default value**: `false`
- **Possible values**: `true`, `false`
#### `false`:
```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
## `where_density`
-Density of a where clause
+Density of a where clause.
- **Default value**: `"CompressedIfEmpty"`
- **Possible values**: `"Compressed"`, `"CompressedIfEmpty"`, `"Tall"`, `"Vertical"`
```rust
trait Lorem {
- fn ipsum<Dolor>(dolor: Dolor) -> Sit where Dolor: Eq;
+ fn ipsum<Dolor>(dolor: Dolor) -> Sit
+ where Dolor: Eq;
- fn ipsum<Dolor>(dolor: Dolor) -> Sit where Dolor: Eq {
+ fn ipsum<Dolor>(dolor: Dolor) -> Sit
+ where Dolor: Eq {
// body
}
}
```rust
trait Lorem {
- fn ipsum<Dolor>(dolor: Dolor) -> Sit where Dolor: Eq;
+ fn ipsum<Dolor>(dolor: Dolor) -> Sit
+ where Dolor: Eq;
fn ipsum<Dolor>(dolor: Dolor) -> Sit
- where Dolor: Eq
+ where
+ Dolor: Eq,
{
// body
}
```rust
trait Lorem {
fn ipsum<Dolor>(dolor: Dolor) -> Sit
- where Dolor: Eq;
+ where
+ Dolor: Eq;
fn ipsum<Dolor>(dolor: Dolor) -> Sit
- where Dolor: Eq
+ where
+ Dolor: Eq,
{
// body
}
}
```
+**Note**: This option only takes effect when `where_style` is set to `"Legacy"`.
+
See also: [`where_density`](#where_density), [`where_pred_indent`](#where_pred_indent), [`where_style`](#where_style).
## `where_pred_indent`
}
```
+**Note**: This option only takes effect when `where_style` is set to `"Legacy"`.
+
See also: [`where_density`](#where_density), [`where_layout`](#where_layout), [`where_style`](#where_style).
## `where_style`
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"`
projects / rust.git / blobdiff