Auto merge of #6071 - ebroto:rustup, r=ebroto

Rustup

r? `@ghost`

changelog: none

clippy_lints/src/matches.rs

@@ -1440,15 +1440,12 @@ where
 
 mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
-    use crate::utils::{in_constant, match_qpath, match_trait_method, paths, snippet, span_lint_and_then};
+    use crate::utils::{match_qpath, match_trait_method, paths, snippet, span_lint_and_then};
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
     use rustc_errors::Applicability;
-    use rustc_hir::{Arm, Expr, ExprKind, HirId, MatchSource, PatKind, QPath};
+    use rustc_hir::{Arm, Expr, ExprKind, MatchSource, PatKind, QPath};
     use rustc_lint::LateContext;
-    use rustc_middle::ty;
-    use rustc_mir::const_eval::is_const_fn;
-    use rustc_span::source_map::Symbol;
 
     pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Match(op, arms, ref match_source) = &expr.kind {
@@ -1468,37 +1465,24 @@ mod redundant_pattern_match {
         arms: &[Arm<'_>],
         keyword: &'static str,
     ) {
-        fn find_suggestion(cx: &LateContext<'_>, hir_id: HirId, path: &QPath<'_>) -> Option<&'static str> {
-            if match_qpath(path, &paths::RESULT_OK) && can_suggest(cx, hir_id, sym!(result_type), "is_ok") {
-                return Some("is_ok()");
-            }
-            if match_qpath(path, &paths::RESULT_ERR) && can_suggest(cx, hir_id, sym!(result_type), "is_err") {
-                return Some("is_err()");
-            }
-            if match_qpath(path, &paths::OPTION_SOME) && can_suggest(cx, hir_id, sym!(option_type), "is_some") {
-                return Some("is_some()");
-            }
-            if match_qpath(path, &paths::OPTION_NONE) && can_suggest(cx, hir_id, sym!(option_type), "is_none") {
-                return Some("is_none()");
-            }
-            None
-        }
-
-        let hir_id = expr.hir_id;
         let good_method = match arms[0].pat.kind {
             PatKind::TupleStruct(ref path, ref patterns, _) if patterns.len() == 1 => {
                 if let PatKind::Wild = patterns[0].kind {
-                    find_suggestion(cx, hir_id, path)
+                    if match_qpath(path, &paths::RESULT_OK) {
+                        "is_ok()"
+                    } else if match_qpath(path, &paths::RESULT_ERR) {
+                        "is_err()"
+                    } else if match_qpath(path, &paths::OPTION_SOME) {
+                        "is_some()"
+                    } else {
+                        return;
+                    }
                 } else {
-                    None
+                    return;
                 }
             },
-            PatKind::Path(ref path) => find_suggestion(cx, hir_id, path),
+            PatKind::Path(ref path) if match_qpath(path, &paths::OPTION_NONE) => "is_none()",
-            _ => None,
+            _ => return,
-        };
-        let good_method = match good_method {
-            Some(method) => method,
-            None => return,
         };
 
         // check that `while_let_on_iterator` lint does not trigger
@@ -1547,7 +1531,6 @@ mod redundant_pattern_match {
         if arms.len() == 2 {
             let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
 
-            let hir_id = expr.hir_id;
             let found_good_method = match node_pair {
                 (
                     PatKind::TupleStruct(ref path_left, ref patterns_left, _),
@@ -1562,8 +1545,6 @@ mod redundant_pattern_match {
                             &paths::RESULT_ERR,
                             "is_ok()",
                             "is_err()",
-                            || can_suggest(cx, hir_id, sym!(result_type), "is_ok"),
-                            || can_suggest(cx, hir_id, sym!(result_type), "is_err"),
                         )
                     } else {
                         None
@@ -1582,8 +1563,6 @@ mod redundant_pattern_match {
                             &paths::OPTION_NONE,
                             "is_some()",
                             "is_none()",
-                            || can_suggest(cx, hir_id, sym!(option_type), "is_some"),
-                            || can_suggest(cx, hir_id, sym!(option_type), "is_none"),
                         )
                     } else {
                         None
@@ -1616,7 +1595,6 @@ mod redundant_pattern_match {
         }
     }
 
-    #[allow(clippy::too_many_arguments)]
     fn find_good_method_for_match<'a>(
         arms: &[Arm<'_>],
         path_left: &QPath<'_>,
@@ -1625,8 +1603,6 @@ mod redundant_pattern_match {
         expected_right: &[&str],
         should_be_left: &'a str,
         should_be_right: &'a str,
-        can_suggest_left: impl Fn() -> bool,
-        can_suggest_right: impl Fn() -> bool,
     ) -> Option<&'a str> {
         let body_node_pair = if match_qpath(path_left, expected_left) && match_qpath(path_right, expected_right) {
             (&(*arms[0].body).kind, &(*arms[1].body).kind)
@@ -1638,35 +1614,13 @@ mod redundant_pattern_match {
 
         match body_node_pair {
             (ExprKind::Lit(ref lit_left), ExprKind::Lit(ref lit_right)) => match (&lit_left.node, &lit_right.node) {
-                (LitKind::Bool(true), LitKind::Bool(false)) if can_suggest_left() => Some(should_be_left),
+                (LitKind::Bool(true), LitKind::Bool(false)) => Some(should_be_left),
-                (LitKind::Bool(false), LitKind::Bool(true)) if can_suggest_right() => Some(should_be_right),
+                (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
                 _ => None,
             },
             _ => None,
         }
     }
-
-    fn can_suggest(cx: &LateContext<'_>, hir_id: HirId, diag_item: Symbol, name: &str) -> bool {
-        if !in_constant(cx, hir_id) {
-            return true;
-        }
-
-        // Avoid suggesting calls to non-`const fn`s in const contexts, see #5697.
-        cx.tcx
-            .get_diagnostic_item(diag_item)
-            .and_then(|def_id| {
-                cx.tcx.inherent_impls(def_id).iter().find_map(|imp| {
-                    cx.tcx
-                        .associated_items(*imp)
-                        .in_definition_order()
-                        .find_map(|item| match item.kind {
-                            ty::AssocKind::Fn if item.ident.name.as_str() == name => Some(item.def_id),
-                            _ => None,
-                        })
-                })
-            })
-            .map_or(false, |def_id| is_const_fn(cx.tcx, def_id))
-    }
 }
 
 #[test]

tests/ui/redundant_pattern_matching.fixed

@@ -18,39 +18,14 @@ fn main() {
 
     if Err::<i32, i32>(42).is_err() {}
 
-    if None::<()>.is_none() {}
-
-    if Some(42).is_some() {}
-
-    if Some(42).is_some() {
-        foo();
-    } else {
-        bar();
-    }
-
-    while Some(42).is_some() {}
-
-    while Some(42).is_none() {}
-
-    while None::<()>.is_none() {}
-
     while Ok::<i32, i32>(10).is_ok() {}
 
     while Ok::<i32, i32>(10).is_err() {}
 
-    let mut v = vec![1, 2, 3];
-    while v.pop().is_some() {
-        foo();
-    }
-
     if Ok::<i32, i32>(42).is_ok() {}
 
     if Err::<i32, i32>(42).is_err() {}
 
-    if None::<i32>.is_none() {}
-
-    if Some(42).is_some() {}
-
     if let Ok(x) = Ok::<i32, i32>(42) {
         println!("{}", x);
     }
@@ -63,48 +38,24 @@ fn main() {
 
     Err::<i32, i32>(42).is_ok();
 
-    Some(42).is_some();
-
-    None::<()>.is_none();
-
-    let _ = None::<()>.is_none();
-
     let _ = if Ok::<usize, ()>(4).is_ok() { true } else { false };
 
-    let opt = Some(false);
-    let x = if opt.is_some() { true } else { false };
-    takes_bool(x);
-
     issue5504();
-    issue5697();
+    issue6067();
 
-    let _ = if gen_opt().is_some() {
+    let _ = if gen_res().is_ok() {
         1
-    } else if gen_opt().is_none() {
-        2
-    } else if gen_res().is_ok() {
-        3
     } else if gen_res().is_err() {
-        4
+        2
     } else {
-        5
+        3
     };
 }
 
-fn gen_opt() -> Option<()> {
-    None
-}
-
 fn gen_res() -> Result<(), ()> {
     Ok(())
 }
 
-fn takes_bool(_: bool) {}
-
-fn foo() {}
-
-fn bar() {}
-
 macro_rules! m {
     () => {
         Some(42u32)
@@ -128,41 +79,19 @@ fn issue5504() {
     while m!().is_some() {}
 }
 
-// None of these should be linted because none of the suggested methods
+// Methods that are unstable const should not be suggested within a const context, see issue #5697.
-// are `const fn` without toggling a feature.
+// However, in Rust 1.48.0 the methods `is_ok` and `is_err` of `Result` were stabilized as const,
-const fn issue5697() {
+// so the following should be linted.
-    if let Ok(_) = Ok::<i32, i32>(42) {}
+const fn issue6067() {
+    if Ok::<i32, i32>(42).is_ok() {}
 
-    if let Err(_) = Err::<i32, i32>(42) {}
+    if Err::<i32, i32>(42).is_err() {}
 
-    if let Some(_) = Some(42) {}
+    while Ok::<i32, i32>(10).is_ok() {}
 
-    if let None = None::<()> {}
+    while Ok::<i32, i32>(10).is_err() {}
 
-    while let Ok(_) = Ok::<i32, i32>(10) {}
+    Ok::<i32, i32>(42).is_ok();
 
-    while let Err(_) = Ok::<i32, i32>(10) {}
+    Err::<i32, i32>(42).is_err();
-
-    while let Some(_) = Some(42) {}
-
-    while let None = None::<()> {}
-
-    match Ok::<i32, i32>(42) {
-        Ok(_) => true,
-        Err(_) => false,
-    };
-
-    match Err::<i32, i32>(42) {
-        Ok(_) => false,
-        Err(_) => true,
-    };
-    match Some(42) {
-        Some(_) => true,
-        None => false,
-    };
-
-    match None::<()> {
-        Some(_) => false,
-        None => true,
-    };
 }

tests/ui/redundant_pattern_matching.rs

@@ -18,39 +18,14 @@ fn main() {
 
     if let Err(_) = Err::<i32, i32>(42) {}
 
-    if let None = None::<()> {}
-
-    if let Some(_) = Some(42) {}
-
-    if let Some(_) = Some(42) {
-        foo();
-    } else {
-        bar();
-    }
-
-    while let Some(_) = Some(42) {}
-
-    while let None = Some(42) {}
-
-    while let None = None::<()> {}
-
     while let Ok(_) = Ok::<i32, i32>(10) {}
 
     while let Err(_) = Ok::<i32, i32>(10) {}
 
-    let mut v = vec![1, 2, 3];
-    while let Some(_) = v.pop() {
-        foo();
-    }
-
     if Ok::<i32, i32>(42).is_ok() {}
 
     if Err::<i32, i32>(42).is_err() {}
 
-    if None::<i32>.is_none() {}
-
-    if Some(42).is_some() {}
-
     if let Ok(x) = Ok::<i32, i32>(42) {
         println!("{}", x);
     }
@@ -75,57 +50,24 @@ fn main() {
         Err(_) => false,
     };
 
-    match Some(42) {
-        Some(_) => true,
-        None => false,
-    };
-
-    match None::<()> {
-        Some(_) => false,
-        None => true,
-    };
-
-    let _ = match None::<()> {
-        Some(_) => false,
-        None => true,
-    };
-
     let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
 
-    let opt = Some(false);
-    let x = if let Some(_) = opt { true } else { false };
-    takes_bool(x);
-
     issue5504();
-    issue5697();
+    issue6067();
 
-    let _ = if let Some(_) = gen_opt() {
+    let _ = if let Ok(_) = gen_res() {
         1
-    } else if let None = gen_opt() {
-        2
-    } else if let Ok(_) = gen_res() {
-        3
     } else if let Err(_) = gen_res() {
-        4
+        2
     } else {
-        5
+        3
     };
 }
 
-fn gen_opt() -> Option<()> {
-    None
-}
-
 fn gen_res() -> Result<(), ()> {
     Ok(())
 }
 
-fn takes_bool(_: bool) {}
-
-fn foo() {}
-
-fn bar() {}
-
 macro_rules! m {
     () => {
         Some(42u32)
@@ -149,25 +91,18 @@ fn issue5504() {
     while let Some(_) = m!() {}
 }
 
-// None of these should be linted because none of the suggested methods
+// Methods that are unstable const should not be suggested within a const context, see issue #5697.
-// are `const fn` without toggling a feature.
+// However, in Rust 1.48.0 the methods `is_ok` and `is_err` of `Result` were stabilized as const,
-const fn issue5697() {
+// so the following should be linted.
+const fn issue6067() {
     if let Ok(_) = Ok::<i32, i32>(42) {}
 
     if let Err(_) = Err::<i32, i32>(42) {}
 
-    if let Some(_) = Some(42) {}
-
-    if let None = None::<()> {}
-
     while let Ok(_) = Ok::<i32, i32>(10) {}
 
     while let Err(_) = Ok::<i32, i32>(10) {}
 
-    while let Some(_) = Some(42) {}
-
-    while let None = None::<()> {}
-
     match Ok::<i32, i32>(42) {
         Ok(_) => true,
         Err(_) => false,
@@ -177,13 +112,4 @@ const fn issue5697() {
         Ok(_) => false,
         Err(_) => true,
     };
-    match Some(42) {
-        Some(_) => true,
-        None => false,
-    };
-
-    match None::<()> {
-        Some(_) => false,
-        None => true,
-    };
 }

tests/ui/redundant_pattern_matching.stderr

@@ -18,62 +18,20 @@ error: redundant pattern matching, consider using `is_err()`
 LL |     if let Err(_) = Err::<i32, i32>(42) {}
    |     -------^^^^^^---------------------- help: try this: `if Err::<i32, i32>(42).is_err()`
 
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:21:12
-   |
-LL |     if let None = None::<()> {}
-   |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
-
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:23:12
-   |
-LL |     if let Some(_) = Some(42) {}
-   |     -------^^^^^^^----------- help: try this: `if Some(42).is_some()`
-
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:25:12
-   |
-LL |     if let Some(_) = Some(42) {
-   |     -------^^^^^^^----------- help: try this: `if Some(42).is_some()`
-
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:31:15
-   |
-LL |     while let Some(_) = Some(42) {}
-   |     ----------^^^^^^^----------- help: try this: `while Some(42).is_some()`
-
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:33:15
-   |
-LL |     while let None = Some(42) {}
-   |     ----------^^^^----------- help: try this: `while Some(42).is_none()`
-
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:35:15
-   |
-LL |     while let None = None::<()> {}
-   |     ----------^^^^------------- help: try this: `while None::<()>.is_none()`
-
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:37:15
+  --> $DIR/redundant_pattern_matching.rs:21:15
    |
 LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:39:15
+  --> $DIR/redundant_pattern_matching.rs:23:15
    |
 LL |     while let Err(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_err()`
 
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:42:15
-   |
-LL |     while let Some(_) = v.pop() {
-   |     ----------^^^^^^^---------- help: try this: `while v.pop().is_some()`
-
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:58:5
+  --> $DIR/redundant_pattern_matching.rs:33:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -82,7 +40,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:63:5
+  --> $DIR/redundant_pattern_matching.rs:38:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -91,7 +49,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:68:5
+  --> $DIR/redundant_pattern_matching.rs:43:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -100,7 +58,7 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:73:5
+  --> $DIR/redundant_pattern_matching.rs:48:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -108,93 +66,89 @@ LL | |         Err(_) => false,
 LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
 
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:78:5
-   |
-LL | /     match Some(42) {
-LL | |         Some(_) => true,
-LL | |         None => false,
-LL | |     };
-   | |_____^ help: try this: `Some(42).is_some()`
-
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:83:5
-   |
-LL | /     match None::<()> {
-LL | |         Some(_) => false,
-LL | |         None => true,
-LL | |     };
-   | |_____^ help: try this: `None::<()>.is_none()`
-
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:88:13
-   |
-LL |       let _ = match None::<()> {
-   |  _____________^
-LL | |         Some(_) => false,
-LL | |         None => true,
-LL | |     };
-   | |_____^ help: try this: `None::<()>.is_none()`
-
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:93:20
+  --> $DIR/redundant_pattern_matching.rs:53:20
    |
 LL |     let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
    |             -------^^^^^--------------------- help: try this: `if Ok::<usize, ()>(4).is_ok()`
 
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:96:20
-   |
-LL |     let x = if let Some(_) = opt { true } else { false };
-   |             -------^^^^^^^------ help: try this: `if opt.is_some()`
-
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:102:20
-   |
-LL |     let _ = if let Some(_) = gen_opt() {
-   |             -------^^^^^^^------------ help: try this: `if gen_opt().is_some()`
-
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:104:19
-   |
-LL |     } else if let None = gen_opt() {
-   |            -------^^^^------------ help: try this: `if gen_opt().is_none()`
-
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:106:19
+  --> $DIR/redundant_pattern_matching.rs:58:20
    |
-LL |     } else if let Ok(_) = gen_res() {
+LL |     let _ = if let Ok(_) = gen_res() {
-   |            -------^^^^^------------ help: try this: `if gen_res().is_ok()`
+   |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:108:19
+  --> $DIR/redundant_pattern_matching.rs:60:19
    |
 LL |     } else if let Err(_) = gen_res() {
    |            -------^^^^^^------------ help: try this: `if gen_res().is_err()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:141:19
+  --> $DIR/redundant_pattern_matching.rs:83:19
    |
 LL |         while let Some(_) = r#try!(result_opt()) {}
    |         ----------^^^^^^^----------------------- help: try this: `while r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:142:16
+  --> $DIR/redundant_pattern_matching.rs:84:16
    |
 LL |         if let Some(_) = r#try!(result_opt()) {}
    |         -------^^^^^^^----------------------- help: try this: `if r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:148:12
+  --> $DIR/redundant_pattern_matching.rs:90:12
    |
 LL |     if let Some(_) = m!() {}
    |     -------^^^^^^^------- help: try this: `if m!().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:149:15
+  --> $DIR/redundant_pattern_matching.rs:91:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
 
-error: aborting due to 29 previous errors
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching.rs:98:12
+   |
+LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
+   |     -------^^^^^--------------------- help: try this: `if Ok::<i32, i32>(42).is_ok()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching.rs:100:12
+   |
+LL |     if let Err(_) = Err::<i32, i32>(42) {}
+   |     -------^^^^^^---------------------- help: try this: `if Err::<i32, i32>(42).is_err()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching.rs:102:15
+   |
+LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
+   |     ----------^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_ok()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching.rs:104:15
+   |
+LL |     while let Err(_) = Ok::<i32, i32>(10) {}
+   |     ----------^^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_err()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching.rs:106:5
+   |
+LL | /     match Ok::<i32, i32>(42) {
+LL | |         Ok(_) => true,
+LL | |         Err(_) => false,
+LL | |     };
+   | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching.rs:111:5
+   |
+LL | /     match Err::<i32, i32>(42) {
+LL | |         Ok(_) => false,
+LL | |         Err(_) => true,
+LL | |     };
+   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
+
+error: aborting due to 22 previous errors
 

tests/ui/redundant_pattern_matching_const_result.fixed

@@ -1,44 +0,0 @@
-// run-rustfix
-
-#![feature(const_result)]
-#![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::match_like_matches_macro, unused)]
-
-// Test that results are linted with the feature enabled.
-
-const fn issue_5697() {
-    if Ok::<i32, i32>(42).is_ok() {}
-
-    if Err::<i32, i32>(42).is_err() {}
-
-    while Ok::<i32, i32>(10).is_ok() {}
-
-    while Ok::<i32, i32>(10).is_err() {}
-
-    Ok::<i32, i32>(42).is_ok();
-
-    Err::<i32, i32>(42).is_err();
-
-    // These should not be linted until `const_option` is implemented.
-    // See https://github.com/rust-lang/rust/issues/67441
-
-    if let Some(_) = Some(42) {}
-
-    if let None = None::<()> {}
-
-    while let Some(_) = Some(42) {}
-
-    while let None = None::<()> {}
-
-    match Some(42) {
-        Some(_) => true,
-        None => false,
-    };
-
-    match None::<()> {
-        Some(_) => false,
-        None => true,
-    };
-}
-
-fn main() {}

tests/ui/redundant_pattern_matching_const_result.rs

@@ -1,50 +0,0 @@
-// run-rustfix
-
-#![feature(const_result)]
-#![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::match_like_matches_macro, unused)]
-
-// Test that results are linted with the feature enabled.
-
-const fn issue_5697() {
-    if let Ok(_) = Ok::<i32, i32>(42) {}
-
-    if let Err(_) = Err::<i32, i32>(42) {}
-
-    while let Ok(_) = Ok::<i32, i32>(10) {}
-
-    while let Err(_) = Ok::<i32, i32>(10) {}
-
-    match Ok::<i32, i32>(42) {
-        Ok(_) => true,
-        Err(_) => false,
-    };
-
-    match Err::<i32, i32>(42) {
-        Ok(_) => false,
-        Err(_) => true,
-    };
-
-    // These should not be linted until `const_option` is implemented.
-    // See https://github.com/rust-lang/rust/issues/67441
-
-    if let Some(_) = Some(42) {}
-
-    if let None = None::<()> {}
-
-    while let Some(_) = Some(42) {}
-
-    while let None = None::<()> {}
-
-    match Some(42) {
-        Some(_) => true,
-        None => false,
-    };
-
-    match None::<()> {
-        Some(_) => false,
-        None => true,
-    };
-}
-
-fn main() {}

tests/ui/redundant_pattern_matching_const_result.stderr

@@ -1,46 +0,0 @@
-error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_const_result.rs:10:12
-   |
-LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
-   |     -------^^^^^--------------------- help: try this: `if Ok::<i32, i32>(42).is_ok()`
-   |
-   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
-
-error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_const_result.rs:12:12
-   |
-LL |     if let Err(_) = Err::<i32, i32>(42) {}
-   |     -------^^^^^^---------------------- help: try this: `if Err::<i32, i32>(42).is_err()`
-
-error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_const_result.rs:14:15
-   |
-LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
-   |     ----------^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_ok()`
-
-error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_const_result.rs:16:15
-   |
-LL |     while let Err(_) = Ok::<i32, i32>(10) {}
-   |     ----------^^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_err()`
-
-error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_const_result.rs:18:5
-   |
-LL | /     match Ok::<i32, i32>(42) {
-LL | |         Ok(_) => true,
-LL | |         Err(_) => false,
-LL | |     };
-   | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
-
-error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_const_result.rs:23:5
-   |
-LL | /     match Err::<i32, i32>(42) {
-LL | |         Ok(_) => false,
-LL | |         Err(_) => true,
-LL | |     };
-   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
-
-error: aborting due to 6 previous errors
-

tests/ui/redundant_pattern_matching_option.fixed

@@ -0,0 +1,85 @@
+// run-rustfix
+
+#![warn(clippy::all)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(
+    clippy::unit_arg,
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    deprecated
+)]
+
+fn main() {
+    if None::<()>.is_none() {}
+
+    if Some(42).is_some() {}
+
+    if Some(42).is_some() {
+        foo();
+    } else {
+        bar();
+    }
+
+    while Some(42).is_some() {}
+
+    while Some(42).is_none() {}
+
+    while None::<()>.is_none() {}
+
+    let mut v = vec![1, 2, 3];
+    while v.pop().is_some() {
+        foo();
+    }
+
+    if None::<i32>.is_none() {}
+
+    if Some(42).is_some() {}
+
+    Some(42).is_some();
+
+    None::<()>.is_none();
+
+    let _ = None::<()>.is_none();
+
+    let opt = Some(false);
+    let x = if opt.is_some() { true } else { false };
+    takes_bool(x);
+
+    issue6067();
+
+    let _ = if gen_opt().is_some() {
+        1
+    } else if gen_opt().is_none() {
+        2
+    } else {
+        3
+    };
+}
+
+fn gen_opt() -> Option<()> {
+    None
+}
+
+fn takes_bool(_: bool) {}
+
+fn foo() {}
+
+fn bar() {}
+
+// Methods that are unstable const should not be suggested within a const context, see issue #5697.
+// However, in Rust 1.48.0 the methods `is_some` and `is_none` of `Option` were stabilized as const,
+// so the following should be linted.
+const fn issue6067() {
+    if Some(42).is_some() {}
+
+    if None::<()>.is_none() {}
+
+    while Some(42).is_some() {}
+
+    while None::<()>.is_none() {}
+
+    Some(42).is_some();
+
+    None::<()>.is_none();
+}

tests/ui/redundant_pattern_matching_option.rs

@@ -0,0 +1,100 @@
+// run-rustfix
+
+#![warn(clippy::all)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(
+    clippy::unit_arg,
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    deprecated
+)]
+
+fn main() {
+    if let None = None::<()> {}
+
+    if let Some(_) = Some(42) {}
+
+    if let Some(_) = Some(42) {
+        foo();
+    } else {
+        bar();
+    }
+
+    while let Some(_) = Some(42) {}
+
+    while let None = Some(42) {}
+
+    while let None = None::<()> {}
+
+    let mut v = vec![1, 2, 3];
+    while let Some(_) = v.pop() {
+        foo();
+    }
+
+    if None::<i32>.is_none() {}
+
+    if Some(42).is_some() {}
+
+    match Some(42) {
+        Some(_) => true,
+        None => false,
+    };
+
+    match None::<()> {
+        Some(_) => false,
+        None => true,
+    };
+
+    let _ = match None::<()> {
+        Some(_) => false,
+        None => true,
+    };
+
+    let opt = Some(false);
+    let x = if let Some(_) = opt { true } else { false };
+    takes_bool(x);
+
+    issue6067();
+
+    let _ = if let Some(_) = gen_opt() {
+        1
+    } else if let None = gen_opt() {
+        2
+    } else {
+        3
+    };
+}
+
+fn gen_opt() -> Option<()> {
+    None
+}
+
+fn takes_bool(_: bool) {}
+
+fn foo() {}
+
+fn bar() {}
+
+// Methods that are unstable const should not be suggested within a const context, see issue #5697.
+// However, in Rust 1.48.0 the methods `is_some` and `is_none` of `Option` were stabilized as const,
+// so the following should be linted.
+const fn issue6067() {
+    if let Some(_) = Some(42) {}
+
+    if let None = None::<()> {}
+
+    while let Some(_) = Some(42) {}
+
+    while let None = None::<()> {}
+
+    match Some(42) {
+        Some(_) => true,
+        None => false,
+    };
+
+    match None::<()> {
+        Some(_) => false,
+        None => true,
+    };
+}

tests/ui/redundant_pattern_matching_option.stderr

@@ -0,0 +1,134 @@
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:14:12
+   |
+LL |     if let None = None::<()> {}
+   |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:16:12
+   |
+LL |     if let Some(_) = Some(42) {}
+   |     -------^^^^^^^----------- help: try this: `if Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:18:12
+   |
+LL |     if let Some(_) = Some(42) {
+   |     -------^^^^^^^----------- help: try this: `if Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:24:15
+   |
+LL |     while let Some(_) = Some(42) {}
+   |     ----------^^^^^^^----------- help: try this: `while Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:26:15
+   |
+LL |     while let None = Some(42) {}
+   |     ----------^^^^----------- help: try this: `while Some(42).is_none()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:28:15
+   |
+LL |     while let None = None::<()> {}
+   |     ----------^^^^------------- help: try this: `while None::<()>.is_none()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:31:15
+   |
+LL |     while let Some(_) = v.pop() {
+   |     ----------^^^^^^^---------- help: try this: `while v.pop().is_some()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:39:5
+   |
+LL | /     match Some(42) {
+LL | |         Some(_) => true,
+LL | |         None => false,
+LL | |     };
+   | |_____^ help: try this: `Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:44:5
+   |
+LL | /     match None::<()> {
+LL | |         Some(_) => false,
+LL | |         None => true,
+LL | |     };
+   | |_____^ help: try this: `None::<()>.is_none()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:49:13
+   |
+LL |       let _ = match None::<()> {
+   |  _____________^
+LL | |         Some(_) => false,
+LL | |         None => true,
+LL | |     };
+   | |_____^ help: try this: `None::<()>.is_none()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:55:20
+   |
+LL |     let x = if let Some(_) = opt { true } else { false };
+   |             -------^^^^^^^------ help: try this: `if opt.is_some()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:60:20
+   |
+LL |     let _ = if let Some(_) = gen_opt() {
+   |             -------^^^^^^^------------ help: try this: `if gen_opt().is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:62:19
+   |
+LL |     } else if let None = gen_opt() {
+   |            -------^^^^------------ help: try this: `if gen_opt().is_none()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:83:12
+   |
+LL |     if let Some(_) = Some(42) {}
+   |     -------^^^^^^^----------- help: try this: `if Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:85:12
+   |
+LL |     if let None = None::<()> {}
+   |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:87:15
+   |
+LL |     while let Some(_) = Some(42) {}
+   |     ----------^^^^^^^----------- help: try this: `while Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:89:15
+   |
+LL |     while let None = None::<()> {}
+   |     ----------^^^^------------- help: try this: `while None::<()>.is_none()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:91:5
+   |
+LL | /     match Some(42) {
+LL | |         Some(_) => true,
+LL | |         None => false,
+LL | |     };
+   | |_____^ help: try this: `Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:96:5
+   |
+LL | /     match None::<()> {
+LL | |         Some(_) => false,
+LL | |         None => true,
+LL | |     };
+   | |_____^ help: try this: `None::<()>.is_none()`
+
+error: aborting due to 19 previous errors
+