confusing clippy suggestion for `zero_repeat_side_effects`

[glorv]

Summary

zero_repeat_side_effects's suggestion is confusing

Reproducer

I tried this code:

fn foo<T>(_s: &[Option<T>]) {}

fn main() {
    foo(&[Some(0i64); 0]);
}

I expected to see this happen:

Instead, this happened:

warning: function or method calls as the initial value in zero-sized array initializers may cause side effects
 --> src/main.rs:4:10
  |
4 |     foo(&[Some(0i64); 0]);
  |          ^^^^^^^^^^^^^^^ help: consider using: `{ Some(0i64); [] as [std::option::Option<i64>; 0] }`
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#zero_repeat_side_effects
  = note: `#[warn(clippy::zero_repeat_side_effects)]` on by default

If only passed &[] then type T cannot be determined.

But I don't get what { Some(0i64); [] as [std::option::Option<i64>; 0] } refers to, maybe [] as [std::option::Option<i64>; 0]?

Version

rustc 1.88.0-nightly (934880f58 2025-04-09)
binary: rustc
commit-hash: 934880f586f6ac1f952c7090e2a943fcd7775e7b
commit-date: 2025-04-09
host: aarch64-apple-darwin
release: 1.88.0-nightly
LLVM version: 20.1.2

Additional Labels

No response

[y21]

But I don't get what { Some(0i64); [] as [std::option::Option<i64>; 0] } refers to, maybe [] as [std::option::Option<i64>; 0]?

The idea of the lint is that it's not immediately obvious to readers whether side effects such as function calls in [x(); 0] execute or not, so it is suggesting to move function calls out of the array literal, which makes it obvious that it does indeed happen ([effect(); 0] -> effect(); [] as [(); 0]). That's what happens in the suggestion, the Some() constructor call is moved out of the array literal, making it clear that it executes. It needs a block since it's in the middle of an arbitrary expression.

I do agree there's something to be improved here though. In this case, Some() is an automatically generated variant constructor function which should never have side effects, so we don't need to include that in the suggestion at all and we can indeed just suggest [] as [Option<i64>; 0] if the callee is an enum variant constructor.
Edit: thinking about it more, maybe we should just not lint at all in that case, because in that case if the expression is known to not have side effects, there shouldn't be an issue with the code.

Maybe the help message could also be a bit clearer and say "move the function call out of the array literal to make side effects explicit" or something like that. I can see how "consider using" alone can be confusing

[glorv]

The idea of the lint is that it's not immediately obvious to readers whether side effects such as function calls in [x(); 0] execute or not, so it is suggesting to move function calls out of the array literal, which makes it obvious that it does indeed happen ([effect(); 0] -> effect(); [] as [(); 0]). That's what happens in the suggestion, the Some() constructor call is moved out of the array literal, making it clear that it executes. It needs a block since it's in the middle of an arbitrary expression.

Got it. @y21 thank you very much for your explanation. I didn't realize Some() maybe have side effects in this context.