mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

improve [match_same_arms] messages, enable rustfix test

Browse Source
This commit is contained in:
J-ZhengLi 2024-05-13 18:29:41 +08:00 committed by blyxyas
parent a4a1a7365d
commit dc5b99b3b6
8 changed files with 551 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
clippy_lints/src/matches/match_same_arms.rs
View File

@ -1,5 +1,5 @@
use clippy_utils::diagnostics::span_lint_hir_and_then;
use clippy_utils::source::snippet;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::{is_lint_allowed, path_to_local, search_same, SpanlessEq, SpanlessHash};
use core::cmp::Ordering;
use core::{iter, slice};
@ -9,9 +9,9 @@ use rustc_errors::Applicability;
use rustc_hir::def_id::DefId;
use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdMapEntry, HirIdSet, Pat, PatKind, RangeEnd};
use rustc_lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
use rustc_lint::LateContext;
use rustc_lint::{LateContext, LintContext};
use rustc_middle::ty;
use rustc_span::{ErrorGuaranteed, Symbol};
use rustc_span::{ErrorGuaranteed, Span, Symbol};
use super::MATCH_SAME_ARMS;
@ -110,20 +110,22 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
&& check_same_body()
};
let mut appl = Applicability::MaybeIncorrect;
let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
for (&(i, arm1), &(j, arm2)) in search_same(&indexed_arms, hash, eq) {
if matches!(arm2.pat.kind, PatKind::Wild) {
if !cx.tcx.features().non_exhaustive_omitted_patterns_lint
|| is_lint_allowed(cx, NON_EXHAUSTIVE_OMITTED_PATTERNS, arm2.hir_id)
{
let arm_span = adjusted_arm_span(cx, arm1.span);
span_lint_hir_and_then(
cx,
MATCH_SAME_ARMS,
arm1.hir_id,
arm1.span,
arm_span,
"this match arm has an identical body to the `_` wildcard arm",
|diag| {
diag.span_suggestion(arm1.span, "try removing the arm", "", Applicability::MaybeIncorrect)
diag.span_suggestion(arm_span, "try removing the arm", "", appl)
.help("or try changing either arm body")
.span_note(arm2.span, "`_` wildcard arm here");
},
@ -144,23 +146,36 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
keep_arm.span,
"this match arm has an identical body to another arm",
|diag| {
let move_pat_snip = snippet(cx, move_arm.pat.span, "<pat2>");
let keep_pat_snip = snippet(cx, keep_arm.pat.span, "<pat1>");
let move_pat_snip = snippet_with_applicability(cx, move_arm.pat.span, "<pat2>", &mut appl);
let keep_pat_snip = snippet_with_applicability(cx, keep_arm.pat.span, "<pat1>", &mut appl);
diag.span_suggestion(
keep_arm.pat.span,
"try merging the arm patterns",
"or try merging the arm patterns",
format!("{keep_pat_snip} | {move_pat_snip}"),
Applicability::MaybeIncorrect,
appl,
)
.help("or try changing either arm body")
.span_note(move_arm.span, "other arm here");
.span_suggestion(
adjusted_arm_span(cx, move_arm.span),
"and remove this obsolete arm",
"",
appl,
)
.help("try changing either arm body");
},
);
}
}
}
/// Extend arm's span to include the comma and whitespaces after it.
fn adjusted_arm_span(cx: &LateContext<'_>, span: Span) -> Span {
let source_map = cx.sess().source_map();
source_map
.span_extend_while(span, |c| c == ',' || c.is_ascii_whitespace())
.unwrap_or(span)
}
#[derive(Clone, Copy)]
enum NormalizedPat<'a> {
Wild,

132
tests/ui/match_same_arms.stderr
View File

