`collapsible_match` suggestion change meaning

[TeXitoi]

Summary

Code in the form pattern => {if test {…}} is suggested to be simplified as pattern if test => {…} but the meaning is different: if the pattern match but not the test, no other pattern are checked in the original code, but other patterns are checked in the suggestion.

Lint Name

collapsible_match

Reproducer

Corrected code should have the same result as the original code, here is an example showing it is false:

fn check(a: Option<&str>, b: i32) -> i32 {
    let mut res = 0;
    match a {
        Some(_) => {
            if b == 0 {
                res = 1
            }
        }
        _ if b == 1 => res = 2,
        _ => {}
    }
    res
}

fn check_clippy_suggestion(a: Option<&str>, b: i32) -> i32 {
    let mut res = 0;
    match a {
        Some(_) if b == 0 => res = 1,
        _ if b == 1 => res = 2,
        _ => {}
    }
    res
}

fn main() {
    assert_eq!(check(Some(""), 1), check_clippy_suggestion(Some(""), 1));
}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=c5e9555641490ea06f6588cd501e1233

Version

rustc 1.95.0 (59807616e 2026-04-14)
binary: rustc
commit-hash: 59807616e1fa2540724bfbac14d7976d7e4a3860
commit-date: 2026-04-14
host: x86_64-unknown-linux-gnu
release: 1.95.0
LLVM version: 22.1.2

Additional Labels

No response

[TeXitoi]

@rustbot label +I-suggestion-causes-bug

[Souradip121]

@rustbot claim

The issue is in the collapsible_match lint's check_arm function. When the lint encounters a pattern => { if test { body } } arm, it suggests collapsing it into pattern if test => { body }. The problem is that adding a match guard changes the semantics: in the original, once pattern matches, no further arms are checked regardless of whether test passes; in the transformed version, a failed guard allows fall-through to subsequent arms.

The fix adds a check that the arm being collapsed is the last non-wildcard arm in the match. Specifically, the lint now computes whether all arms after the current one are "wild-like" (a bare _, a binding pattern, or None, all without guards). Only when that condition holds is the transformation safe, because there are no subsequent arms that could be unexpectedly reached when the guard fails.

As a side effect, three #[expect(clippy::collapsible_match)] suppressions in clippy_lints/src/methods/mod.rs were removed. Those annotations had been added precisely to silence this false positive on arms inside large match blocks where non-wildcard arms followed, and they are no longer needed.

The fix is on branch fix-collapsible-match-guard-semantics in my fork, with tests covering both the no-lint case from this issue and a positive case confirming the lint still fires correctly when only wildcard arms follow.