Lint for large on-stack temporary values

[bczhc]

What it does

This lint warns unintentional large temporary values which may cause an overflowed stack.

Taking this function definition:

const LENGTH: usize = 1048576;

fn foo(buf: &[u8; LENGTH]) {
    let _a = buf;
}

On the signature, a thin ref &[u8; LENGTH] ensures the argument passed in should have exactly this size. Out of the function, array.try_into().unwrap() can be used as an assertion to the array size. However,

fn main() {
    let buf = vec![0_u8; LENGTH];
    // No! equivalent to: foo(&<[u8; LENGTH]>::try_from(buf).unwrap())
    foo(&buf.try_into().unwrap());
}

One may carelessly write a function call like above (I searched and found many occurrences like this on GitHub). Note, it will create a [u8; LENGTH] temporary value that is then referenced and passed to the function. This temporary value may cause an overflowed stack.

In this case above, due to different stack size limit on the two platforms, it runs smoothly on Linux but Stack overflow encounters on Windows. This may be tricky somehow.

Advantage

• Avoid unneeded stack temporary values and potential stack overflow errors.

Drawbacks

No response

Example

let buf: Vec<T> = ...
foo(&buf.try_into().unwrap());

Could be written as:

let buf: Vec<T> = ...
foo(<&[T; LENGTH]>::try_from(&buf[..]).unwrap());

Or,

let buf: Vec<T> = ...
foo((&buf[..]).try_into().unwrap());

Comparison with existing lints

We have large_stack_arrays lint but this is unable to detect such cases.

Additional Context

No response

[y21]

This sounds very similar to the large_stack_frames lint.

For your provided example (and adding #![warn(clippy::large_stack_frames)] at the top), that lint catches this:

warning: this function may allocate 2097224 bytes on the stack
  --> src/main.rs:9:4
   |
 9 | fn main() {
   |    ^^^^
...
12 |     foo(&buf.try_into().unwrap());
   |          -------------- this is the largest part, at 1048584 bytes for type `std::result::Result<[u8; 1048576], std::vec::Vec<u8>>`
   |
   = note: 2097224 bytes is larger than Clippy's configured `stack-size-threshold` of 512000
   = note: allocating large amounts of stack space can overflow the stack and cause the program to abort
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_frames

[bczhc]

Yes it catches. I used to add #![warn(clippy::all)] and there were no clippy warnings, so I thought no clippy lint can catch this. I later learned that clippy::all doesn't enable nursery group 😅. So despite this, may we go further: suggest a rewrite, for these cases (e.g. unneeded temporary values, but not large enough to cause a stack overflow). Thus seems this falls into the distinction between &a.some_call() and (&a).some_call().