@ -2,7 +2,7 @@ error: this match arm has an identical body to the `_` wildcard arm
--> tests/ui/match_same_arms.rs:12:9
|
LL | Abc::A => 0,
| ^^^^^^^^^^^ help: try removing the arm
| ^^^^^^^^^^^^^ help: try removing the arm
|
= help: or try changing either arm body
note: `_` wildcard arm here
@ -17,106 +17,114 @@ error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:18:9
|
LL | (1, .., 3) => 42,
| ----------^^^^^^
| |
| help: try merging the arm patterns: `(1, .., 3) | (.., 3)`
| ^^^^^^^^^^^^^^^^
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms.rs:19:9
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | (1, .., 3) | (.., 3) => 42,
| ~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - (.., 3) => 42,
|
LL | (.., 3) => 42,
| ^^^^^^^^^^^^^
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:25:9
|
LL | 51 => 1,
| --^^^^^
| |
| help: try merging the arm patterns: `51 | 42`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms.rs:24:9
|
LL | 42 => 1,
| ^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | 51 | 42 => 1,
| ~~~~~~~
help: and remove this obsolete arm
|
LL - 42 => 1,
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:26:9
|
LL | 41 => 2,
| --^^^^^
| |
| help: try merging the arm patterns: `41 | 52`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms.rs:27:9
|
LL | 52 => 2,
| ^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | 41 | 52 => 2,
| ~~~~~~~
help: and remove this obsolete arm
|
LL - 52 => 2,
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:33:9
|
LL | 2 => 2,
| -^^^^^
| |
| help: try merging the arm patterns: `2 | 1`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms.rs:32:9
|
LL | 1 => 2,
| ^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | 2 | 1 => 2,
| ~~~~~
help: and remove this obsolete arm
|
LL - 1 => 2,
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:35:9
|
LL | 3 => 2,
| -^^^^^
| |
| help: try merging the arm patterns: `3 | 1`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms.rs:32:9
|
LL | 1 => 2,
| ^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | 3 | 1 => 2,
| ~~~~~
help: and remove this obsolete arm
|
LL - 1 => 2,
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:33:9
|
LL | 2 => 2,
| -^^^^^
| |
| help: try merging the arm patterns: `2 | 3`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms.rs:35:9
|
LL | 3 => 2,
| ^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | 2 | 3 => 2,
| ~~~~~
help: and remove this obsolete arm
|
LL - 3 => 2,
LL +
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:52:17
|
LL | CommandInfo::External { name, .. } => name.to_string(),
| ----------------------------------^^^^^^^^^^^^^^^^^^^^
| |
| help: try merging the arm patterns: `CommandInfo::External { name, .. } | CommandInfo::BuiltIn { name, .. }`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms.rs:51:17
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | CommandInfo::External { name, .. } | CommandInfo::BuiltIn { name, .. } => name.to_string(),
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - CommandInfo::BuiltIn { name, .. } => name.to_string(),
|
LL | CommandInfo::BuiltIn { name, .. } => name.to_string(),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 8 previous errors

241
tests/ui/match_same_arms2.fixed Normal file
View File

