Simplify the code by avoiding, instead of correcting, corner cases

Author: notriddle

Diff for: clippy_lints/src/question_mark.rs

@@ -142,45 +142,13 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         && let Some(ret) = find_let_else_ret_expression(els)
         && let Some(inner_pat) = pat_and_expr_can_be_question_mark(cx, pat, ret)
         && !span_contains_comment(cx.tcx.sess.source_map(), els.span)
+        // https://github.com/rust-lang/rust-clippy/issues/13417
+        && !matches!(inner_pat.kind, PatKind::Binding(BindingMode(ByRef::Yes(_), _mut), _hir_id, _ident, _subpat))
     {
         let mut applicability = Applicability::MaybeIncorrect;
         let init_expr_str = snippet_with_applicability(cx, init_expr.span, "..", &mut applicability);
-        let sugg = if let PatKind::Binding(
-            BindingMode(ByRef::Yes(ref_mutability), binding_mutability),
-            _hir_id,
-            ident,
-            subpattern,
-        ) = inner_pat.kind
-        {
-            let (method_str, subpattern_unpack_str) = match ref_mutability {
-                Mutability::Mut => (".as_mut()", "&mut "),
-                Mutability::Not => (".as_ref()", "&"),
-            };
-            let mutability_str = match binding_mutability {
-                Mutability::Mut => "mut ",
-                Mutability::Not => "",
-            };
-            let subpattern_str = match subpattern {
-                Some(Pat {
-                    kind: PatKind::Binding(BindingMode(ByRef::Yes(_), _), _, subident, None),
-                    ..
-                }) => {
-                    // avoid `&ref`
-                    // note that, because you can't have aliased, mutable references, we don't have to worry about
-                    // the outer and inner mutability being different
-                    format!(" @ {subident}")
-                },
-                Some(subpattern) => {
-                    let substr = snippet_with_applicability(cx, subpattern.span, "..", &mut applicability);
-                    format!(" @ {subpattern_unpack_str}{substr}")
-                },
-                None => String::new(),
-            };
-            format!("let {mutability_str}{ident}{subpattern_str} = {init_expr_str}{method_str}?;")
-        } else {
-            let receiver_str = snippet_with_applicability(cx, inner_pat.span, "..", &mut applicability);
-            format!("let {receiver_str} = {init_expr_str}?;")
-        };
+        let receiver_str = snippet_with_applicability(cx, inner_pat.span, "..", &mut applicability);
+        let sugg = format!("let {receiver_str} = {init_expr_str}?;",);
         span_lint_and_sugg(
             cx,
             QUESTION_MARK,

Diff for: tests/ui/question_mark.fixed

@@ -382,23 +382,33 @@ struct WrapperStructWithString(String);
 
 #[allow(clippy::disallowed_names)]
 fn issue_13417(foo: &mut StructWithOptionString) -> Option<String> {
-    let x = foo.opt_x.as_ref()?;
+    let Some(ref x) = foo.opt_x else {
+        return None;
+    };
     let opt_y = Some(x.clone());
     std::mem::replace(&mut foo.opt_x, opt_y)
 }
 
 #[allow(clippy::disallowed_names)]
 fn issue_13417_mut(foo: &mut StructWithOptionString) -> Option<String> {
-    let x = foo.opt_x.as_mut()?;
+    let Some(ref mut x) = foo.opt_x else {
+        return None;
+    };
     let opt_y = Some(x.clone());
     std::mem::replace(&mut foo.opt_x, opt_y)
 }
 
 #[allow(clippy::disallowed_names)]
 #[allow(unused)]
 fn issue_13417_weirder(foo: &mut StructWithOptionString, mut bar: Option<WrapperStructWithString>) -> Option<()> {
-    let x @ y = foo.opt_x.as_ref()?;
-    let x @ &WrapperStructWithString(_) = bar.as_ref()?;
-    let x @ &mut WrapperStructWithString(_) = bar.as_mut()?;
+    let Some(ref x @ ref y) = foo.opt_x else {
+        return None;
+    };
+    let Some(ref x @ WrapperStructWithString(_)) = bar else {
+        return None;
+    };
+    let Some(ref mut x @ WrapperStructWithString(_)) = bar else {
+        return None;
+    };
     Some(())
 }

Diff for: tests/ui/question_mark.stderr

@@ -195,45 +195,5 @@ LL | |         return None;
 LL | |     };
    | |______^ help: replace it with: `let v = bar.foo.owned.clone()?;`
 
-error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:442:5
-   |
-LL | /     let Some(ref x) = foo.opt_x else {
-LL | |         return None;
-LL | |     };
-   | |______^ help: replace it with: `let x = foo.opt_x.as_ref()?;`
-
-error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:451:5
-   |
-LL | /     let Some(ref mut x) = foo.opt_x else {
-LL | |         return None;
-LL | |     };
-   | |______^ help: replace it with: `let x = foo.opt_x.as_mut()?;`
-
-error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:461:5
-   |
-LL | /     let Some(ref x @ ref y) = foo.opt_x else {
-LL | |         return None;
-LL | |     };
-   | |______^ help: replace it with: `let x @ y = foo.opt_x.as_ref()?;`
-
-error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:464:5
-   |
-LL | /     let Some(ref x @ WrapperStructWithString(_)) = bar else {
-LL | |         return None;
-LL | |     };
-   | |______^ help: replace it with: `let x @ &WrapperStructWithString(_) = bar.as_ref()?;`
-
-error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:467:5
-   |
-LL | /     let Some(ref mut x @ WrapperStructWithString(_)) = bar else {
-LL | |         return None;
-LL | |     };
-   | |______^ help: replace it with: `let x @ &mut WrapperStructWithString(_) = bar.as_mut()?;`
-
-error: aborting due to 27 previous errors
+error: aborting due to 22 previous errors