Clippy lint · Performance · checked with Clippy 0.1.99

clippy::useless_borrows_in_formatting: redundant reference in `println!` argument

What it meansDetects format!-style macros (e.g. format!, println!, write!) where an argument is passed with an explicit & but the value is already a reference, resulting in a double reference (e.g. &&T). It is in the performance group and warns by default.

What you see

warning: redundant reference in `println!` argument
 --> main.rs:4:16
  |
4 | println!("{}", &s);
  |                ^^ help: remove the redundant `&`: `s`
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#useless_borrows_in_formatting
  = note: `#[warn(clippy::useless_borrows_in_formatting)]` on by default

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?

The extra & is redundant and can make the code less clear. Format macros take references to the arguments internally, so passing &x when x is already a reference produces a double reference. The compiler is currently unable to optimize double references, which results in about 6% degradation per call.

Code that could be written to run faster. Warns by default.

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

let s: &str = "hello";
println!("{}", &s);

Write this instead

let s: &str = "hello";
println!("{}", s);

Turn it off, or on

Allow it where it does not fit your code, as narrowly as you can:

On one item

#[allow(clippy::useless_borrows_in_formatting)]
fn my_function() { /* ... */ }

Whole crate (Cargo.toml)

[lints.clippy]
useless_borrows_in_formatting = "allow"

One run

cargo clippy -- -A clippy::useless-borrows-in-formatting

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.

Performancegroup

warndefault level

yesfixed by cargo clippy --fix

1.97.0added in Rust

Clippy's own documentation

What it does

Detects format!-style macros (e.g. format!, println!, write!) where an argument is passed with an explicit & but the value is already a reference, resulting in a double reference (e.g. &&T).

Why is this bad?

The extra & is redundant and can make the code less clear. Format macros take references to the arguments internally, so passing &x when x is already a reference produces a double reference. The compiler is currently unable to optimize double references, which results in about 6% degradation per call.

Example

let s: &str = "hello";
println!("{}", &s);

Use instead:

let s: &str = "hello";
println!("{}", s);

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?