Only using a parameter in a macro call followed by an assignment causes the only_used_in_recursion lint to trigger

Summary

The only_used_in_recursion lint seems to cause false positives when the parameter is used as the index into an array stored inside a struct, passing both into a macro, and the result of the macro is assigned to. Using just an array instead of a struct or tuple as the parameter, or not having an assignment in that position, makes the issue go away, and so does writing the same code without using an intermediate macro (which would be less ergonomic in the use case this issue came up in).

Lint Name

only_used_in_recursion

Reproducer

I tried this code:

macro_rules! do_index {
    ($arr: expr, $index: expr) => {
        $arr.1[$index as usize]
    };
}

fn do_thing(s: &mut (u8, [u32; 4]), index: u8, value: u32) {
    do_index!(s, index) = value;
}

I saw this happen:

warning: parameter is only used in recursion
 --> src/lib.rs:7:39
  |
7 | fn do_thing(arr: &mut (u8, [u32; 4]), index: u8, value: u32) {
  |                                       ^^^^^ help: if this is intentional, prefix with an underscore: `_index`
  |
  = note: `#[warn(clippy::only_used_in_recursion)]` on by default
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#only_used_in_recursion

I expected to see this happen: (no warning)

Version

rustc 1.61.0-nightly (461e80780 2022-03-16)
binary: rustc
commit-hash: 461e8078010433ff7de2db2aaae8a3cfb0847215
commit-date: 2022-03-16
host: x86_64-unknown-linux-gnu
release: 1.61.0-nightly
LLVM version: 14.0.0

Additional Labels

No response

[hellow554]

I have a "in the wild" example from the base64 crate:

pub(crate) const fn decode_table(alphabet: &Alphabet) -> [u8; 256] {
    let mut decode_table = [INVALID_VALUE; 256];

    // Since the table is full of `INVALID_VALUE` already, we only need to overwrite
    // the parts that are valid.
    let mut index = 0;
    while index < 64 {
        // The index in the alphabet is the 6-bit value we care about.
        // Since the index is in 0-63, it is safe to cast to u8.
        decode_table[alphabet.symbols[index] as usize] = index as u8;
        index += 1;
    }

    return decode_table;
}

but it's practially the same. alphabet is used as an index to an array which triggers the lint.

[danieleades]

I have a "in the wild" example from the base64 crate:

pub(crate) const fn decode_table(alphabet: &Alphabet) -> [u8; 256] {
    let mut decode_table = [INVALID_VALUE; 256];

    // Since the table is full of `INVALID_VALUE` already, we only need to overwrite
    // the parts that are valid.
    let mut index = 0;
    while index < 64 {
        // The index in the alphabet is the 6-bit value we care about.
        // Since the index is in 0-63, it is safe to cast to u8.
        decode_table[alphabet.symbols[index] as usize] = index as u8;
        index += 1;
    }

    return decode_table;
}

but it's practially the same. alphabet is used as an index to an array which triggers the lint.

this false positive is still occurring. Can this ticket be reopened? Or is there another ticket that's more appropriate?