update indirect_structural_match and pointer_structural_match lints to match RFC and to show up for dependencies

[RalfJung]

This is a large step towards implementing rust-lang/rfcs#3535.
We currently have five lints related to "the structural match situation":

• nontrivial_structural_match
• indirect_structural_match
• pointer_structural_match
• const_patterns_without_partial_eq
• illegal_floating_point_literal_pattern

This PR concerns the first 3 of them. (The 4th already is set up to show for dependencies, and the 5th is removed by #116284.) nontrivial_structural_match is being removed as per the RFC; the other two are enabled to show up in dependencies.

Fixes #73448 by removing the affected analysis.

[rustbot]

r? @petrochenkov

(rustbot has picked a reviewer for you, use r? to override)

[rustbot]

Some changes might have occurred in exhaustiveness checking

cc @Nadrieril

[RalfJung]

Accepting these patterns is the key change here -- we no longer plan to reject these in the future so we don't have to lint against them.

[traviscross]

@rustbot labels +T-lang +I-lang-nominated

This is part of implementing rust-lang/rfcs#3535, which we accepted. Let's nominate to verify we're OK to stabilize this piece.

@RalfJung: If there's anything beyond what is in the PR description you'd like the team to understand when considering this piece, it may be worth posting a stabilization report to that effect.

[RalfJung]

The nontrivial_structural_match is being removed, meaning we now accept code like this without a lint (where NoDerive is a type with a custom PartialEq):

    // The final value is fine, but statically analyzing the expression that computes
    // the value would likely (incorrectly) have us conclude that this may match on
    // values that do not have structural equality.
    const INDEX: Option<NoDerive> = [None, Some(NoDerive(10))][0];
    match None { Some(_) => panic!("whoops"), INDEX => dbg!(INDEX), };

    const fn build() -> Option<NoDerive> { None }
    const CALL: Option<NoDerive> = build();
    match None { Some(_) => panic!("whoops"), CALL => dbg!(CALL), };

    impl NoDerive { const fn none() -> Option<NoDerive> { None } }
    const METHOD_CALL: Option<NoDerive> = NoDerive::none();
    match None { Some(_) => panic!("whoops"), METHOD_CALL => dbg!(METHOD_CALL), };

The indirect_structural_match and pointer_structural_match lints detect constants that do not have structural equality according to the definition from the RFC, but are currently accepted:

• indirect_structural_match detects constants involving references: due to a bug, &NotStructural values (and more generally, having a type with custom equality behind a reference) were not detected properly. We have a future-compat lint against this for many years already. This makes the lint show up in dependencies as well, in preparation for making it a hard error.
• pointer_structural_match detects constants containing raw pointers and function pointers that are not just bare integers. According to the RFC, such values are not considered to have structural equality. The crater run in patterns: reject raw pointers that are not just integers #116930 found no case of the lint actually triggering. The lint is warn-by-default since Rust 1.75; this makes the lint show up in dependencies as well.

[traviscross]

@rustbot labels -I-lang-nominated -S-waiting-on-team

We discussed this in the triage meeting today with all members present and agreed that we want to do this. This is OK to proceed.

Thanks again to @RalfJung for pushing forward on this.

[petrochenkov]

@bors r+

[bors]

📌 Commit efbfb04 has been approved by petrochenkov

It is now in the queue for this repository.

[bors]

☔ The latest upstream changes (presumably #120671) made this pull request unmergeable. Please resolve the merge conflicts.

[RalfJung]

@bors r=petrochenkov

[bors]

📌 Commit e00df17 has been approved by petrochenkov

It is now in the queue for this repository.