static_mut_refs: Should the lint cover hidden references?

[ehuss]

There is some discussion on #114447 (comment) about whether or not static_mut_refs should be triggering on code that takes references without using the & sigil, such as method calls.

This should probably be resolved soon if this is to be part of the edition. If this needs to change after the edition, the implementation will likely require separate code paths for the lint versus edition behavior, which could become confusing, or risk unintentional breakage.

[traviscross]

@rustbot labels +I-lang-nominated

What we need to discuss is whether, e.g., these cases should trigger an error in Rust 2024:

// edition: 2024

static mut STATIC: &[u8; 3] = &[0, 1, 2];

fn main() { unsafe {
    let _ = STATIC.len();
    let _ = STATIC[0];
    let _ = format!("{:?}", STATIC);
}}

Playground link

What was implemented in #117556 does not trigger an error for these. However, @scottmcm expressed a view that these should be included also:

I think this should be linting about anything that's created enough of a reference to trigger the reference rules -- if it can trigger UB when someone else holds a &mut to the static, that's worth linting about here.

cc @obeis @scottmcm @RalfJung @est31

[scottmcm]

I think that, if anything, the invisible ones are more important to lint(/break).

At least if someone is doing &STATIC they have a chance at spotting it, but STATIC.frobble() taking a secret reference makes it way harder to manually check.

[scottmcm]

I think it should cover hidden references, as expressed above.

Triage was sparsely attended today, but maybe we can get team agreement async:
@rfcbot fcp merge

[rfcbot]

Team member @scottmcm has proposed to merge this. The next step is review by the rest of the tagged team members:

• @joshtriplett
• @nikomatsakis
• @pnkfelix
• @scottmcm
• @tmandry

No concerns currently listed.

Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!

cc @rust-lang/lang-advisors: FCP proposed for lang, please feel free to register concerns.
See this document for info about what commands tagged team members can give me.

[Dirbaio]

+1 to this. I was quite confused when I saw that MY_STATIC.some_mut_self_method() doesn't generate a warning, since it's the same in the end as &mut MY_STATIC. I've also seen people in embedded bypassing the lint by rearranging code to get the reference by calling a &mut self method, without being aware it's "equally bad" as their previous code.

[tmandry]

Agreed that this should cover hidden references. Not sure if we need an FCP to decide it, but

@rfcbot reviewed