@ -0,0 +1,241 @@
#![warn(clippy::match_same_arms)]
#![allow(
clippy::disallowed_names,
clippy::diverging_sub_expression,
clippy::uninlined_format_args,
clippy::match_single_binding,
clippy::match_like_matches_macro
)]
fn bar<T>(_: T) {}
fn foo() -> bool {
unimplemented!()
}
fn match_same_arms() {
let _ = match 42 {
_ => {
foo();
let mut a = 42 + [23].len() as i32;
if true {
a += 7;
}
a = -31 - a;
a
},
};
//~^^^^^^^^^^^^^^^^^^^ ERROR: this match arm has an identical body to the `_` wildcard arm
let _ = match 42 {
51 | 42 => foo(), //~ ERROR: this match arm has an identical body to another arm
_ => true,
};
let _ = match Some(42) {
None | Some(_) => 24, //~ ERROR: this match arm has an identical body to another arm
};
let _ = match Some(42) {
Some(foo) => 24,
None => 24,
};
let _ = match Some(42) {
Some(42) => 24,
Some(a) => 24, // bindings are different
None => 0,
};
let _ = match Some(42) {
Some(a) if a > 0 => 24,
Some(a) => 24, // one arm has a guard
None => 0,
};
match (Some(42), Some(42)) {
(None, Some(a)) | (Some(a), None) => bar(a), //~ ERROR: this match arm has an identical body to another arm
_ => (),
}
// No warning because guards are different
let _ = match Some(42) {
Some(a) if a == 42 => a,
Some(a) if a == 24 => a,
Some(_) => 24,
None => 0,
};
let _ = match (Some(42), Some(42)) {
(None, Some(a)) | (Some(a), None) if a == 42 => a, //~ ERROR: this match arm has an identical body to another arm
_ => 0,
};
match (Some(42), Some(42)) {
(Some(a), ..) | (.., Some(a)) => bar(a), //~ ERROR: this match arm has an identical body to another arm
_ => (),
}
let _ = match Some(()) {
Some(()) => 0.0,
None => -0.0,
};
match (Some(42), Some("")) {
(Some(a), None) => bar(a),
(None, Some(a)) => bar(a), // bindings have different types
_ => (),
}
let x: Result<i32, &str> = Ok(3);
// No warning because of the guard.
match x {
Ok(x) if x * x == 64 => println!("ok"),
Ok(_) => println!("ok"),
Err(_) => println!("err"),
}
// This used to be a false positive; see issue #1996.
match x {
Ok(3) => println!("ok"),
Ok(x) if x * x == 64 => println!("ok 64"),
Ok(_) => println!("ok"),
Err(_) => println!("err"),
}
match (x, Some(1i32)) {
(Ok(x), Some(_)) | (Ok(_), Some(x)) => println!("ok {}", x), //~ ERROR: this match arm has an identical body to another arm
_ => println!("err"),
}
// No warning; different types for `x`.
match (x, Some(1.0f64)) {
(Ok(x), Some(_)) => println!("ok {}", x),
(Ok(_), Some(x)) => println!("ok {}", x),
_ => println!("err"),
}
// False negative #2251.
match x {
Ok(_tmp) => println!("ok"),
Ok(_) | Ok(3) => println!("ok"), //~ ERROR: this match arm has an identical body to another arm
Err(_) => {
unreachable!();
},
}
// False positive #1390
macro_rules! empty {
($e:expr) => {};
}
match 0 {
0 => {
empty!(0);
},
1 => {
empty!(1);
},
x => {
empty!(x);
},
};
// still lint if the tokens are the same
match 0 {
1 | 0 => {
empty!(0);
},
x => {
empty!(x);
},
}
//~^^^^^^^ ERROR: this match arm has an identical body to another arm
match_expr_like_matches_macro_priority();
}
fn match_expr_like_matches_macro_priority() {
enum E {
A,
B,
C,
}
let x = E::A;
let _ans = match x {
E::A => false,
E::B => false,
_ => true,
};
}
fn main() {
let _ = match Some(0) {
Some(0) => 0,
Some(1) => 1,
#[cfg(feature = "foo")]
Some(2) => 2,
_ => 1,
};
enum Foo {
X(u32),
Y(u32),
Z(u32),
}
// Don't lint. `Foo::X(0)` and `Foo::Z(_)` overlap with the arm in between.
let _ = match Foo::X(0) {
Foo::X(0) => 1,
Foo::X(_) | Foo::Y(_) | Foo::Z(0) => 2,
Foo::Z(_) => 1,
_ => 0,
};
// Suggest moving `Foo::Z(_)` up.
let _ = match Foo::X(0) {
Foo::X(0) | Foo::Z(_) => 1, //~ ERROR: this match arm has an identical body to another arm
Foo::X(_) | Foo::Y(_) => 2,
_ => 0,
};
// Suggest moving `Foo::X(0)` down.
let _ = match Foo::X(0) {
Foo::Y(_) | Foo::Z(0) => 2,
Foo::Z(_) | Foo::X(0) => 1, //~ ERROR: this match arm has an identical body to another arm
_ => 0,
};
// Don't lint.
let _ = match 0 {
-2 => 1,
-5..=50 => 2,
-150..=88 => 1,
_ => 3,
};
struct Bar {
x: u32,
y: u32,
z: u32,
}
// Lint.
let _ = match None {
Some(Bar { y: 10, z: 0, .. }) => 2,
None => 50,
Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. }) => 1, //~ ERROR: this match arm has an identical body to another arm
_ => 200,
};
let _ = match 0 {
0 => todo!(),
1 => todo!(),
2 => core::convert::identity::<u32>(todo!()),
3 => core::convert::identity::<u32>(todo!()),
_ => 5,
};
let _ = match 0 {
1 | 0 => cfg!(not_enable),
_ => false,
};
}

