Clippy lint · Pedantic · checked with Clippy 0.1.99

clippy::inconsistent_struct_constructor: struct constructor field order is inconsistent with struct definition field order

What it meansChecks for struct constructors where the order of the field init in the constructor is inconsistent with the order in the struct definition. It is in the pedantic group and off by default.

What you see

warning: struct constructor field order is inconsistent with struct definition field order
  --> main.rs:12:32
   |
12 | assert_eq!(Foo { x, y }, Foo { y, x });
   |                                ^^^^ help: try: `x, y`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#inconsistent_struct_constructor
   = note: `-W clippy::inconsistent-struct-constructor` implied by `-W clippy::pedantic`

Real output of Clippy 0.1.99 (Rust 1.99) on the example below. Names and line numbers in yours will differ.

Does it matter?

Since the order of fields in a constructor doesn’t affect the resulted instance as the below example indicates, #[derive(Debug, PartialEq, Eq)] struct Foo { x: i32, y: i32, } let x = 1; let y = 2; // This assertion never fails: assert_eq!(Foo { x, y }, Foo { y, x }); inconsistent order can be confusing and decreases readability and consistency.

Stricter lints with some false positives. Off by default; opt in with clippy::pedantic.

How to fix it

Clippy can fix this one for you: run cargo clippy --fix (add --allow-dirty if you have uncommitted changes). Review the diff before you commit.

Flagged

#[derive(Debug, PartialEq, Eq)]
struct Foo {
    x: i32,
    y: i32,
}
let x = 1;
let y = 2;

// This assertion never fails:
assert_eq!(Foo { x, y }, Foo { y, x });

Write this instead

struct Foo {
    x: i32,
    y: i32,
}
let x = 1;
let y = 2;

Foo { y, x };

Turn it off, or on

It is off by default. To use it, set it to warn or deny:

Whole crate (Cargo.toml)

[lints.clippy]
inconsistent_struct_constructor = "warn"

In code

#![warn(clippy::inconsistent_struct_constructor)]

One run

cargo clippy -- -W clippy::inconsistent-struct-constructor

The [lints] table needs Rust 1.74 or newer. In a workspace, put it under [workspace.lints.clippy] and add [lints] workspace = true to each member.

Pedanticgroup

allowdefault level

yesfixed by cargo clippy --fix

1.52.0added in Rust

Clippy's own documentation

What it does

Checks for struct constructors where the order of the field init in the constructor is inconsistent with the order in the struct definition.

Why is this bad?

Since the order of fields in a constructor doesn’t affect the resulted instance as the below example indicates,

#[derive(Debug, PartialEq, Eq)]
struct Foo {
    x: i32,
    y: i32,
}
let x = 1;
let y = 2;

// This assertion never fails:
assert_eq!(Foo { x, y }, Foo { y, x });

inconsistent order can be confusing and decreases readability and consistency.

Example

struct Foo {
    x: i32,
    y: i32,
}
let x = 1;
let y = 2;

Foo { y, x };

Use instead:

Foo { x, y };

Configuration

check-inconsistent-struct-field-initializers: Whether to suggest reordering constructor fields when initializers are present.

Warnings produced by this configuration aren’t necessarily fixed by just reordering the fields. Even if the suggested code would compile, it can change semantics if the initializer expressions have side effects. The following example from rust-clippy#11846 shows how the suggestion can run into borrow check errors:

struct MyStruct {
    vector: Vec<u32>,
    length: usize
}
fn main() {
    let vector = vec![1,2,3];
    MyStruct { length: vector.len(), vector};
}

(default: false)

From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.

Up next

Also worth your time

Did this answer your question?