`tuple_array_conversions` suggested code erases binding names and hides asymmetry

[oxalica]

Summary

In case of tuple elements are asymmetric, eg. (src, dst), simply tuple.into() erase all binding names and make it seem like all elements are interchangeable, also hiding the asymmetry.

let [src, dest]: [_; 2] = args.try_into().ok()?;
operations.push((src, dest)); // <- warning

Suggested code is not obvious what each element means. It seems like to be an iterator which is general over array length, but is actually not.

operations.push(<[_; 2]>::try_from(args).ok()?.into());

Lint Name

tuple_array_conversions

Reproducer

I tried this code:

use std::path::PathBuf;

pub fn parse_ops_from_args_warn(args: Vec<PathBuf>, operations: &mut Vec<(PathBuf, PathBuf)>) -> Option<()> {
    let [src, dest]: [_; 2] = args.try_into().ok()?;
    operations.push((src, dest)); // <- warning
    Some(())
}

pub fn parse_ops_from_args_suggested(args: Vec<PathBuf>, operations: &mut Vec<(PathBuf, PathBuf)>) -> Option<()> {
    operations.push(<[_; 2]>::try_from(args).ok()?.into());
    Some(())
}

I saw this happen:

warning: it looks like you're trying to convert an array to a tuple
 --> src/lib.rs:5:21
  |
5 |     operations.push((src, dest));
  |                     ^^^^^^^^^^^
  |
  = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#tuple_array_conversions
  = note: `#[warn(clippy::tuple_array_conversions)]` on by default

I expected to see this happen: no warnings.

Version

Clippy 0.1.72 (2023-07-02 839e9a6)

On Rust playground nightly.

Additional Labels

No response

[Centri3]

I don't see any reason you can't do something like:

let (src, dest) = <[_; 2]>::try_from(args).ok()?.into();
operations.push((src, dest));

(untested, could summon demons)

Or even name it src_and_dest and don't destructure at all (though that's awful for anything with more than 2 elements)

Or, you know, [src, dest] then .into() on that? Like

let [src, dest] = <[_; 2]>::try_from(args).ok()?.into();
operations.push([src, dest].into());

Don't particularly like that though.

[oxalica]

I don't see any reason you can't do something like:

let (src, dest) = <[_; 2]>::try_from(args).ok()?.into();
operations.push((src, dest));

Yes this works. But it's almost the same as the slice pattern. I could also say, I don't see any reason you must convert the slice into tuple to match, instead of using slice patterns directly. The type signature here is also necessary to make inferences work, as the original one.

operations.push([src, dest].into());

No. This is purely making things complicated to workaround the warning.

[Centri3]

No. This is purely making things complicated to workaround the warning.

Completely agree ^^

I don't know how this is meant to catch something like (src, dest) though.