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` (default):
+
+```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"`:
+#### `"Block"` (default):
```rust
let lorem = vec![
#### 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` (default):
+
+```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` (default):
+
+```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,
+}
+```
+
+## `binop_separator`
+
+Where to put a binary operator when a binary expression goes multiline.
+
+- **Default value**: `"Front"`
+- **Possible values**: `"Front"`, `"Back"`
+
+#### `"Front"` (default):
+
+```rust
+let or = foo
+ || bar
+ || foobar;
+
+let sum = 1234
+ + 5678
+ + 910;
+
+let range = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+ ..bbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
+```
+
+#### `"Back"`:
+
+```rust
+let or = foo ||
+ bar ||
+ foobar;
+
+let sum = 1234 +
+ 5678 +
+ 910;
+
+let range = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
+```
+
## `chain_indent`
Indentation of chain
- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
-#### `"Block"`:
+#### `"Block"` (default):
```rust
let lorem = ipsum
#### 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` (default):
+
+```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.
});
```
+**Note**: This option only takes effect when `fn_call_style` is set to `"Visual"`.
+
+## `combine_control_expr`
+
+Combine control expressions with function calls.
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+
+#### `true` (default):
+
+```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`.
See also [`wrap_comments`](#wrap_comments).
-## `condense_wildcard_suffices`
+## `condense_wildcard_suffixes`
Replace strings of _ wildcards by a single .. in tuple patterns
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
let (lorem, ipsum, _, _) = (1, 2, 3, 4);
let (lorem, ipsum, ..) = (1, 2, 3, 4);
```
+## `control_style`
+
+Indent style for control flow statements
+
+- **Default value**: `"Rfc"`
+- **Possible values**: `"Rfc"`, `"Legacy"`
+
+#### `"Rfc"` (default):
+
+```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
- **Default value**: `"AlwaysSameLine"`
- **Possible values**: `"AlwaysNextLine"`, `"AlwaysSameLine"`, `"ClosingNextLine"`
-#### `"AlwaysNextLine"`:
+#### `"AlwaysSameLine"` (default):
```rust
-if lorem
-{
+if lorem {
println!("ipsum!");
-}
-else
-{
+} else {
println!("dolor!");
}
```
-#### `"AlwaysSameLine"`:
+#### `"AlwaysNextLine"`:
```rust
-if lorem {
+if lorem
+{
println!("ipsum!");
-} else {
+}
+else
+{
println!("dolor!");
}
```
- **Default value**: `"Tall"`
- **Possible values**: `"Compressed"`, `"CompressedIfEmpty"`, `"Tall"`, `"Vertical"`
-#### `"Compressed"`:
+#### `"Tall"` (default):
```rust
trait Lorem {
// 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
}
}
```
-#### `"CompressedIfEmpty"`:
+#### `"Compressed"`:
```rust
trait Lorem {
// 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: 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,
+ ) {
// body
}
}
```
-#### `"Tall"`:
+#### `"CompressedIfEmpty"`:
```rust
trait Lorem {
// 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: Consectetur,
+ 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"`:
+#### `"Block"` (default):
```rust
fn lorem() {}
If function argument parenthesis goes on a newline
-- **Default value**: `true`
+- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
fn lorem(
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
}
```
- **Default value**: `"SameLineWhere"`
- **Possible values**: `"AlwaysNextLine"`, `"PreferSameLine"`, `"SameLineWhere"`
-#### `"AlwaysNextLine"`:
+#### `"SameLineWhere"` (default):
```rust
-fn lorem()
-{
+fn lorem() {
// body
}
-fn lorem(ipsum: usize)
-{
+fn lorem(ipsum: usize) {
// body
}
fn lorem<T>(ipsum: T)
- where T: Add + Sub + Mul + Div
+where
+ T: Add + Sub + Mul + Div,
{
// body
}
```
-#### `"PreferSameLine"`:
+#### `"AlwaysNextLine"`:
```rust
-fn lorem() {
+fn lorem()
+{
// body
}
-fn lorem(ipsum: usize) {
+fn lorem(ipsum: usize)
+{
// body
}
fn lorem<T>(ipsum: T)
- where T: Add + Sub + Mul + Div {
+where
+ T: Add + Sub + Mul + Div,
+{
// body
}
```
-#### `"SameLineWhere"`:
+#### `"PreferSameLine"`:
```rust
fn lorem() {
}
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"`:
+#### `"Block"` (default):
```rust
lorem(
- **Default value**: `true`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `true` (default):
```rust
-fn lorem() {
-}
+fn lorem() {}
```
-#### `true`:
+#### `false`:
```rust
-fn lorem() {}
+fn lorem() {
+}
```
See also [`control_brace_style`](#control_brace_style).
- **Default value**: `"WithArgs"`
- **Possible values**: `"WithArgs"`, `"WithWhereClause"`
-#### `"WithArgs"`:
+#### `"WithArgs"` (default):
```rust
fn lorem(ipsum: Ipsum,
```
+**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
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
fn lorem() -> usize {
**Note:** Non-"C" ABIs are always printed. If `false` then "C" is removed.
-#### `false`:
+#### `true` (default):
```rust
-extern {
+extern "C" {
pub static lorem: c_int;
}
```
-#### `true`:
+#### `false`:
```rust
-extern "C" {
+extern {
pub static lorem: c_int;
}
```
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
let lorem = "ipsum dolor sit amet consectetur adipiscing elit lorem ipsum dolor sit";
Indentation of generics
-- **Default value**: `"Visual"`
+- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
-#### `"Block"`:
+#### `"Block"` (default):
```rust
fn lorem<
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
}
```
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
fn lorem() -> usize {
- **Default value**: `true`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `true` (default):
```rust
-impl Lorem {
-}
+impl Lorem {}
```
-#### `true`:
+#### `false`:
```rust
-impl Lorem {}
+impl Lorem {
+}
```
See also [`item_brace_style`](#item_brace_style).
- **Default value**: `true`
- **Possible values**: `true`, `false`
+#### `true` (default):
+
+```rust
+match lorem {
+ Lorem::Ipsum => (),
+ Lorem::Dolor => (),
+ Lorem::Sit => (),
+ Lorem::Amet => (),
+}
+```
+
#### `false`:
```rust
}
```
-#### `true`:
+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"`
+
+#### `"Visual"` (default):
```rust
-match lorem {
- Lorem::Ipsum => (),
- Lorem::Dolor => (),
- Lorem::Sit => (),
- Lorem::Amet => (),
-}
+use foo::{xxx,
+ yyy,
+ zzz};
```
-See also: [`match_block_trailing_comma`](#match_block_trailing_comma), [`wrap_match_arms`](#wrap_match_arms).
+#### `"Block"`:
+
+```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"` (default):
+
+```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`
- **Default value**: `"SameLineWhere"`
- **Possible values**: `"AlwaysNextLine"`, `"PreferSameLine"`, `"SameLineWhere"`
-#### `"AlwaysNextLine"`:
+#### `"SameLineWhere"` (default):
```rust
-struct Lorem
-{
+struct Lorem {
ipsum: bool,
}
}
```
-#### `"PreferSameLine"`:
+#### `"AlwaysNextLine"`:
```rust
-struct Lorem {
+struct Lorem
+{
ipsum: bool,
}
struct Dolor<T>
- where T: Eq {
+ where T: Eq
+{
sit: T,
}
```
-#### `"SameLineWhere"`:
+#### `"PreferSameLine"`:
```rust
struct Lorem {
}
struct Dolor<T>
- where T: Eq
-{
+ where T: Eq {
sit: T,
}
```
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
match lorem {
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"` (default):
+
+```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` (default):
+
+```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`
+
+#### `false` (default):
+
+```rust
+result.and_then(|maybe_value| match maybe_value {
+ None => ...,
+ Some(value) => ...,
+})
+```
+
+#### `true`:
+
+```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` (default):
+
+```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
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
// Lorem ipsum:
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
use super::{lorem, ipsum, dolor, sit};
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
+
+```rust
+use lorem;
+use ipsum;
+use dolor;
+use sit;
+```
+
+#### `true`:
+
+```rust
+use dolor;
+use ipsum;
+use lorem;
+use sit;
+```
+
+See also [`reorder_imported_names`](#reorder_imported_names), [`reorder_imports_in_group`](#reorder_imports_in_group).
+
+## `reorder_imports_in_group`
+
+Reorder import statements in group
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+
+**Note:** This option takes effect only when [`reorder_imports`](#reorder_imports) is set to `true`.
+
+#### `false` (default):
```rust
+use std::mem;
+use std::io;
+
use lorem;
use ipsum;
use dolor;
#### `true`:
```rust
+use std::io;
+use std::mem;
+
use dolor;
use ipsum;
use lorem;
use sit;
```
-See also [`reorder_imported_names`](#reorder_imported_names).
+See also [`reorder_imports`](#reorder_imports).
## `single_line_if_else_max_width`
- **Default value**: `true`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `true` (default):
```rust
-fn lorem<T:Eq>(t: T) {
+fn lorem<T: Eq>(t: T) {
// body
}
```
-#### `true`:
+#### `false`:
```rust
-fn lorem<T: Eq>(t: T) {
+fn lorem<T:Eq>(t: T) {
// body
}
```
See also: [`space_before_bound`](#space_before_bound).
-## `space_after_type_annotation_colon`
+## `struct_field_align_threshold`
-Leave a space after the colon in a type annotation
+The maximum diff of width between struct fields to be aligned with each other.
+
+- **Default value** : 0
+- **Possible values**: any positive integer
+
+#### `0` (default):
+
+```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`
+#### `true` (default):
+
+```rust
+let lorem = Lorem {
+ ipsum: dolor,
+ sit: amet,
+};
+```
+
#### `false`:
```rust
-fn lorem<T: Eq>(t:T) {
- let ipsum:Dolor = sit;
-}
+let lorem = Lorem {
+ ipsum:dolor,
+ sit:amet,
+};
```
-#### `true`:
+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
+
+- **Default value**: `true`
+- **Possible values**: `true`, `false`
+
+#### `true` (default):
```rust
fn lorem<T: Eq>(t: T) {
}
```
+#### `false`:
+
+```rust
+fn lorem<T: Eq>(t:T) {
+ let ipsum:Dolor = sit;
+}
+```
+
See also: [`space_before_type_annotation`](#space_before_type_annotation).
## `space_before_bound`
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
fn lorem<T: Eq>(t: T) {
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` (default):
+
+```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
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
fn lorem<T: Eq>(t: T) {
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
let lorem = 0..10;
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
fn lorem<T: Eq>(t: T) {
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
fn lorem<T: Eq>(t: T) {
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
let lorem: [usize; 2] = [ipsum, dolor];
- **Default value**: `"PreferSingle"`
- **Possible values**: `"ForceMulti"`, `"PreferSingle"`
+#### `"PreferSingle"` (default):
+
+```rust
+let lorem = Lorem { ipsum: dolor, sit: amet };
+```
+
#### `"ForceMulti"`:
```rust
};
```
-#### `"PreferSingle"`:
-
-```rust
-let lorem = Lorem { ipsum: dolor, sit: amet };
-```
-
See also: [`struct_lit_style`](#struct_lit_style), [`struct_lit_width`](#struct_lit_width).
## `struct_lit_style`
- **Default value**: `"Block"`
- **Possible values**: `"Block"`, `"Visual"`
-#### `"Block"`:
+#### `"Block"` (default):
```rust
let lorem = Lorem {
```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).
- **Default value**: `4`
- **Possible values**: any positive integer
-#### `2`:
+#### `4` (default):
```rust
fn lorem() {
- let ipsum = dolor();
- let sit = vec![
- "amet consectetur adipiscing elit."
- ];
+ let ipsum = dolor();
+ let sit = vec![
+ "amet consectetur adipiscing elit."
+ ];
}
```
-#### `4`:
+#### `2`:
```rust
fn lorem() {
- let ipsum = dolor();
- let sit = vec![
- "amet consectetur adipiscing elit."
- ];
+ let ipsum = dolor();
+ let sit = vec![
+ "amet consectetur adipiscing elit."
+ ];
}
```
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
lorem
- **Default value**: `"Vertical"`
- **Possible values**: `"Always"`, `"Never"`, `"Vertical"`
-#### `"Always"`:
+#### `"Vertical"` (default):
```rust
-let Lorem { ipsum, dolor, sit, } = amet;
+let Lorem { ipsum, dolor, sit } = amet;
let Lorem {
ipsum,
dolor,
} = elit;
```
-#### `"Never"`:
+#### `"Always"`:
```rust
-let Lorem { ipsum, dolor, sit } = amet;
+let Lorem { ipsum, dolor, sit, } = amet;
let Lorem {
ipsum,
dolor,
sit,
amet,
consectetur,
- adipiscing
+ adipiscing,
} = elit;
```
-#### `"Vertical"`:
+#### `"Never"`:
```rust
let Lorem { ipsum, dolor, sit } = amet;
sit,
amet,
consectetur,
- adipiscing,
+ adipiscing
} = elit;
```
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` (default):
+```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
- **Default value**: `"Wide"`
- **Possible values**: `"Compressed"`, `"Wide"`
-#### `"Compressed"`:
+#### `"Wide"` (default):
```rust
-fn lorem<Ipsum: Dolor+Sit=Amet>() {
+fn lorem<Ipsum: Dolor + Sit = Amet>() {
// body
}
```
-#### `"Wide"`:
+#### `"Compressed"`:
```rust
-fn lorem<Ipsum: Dolor + Sit = Amet>() {
+fn lorem<Ipsum: Dolor+Sit=Amet>() {
// body
}
```
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
let lorem = try!(ipsum.map(|dolor|dolor.sit()));
## `where_density`
-Density of a where clause
+Density of a where clause.
- **Default value**: `"CompressedIfEmpty"`
- **Possible values**: `"Compressed"`, `"CompressedIfEmpty"`, `"Tall"`, `"Vertical"`
-#### `"Compressed"`:
+#### `"CompressedIfEmpty"` (default):
```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
}
}
```
-#### `"CompressedIfEmpty"`:
+#### `"Compressed"`:
```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
}
- **Default value**: `"Vertical"`
- **Possible values**: `"Horizontal"`, `"HorizontalVertical"`, `"Mixed"`, `"Vertical"`
-#### `"Horizontal"`:
+#### `"Vertical"` (default):
```rust
fn lorem<Ipsum, Dolor>(ipsum: Ipsum, dolor: Dolor)
- where Ipsum: IpsumDolorSitAmet, Dolor: DolorSitAmetConsectetur
+ where Ipsum: IpsumDolorSitAmet,
+ Dolor: DolorSitAmetConsectetur
{
// body
}
fn lorem<Ipsum, Dolor, Sit, Amet>(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet)
- where Ipsum: IpsumDolorSitAmet, Dolor: DolorSitAmetConsectetur, Sit: SitAmetConsecteturAdipiscing, Amet: AmetConsecteturAdipiscingElit
+ where Ipsum: IpsumDolorSitAmet,
+ Dolor: DolorSitAmetConsectetur,
+ Sit: SitAmetConsecteturAdipiscing,
+ Amet: AmetConsecteturAdipiscingElit
{
// body
}
```
-#### `"HorizontalVertical"`:
+#### `"Horizontal"`:
```rust
fn lorem<Ipsum, Dolor>(ipsum: Ipsum, dolor: Dolor)
}
fn lorem<Ipsum, Dolor, Sit, Amet>(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet)
- where Ipsum: IpsumDolorSitAmet,
- Dolor: DolorSitAmetConsectetur,
- Sit: SitAmetConsecteturAdipiscing,
- Amet: AmetConsecteturAdipiscingElit
+ where Ipsum: IpsumDolorSitAmet, Dolor: DolorSitAmetConsectetur, Sit: SitAmetConsecteturAdipiscing, Amet: AmetConsecteturAdipiscingElit
{
// body
}
```
-#### `"Mixed"`:
+#### `"HorizontalVertical"`:
```rust
fn lorem<Ipsum, Dolor>(ipsum: Ipsum, dolor: Dolor)
}
fn lorem<Ipsum, Dolor, Sit, Amet>(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet)
- where Ipsum: IpsumDolorSitAmet, Dolor: DolorSitAmetConsectetur,
- Sit: SitAmetConsecteturAdipiscing, Amet: AmetConsecteturAdipiscingElit
+ where Ipsum: IpsumDolorSitAmet,
+ Dolor: DolorSitAmetConsectetur,
+ Sit: SitAmetConsecteturAdipiscing,
+ Amet: AmetConsecteturAdipiscingElit
{
// body
}
```
-#### `"Vertical"`:
+#### `"Mixed"`:
```rust
fn lorem<Ipsum, Dolor>(ipsum: Ipsum, dolor: Dolor)
- where Ipsum: IpsumDolorSitAmet,
- Dolor: DolorSitAmetConsectetur
+ where Ipsum: IpsumDolorSitAmet, Dolor: DolorSitAmetConsectetur
{
// body
}
fn lorem<Ipsum, Dolor, Sit, Amet>(ipsum: Ipsum, dolor: Dolor, sit: Sit, amet: Amet)
- where Ipsum: IpsumDolorSitAmet,
- Dolor: DolorSitAmetConsectetur,
- Sit: SitAmetConsecteturAdipiscing,
- Amet: AmetConsecteturAdipiscingElit
+ where Ipsum: IpsumDolorSitAmet, Dolor: DolorSitAmetConsectetur,
+ Sit: SitAmetConsecteturAdipiscing, Amet: AmetConsecteturAdipiscingElit
{
// 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`
- **Default value**: `"Visual"`
- **Possible values**: `"Block"`, `"Visual"`
-#### `"Block"`:
+#### `"Visual"` (default):
```rust
fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
where Ipsum: Eq,
- Dolor: Eq,
- Sit: Eq,
- Amet: Eq
+ Dolor: Eq,
+ Sit: Eq,
+ Amet: Eq
{
// body
}
```
-#### `"Visual"`:
+#### `"Block"`:
```rust
fn lorem<Ipsum, Dolor, Sit, Amet>() -> T
where Ipsum: Eq,
- Dolor: Eq,
- Sit: Eq,
- Amet: Eq
+ Dolor: Eq,
+ Sit: Eq,
+ Amet: Eq
{
// body
}
```
+**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"` (default):
```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
}
- **Default value**: `false`
- **Possible values**: `true`, `false`
-#### `false`:
+#### `false` (default):
```rust
// 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.
## `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`
-#### `false`:
+#### `true` (default):
```rust
match lorem {
true => {
- let ipsum = dolor;
- println!("{}", ipsum);
- }
- false => {
- println!("{}", sit)
+ foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo(x)
}
+ false => println!("{}", sit),
}
```
-#### `true`:
+#### `false`:
```rust
match lorem {
- true => {
- let ipsum = dolor;
- println!("{}", ipsum);
- }
+ true =>
+ 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"`