5
tests/ui/match_same_arms2.rs
View File

@ -2,9 +2,10 @@
#![allow(
clippy::disallowed_names,
clippy::diverging_sub_expression,
clippy::uninlined_format_args
clippy::uninlined_format_args,
clippy::match_single_binding,
clippy::match_like_matches_macro
)]
//@no-rustfix
fn bar<T>(_: T) {}
fn foo() -> bool {
unimplemented!()

283
tests/ui/match_same_arms2.stderr
View File

@ -1,18 +1,18 @@
error: this match arm has an identical body to the `_` wildcard arm
--> tests/ui/match_same_arms2.rs:15:9
--> tests/ui/match_same_arms2.rs:16:9
|
LL | / 42 => {
LL | | foo();
LL | | let mut a = 42 + [23].len() as i32;
LL | | if true {
... |
LL | | a
LL | | },
| |_________^ help: try removing the arm
LL | | _ => {
| |________^ help: try removing the arm
|
= help: or try changing either arm body
note: `_` wildcard arm here
--> tests/ui/match_same_arms2.rs:24:9
--> tests/ui/match_same_arms2.rs:25:9
|
LL | / _ => {
LL | | foo();
@ -26,203 +26,200 @@ LL | | },
= help: to override `-D warnings` add `#[allow(clippy::match_same_arms)]`
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:38:9
--> tests/ui/match_same_arms2.rs:39:9
|
LL | 51 => foo(),
| --^^^^^^^^^
| |
| help: try merging the arm patterns: `51 | 42`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:37:9
|
LL | 42 => foo(),
| ^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | 51 | 42 => foo(),
| ~~~~~~~
help: and remove this obsolete arm
|
LL - 42 => foo(),
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:44:9
--> tests/ui/match_same_arms2.rs:45:9
|
LL | None => 24,
| ----^^^^^^
| |
| help: try merging the arm patterns: `None | Some(_)`
| ^^^^^^^^^^
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:43:9
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | None | Some(_) => 24,
| ~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - Some(_) => 24,
|
LL | Some(_) => 24,
| ^^^^^^^^^^^^^
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:66:9
--> tests/ui/match_same_arms2.rs:67:9
|
LL | (None, Some(a)) => bar(a),
| ---------------^^^^^^^^^^
| |
| help: try merging the arm patterns: `(None, Some(a)) | (Some(a), None)`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:65:9
|
LL | (Some(a), None) => bar(a),
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | (None, Some(a)) | (Some(a), None) => bar(a),
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - (Some(a), None) => bar(a),
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:80:9
--> tests/ui/match_same_arms2.rs:81:9
|
LL | (None, Some(a)) if a == 42 => a,
| ---------------^^^^^^^^^^^^^^^^
| |
| help: try merging the arm patterns: `(None, Some(a)) | (Some(a), None)`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:79:9
|
LL | (Some(a), None) if a == 42 => a,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | (None, Some(a)) | (Some(a), None) if a == 42 => a,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - (Some(a), None) if a == 42 => a,
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:85:9
|
LL | (Some(a), ..) => bar(a),
| -------------^^^^^^^^^^
| |
| help: try merging the arm patterns: `(Some(a), ..) | (.., Some(a))`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:86:9
|
LL | (.., Some(a)) => bar(a),
LL | (Some(a), ..) => bar(a),
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | (Some(a), ..) | (.., Some(a)) => bar(a),
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - (.., Some(a)) => bar(a),
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:119:9
|
LL | (Ok(x), Some(_)) => println!("ok {}", x),
| ----------------^^^^^^^^^^^^^^^^^^^^^^^^
| |
| help: try merging the arm patterns: `(Ok(x), Some(_)) | (Ok(_), Some(x))`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:120:9
|
LL | (Ok(_), Some(x)) => println!("ok {}", x),
LL | (Ok(x), Some(_)) => println!("ok {}", x),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | (Ok(x), Some(_)) | (Ok(_), Some(x)) => println!("ok {}", x),
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - (Ok(_), Some(x)) => println!("ok {}", x),
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:135:9
--> tests/ui/match_same_arms2.rs:136:9
|
LL | Ok(_) => println!("ok"),
| -----^^^^^^^^^^^^^^^^^^
| |
| help: try merging the arm patterns: `Ok(_) | Ok(3)`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:134:9
|
LL | Ok(3) => println!("ok"),
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | Ok(_) | Ok(3) => println!("ok"),
| ~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - Ok(3) => println!("ok"),
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:162:9
--> tests/ui/match_same_arms2.rs:163:9
|
LL | 1 => {
| ^ help: try merging the arm patterns: `1 | 0`
| _________|
| |
LL | / 1 => {
LL | | empty!(0);
LL | | },
| |_________^
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:159:9
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | / 0 => {
LL | | empty!(0);
LL | | },
| |_________^
error: match expression looks like `matches!` macro
--> tests/ui/match_same_arms2.rs:181:16
LL | 1 | 0 => {
| ~~~~~
help: and remove this obsolete arm
|
LL | let _ans = match x {
| ________________^
LL | | E::A => false,
LL | | E::B => false,
LL | | _ => true,
LL | | };
| |_____^ help: try: `!matches!(x, E::A | E::B)`
LL - 0 => {
LL - empty!(0);
LL - },
|
= note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::match_like_matches_macro)]`
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:213:9
|
LL | Foo::X(0) => 1,
| ---------^^^^^
| |
| help: try merging the arm patterns: `Foo::X(0) | Foo::Z(_)`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:215:9
|
LL | Foo::Z(_) => 1,
| ^^^^^^^^^^^^^^
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:223:9
|
LL | Foo::Z(_) => 1,
| ---------^^^^^
| |
| help: try merging the arm patterns: `Foo::Z(_) | Foo::X(0)`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:221:9
--> tests/ui/match_same_arms2.rs:214:9
|
LL | Foo::X(0) => 1,
| ^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | Foo::X(0) | Foo::Z(_) => 1,
| ~~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - Foo::Z(_) => 1,
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:246:9
--> tests/ui/match_same_arms2.rs:224:9
|
LL | Foo::Z(_) => 1,
| ^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | Foo::Z(_) | Foo::X(0) => 1,
| ~~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - Foo::X(0) => 1,
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:247:9
|
LL | Some(Bar { y: 0, x: 5, .. }) => 1,
| ----------------------------^^^^^
| |
| help: try merging the arm patterns: `Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. })`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:243:9
|
LL | Some(Bar { x: 0, y: 5, .. }) => 1,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. }) => 1,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
help: and remove this obsolete arm
|
LL - Some(Bar { x: 0, y: 5, .. }) => 1,
|
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms2.rs:260:9
--> tests/ui/match_same_arms2.rs:261:9
|
LL | 1 => cfg!(not_enable),
| -^^^^^^^^^^^^^^^^^^^^
| |
| help: try merging the arm patterns: `1 | 0`
|
= help: or try changing either arm body
note: other arm here
--> tests/ui/match_same_arms2.rs:259:9
|
LL | 0 => cfg!(not_enable),
| ^^^^^^^^^^^^^^^^^^^^^
|
= help: try changing either arm body
help: or try merging the arm patterns
|
LL | 1 | 0 => cfg!(not_enable),
| ~~~~~
help: and remove this obsolete arm
|
LL - 0 => cfg!(not_enable),
|
error: aborting due to 14 previous errors
error: aborting due to 13 previous errors

61
tests/ui/match_same_arms_non_exhaustive.fixed Normal file
View File

@ -0,0 +1,61 @@
#![feature(non_exhaustive_omitted_patterns_lint)]
#![warn(clippy::match_same_arms)]
#![no_main]
use std::sync::atomic::Ordering; // #[non_exhaustive] enum
fn repeat() -> ! {
panic!()
}
pub fn f(x: Ordering) {
#[deny(non_exhaustive_omitted_patterns)]
match x {
Ordering::Relaxed => println!("relaxed"),
Ordering::Release => println!("release"),
Ordering::Acquire => println!("acquire"),
Ordering::AcqRel | Ordering::SeqCst => repeat(),
_ => repeat(),
}
}
mod f {
#![deny(non_exhaustive_omitted_patterns)]
use super::*;
pub fn f(x: Ordering) {
match x {
Ordering::Relaxed => println!("relaxed"),
Ordering::Release => println!("release"),
Ordering::Acquire => println!("acquire"),
Ordering::AcqRel | Ordering::SeqCst => repeat(),
_ => repeat(),
}
}
}
// Below should still lint
pub fn g(x: Ordering) {
match x {
Ordering::Relaxed => println!("relaxed"),
Ordering::Release => println!("release"),
Ordering::Acquire => println!("acquire"),
//~^ ERROR: this match arm has an identical body to the `_` wildcard arm
_ => repeat(),
}
}
mod g {
use super::*;
pub fn g(x: Ordering) {
match x {
Ordering::Relaxed => println!("relaxed"),
Ordering::Release => println!("release"),
Ordering::Acquire => println!("acquire"),
//~^ ERROR: this match arm has an identical body to the `_` wildcard arm
_ => repeat(),
}
}
}

1
tests/ui/match_same_arms_non_exhaustive.rs
View File

@ -1,7 +1,6 @@
#![feature(non_exhaustive_omitted_patterns_lint)]
#![warn(clippy::match_same_arms)]
#![no_main]
//@no-rustfix
use std::sync::atomic::Ordering; // #[non_exhaustive] enum
fn repeat() -> ! {

18
tests/ui/match_same_arms_non_exhaustive.stderr
View File

@ -1,12 +1,13 @@
error: this match arm has an identical body to the `_` wildcard arm
--> tests/ui/match_same_arms_non_exhaustive.rs:45:9
--> tests/ui/match_same_arms_non_exhaustive.rs:44:9
|
LL | Ordering::AcqRel | Ordering::SeqCst => repeat(),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the arm
LL | / Ordering::AcqRel | Ordering::SeqCst => repeat(),
LL | |
| |________^ help: try removing the arm
|
= help: or try changing either arm body
note: `_` wildcard arm here
--> tests/ui/match_same_arms_non_exhaustive.rs:47:9
--> tests/ui/match_same_arms_non_exhaustive.rs:46:9
|
LL | _ => repeat(),
| ^^^^^^^^^^^^^
@ -14,14 +15,15 @@ LL | _ => repeat(),
= help: to override `-D warnings` add `#[allow(clippy::match_same_arms)]`
error: this match arm has an identical body to the `_` wildcard arm
--> tests/ui/match_same_arms_non_exhaustive.rs:59:13
--> tests/ui/match_same_arms_non_exhaustive.rs:58:13
|
LL | Ordering::AcqRel | Ordering::SeqCst => repeat(),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the arm
LL | / Ordering::AcqRel | Ordering::SeqCst => repeat(),
LL | |
| |____________^ help: try removing the arm
|
= help: or try changing either arm body
note: `_` wildcard arm here
--> tests/ui/match_same_arms_non_exhaustive.rs:61:13
--> tests/ui/match_same_arms_non_exhaustive.rs:60:13
|
LL | _ => repeat(),
| ^^^^^^^^^^^^^