Auto merge of #10175 - koka831:fix/10171, r=giraffate

bors · bors · commit 7e184516331e · 2023-05-18T01:21:27.000Z
Use original variable name in the suggestion Fix #10171 --- changelog: Sugg: [`manual_let_else`]: Now suggest the correct variable name [#10175](#10175)
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
@@ -38,7 +38,6 @@ declare_clippy_lint! {
     /// Could be written:
     ///
     /// ```rust
-    /// # #![feature(let_else)]
     /// # fn main () {
     /// # let w = Some(0);
     /// let Some(v) = w else { return };
@@ -69,29 +68,23 @@ impl_lint_pass!(ManualLetElse => [MANUAL_LET_ELSE]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
     fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &'tcx Stmt<'tcx>) {
-        let if_let_or_match = if_chain! {
-            if self.msrv.meets(msrvs::LET_ELSE);
-            if !in_external_macro(cx.sess(), stmt.span);
-            if let StmtKind::Local(local) = stmt.kind;
-            if let Some(init) = local.init;
-            if local.els.is_none();
-            if local.ty.is_none();
-            if init.span.ctxt() == stmt.span.ctxt();
-            if let Some(if_let_or_match) = IfLetOrMatch::parse(cx, init);
-            then {
-                if_let_or_match
-            } else {
-                return;
-            }
-        };
+        if !self.msrv.meets(msrvs::LET_ELSE) || in_external_macro(cx.sess(), stmt.span) {
+            return;
+        }
 
+        if let StmtKind::Local(local) = stmt.kind &&
+            let Some(init) = local.init &&
+            local.els.is_none() &&
+            local.ty.is_none() &&
+            init.span.ctxt() == stmt.span.ctxt() &&
+            let Some(if_let_or_match) = IfLetOrMatch::parse(cx, init) {
         match if_let_or_match {
             IfLetOrMatch::IfLet(if_let_expr, let_pat, if_then, if_else) => if_chain! {
                 if expr_is_simple_identity(let_pat, if_then);
                 if let Some(if_else) = if_else;
                 if expr_diverges(cx, if_else);
                 then {
-                    emit_manual_let_else(cx, stmt.span, if_let_expr, let_pat, if_else);
+                    emit_manual_let_else(cx, stmt.span, if_let_expr, local.pat, let_pat, if_else);
                 }
             },
             IfLetOrMatch::Match(match_expr, arms, source) => {
@@ -128,15 +121,23 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                     return;
                 }
 
-                emit_manual_let_else(cx, stmt.span, match_expr, pat_arm.pat, diverging_arm.body);
+                emit_manual_let_else(cx, stmt.span, match_expr, local.pat, pat_arm.pat, diverging_arm.body);
             },
         }
+        };
     }
 
     extract_msrv_attr!(LateContext);
 }
 
-fn emit_manual_let_else(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, pat: &Pat<'_>, else_body: &Expr<'_>) {
+fn emit_manual_let_else(
+    cx: &LateContext<'_>,
+    span: Span,
+    expr: &Expr<'_>,
+    local: &Pat<'_>,
+    pat: &Pat<'_>,
+    else_body: &Expr<'_>,
+) {
     span_lint_and_then(
         cx,
         MANUAL_LET_ELSE,
@@ -145,12 +146,11 @@ fn emit_manual_let_else(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, pat:
         |diag| {
             // This is far from perfect, for example there needs to be:
             // * mut additions for the bindings
-            // * renamings of the bindings
+            // * renamings of the bindings for `PatKind::Or`
             // * unused binding collision detection with existing ones
             // * putting patterns with at the top level | inside ()
             // for this to be machine applicable.
             let mut app = Applicability::HasPlaceholders;
-            let (sn_pat, _) = snippet_with_context(cx, pat.span, span.ctxt(), "", &mut app);
             let (sn_expr, _) = snippet_with_context(cx, expr.span, span.ctxt(), "", &mut app);
             let (sn_else, _) = snippet_with_context(cx, else_body.span, span.ctxt(), "", &mut app);
 
@@ -159,10 +159,21 @@ fn emit_manual_let_else(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, pat:
             } else {
                 format!("{{ {sn_else} }}")
             };
-            let sn_bl = if matches!(pat.kind, PatKind::Or(..)) {
-                format!("({sn_pat})")
-            } else {
-                sn_pat.into_owned()
+            let sn_bl = match pat.kind {
+                PatKind::Or(..) => {
+                    let (sn_pat, _) = snippet_with_context(cx, pat.span, span.ctxt(), "", &mut app);
+                    format!("({sn_pat})")
+                },
+                // Replace the variable name iff `TupleStruct` has one argument like `Variant(v)`.
+                PatKind::TupleStruct(ref w, args, ..) if args.len() == 1 => {
+                    let sn_wrapper = cx.sess().source_map().span_to_snippet(w.span()).unwrap_or_default();
+                    let (sn_inner, _) = snippet_with_context(cx, local.span, span.ctxt(), "", &mut app);
+                    format!("{sn_wrapper}({sn_inner})")
+                },
+                _ => {
+                    let (sn_pat, _) = snippet_with_context(cx, pat.span, span.ctxt(), "", &mut app);
+                    sn_pat.into_owned()
+                },
             };
             let sugg = format!("let {sn_bl} = {sn_expr} else {else_bl};");
             diag.span_suggestion(span, "consider writing", sugg, app);
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
@@ -8,6 +8,12 @@
 )]
 #![warn(clippy::manual_let_else)]
 
+enum Variant {
+    A(usize, usize),
+    B(usize),
+    C,
+}
+
 fn g() -> Option<()> {
     None
 }
@@ -135,6 +141,15 @@ fn fire() {
         };
     }
     create_binding_if_some!(w, g());
+
+    fn e() -> Variant {
+        Variant::A(0, 0)
+    }
+
+    // Should not be renamed
+    let v = if let Variant::A(a, 0) = e() { a } else { return };
+    // Should be renamed
+    let v = if let Variant::B(b) = e() { b } else { return };
 }
 
 fn not_fire() {
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
@@ -1,13 +1,13 @@
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:18:5
+  --> $DIR/manual_let_else.rs:24:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { return };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { return };`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
    |
    = note: `-D clippy::manual-let-else` implied by `-D warnings`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:19:5
+  --> $DIR/manual_let_else.rs:25:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -18,13 +18,13 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         return;
 LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:25:5
+  --> $DIR/manual_let_else.rs:31:5
    |
 LL | /     let v = if let Some(v) = g() {
 LL | |         // Blocks around the identity should have no impact
@@ -45,25 +45,25 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:38:9
+  --> $DIR/manual_let_else.rs:44:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { continue };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { continue };`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:39:9
+  --> $DIR/manual_let_else.rs:45:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { break };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { break };`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { break };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:43:5
+  --> $DIR/manual_let_else.rs:49:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { panic!() };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { panic!() };`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { panic!() };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:46:5
+  --> $DIR/manual_let_else.rs:52:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -74,13 +74,13 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         std::process::abort()
 LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:53:5
+  --> $DIR/manual_let_else.rs:59:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -91,13 +91,13 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         if true { return } else { panic!() }
 LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:60:5
+  --> $DIR/manual_let_else.rs:66:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -109,14 +109,14 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         if true {}
 LL +         panic!();
 LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:70:5
+  --> $DIR/manual_let_else.rs:76:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -129,7 +129,7 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         match () {
 LL +             _ if panic!() => {},
 LL +             _ => panic!(),
@@ -138,13 +138,13 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:80:5
+  --> $DIR/manual_let_else.rs:86:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { if panic!() {} };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { if panic!() {} };`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { if panic!() {} };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:83:5
+  --> $DIR/manual_let_else.rs:89:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -157,15 +157,15 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         match panic!() {
 LL +             _ => {},
 LL +         }
 LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:92:5
+  --> $DIR/manual_let_else.rs:98:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -178,15 +178,15 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else { if true {
+LL ~     let Some(v) = g() else { if true {
 LL +         return;
 LL +     } else {
 LL +         panic!("diverge");
 LL +     } };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:101:5
+  --> $DIR/manual_let_else.rs:107:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -199,7 +199,7 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         match (g(), g()) {
 LL +             (Some(_), None) => return,
 LL +             (None, Some(_)) => {
@@ -215,7 +215,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:118:5
+  --> $DIR/manual_let_else.rs:124:5
    |
 LL | /     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
 LL | |         v_some
@@ -226,13 +226,13 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g().map(|v| (v, 42)) else {
+LL ~     let Some((v, w)) = g().map(|v| (v, 42)) else {
 LL +         return;
 LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:125:5
+  --> $DIR/manual_let_else.rs:131:5
    |
 LL | /     let v = if let (Some(v_some), w_some) = (g(), 0) {
 LL | |         (w_some, v_some)
@@ -249,24 +249,36 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:134:13
+  --> $DIR/manual_let_else.rs:140:13
    |
 LL |             let $n = if let Some(v) = $e { v } else { return };
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some($n) = g() else { return };`
 ...
 LL |     create_binding_if_some!(w, g());
    |     ------------------------------- in this macro invocation
    |
    = note: this error originates in the macro `create_binding_if_some` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:247:5
+  --> $DIR/manual_let_else.rs:150:5
+   |
+LL |     let v = if let Variant::A(a, 0) = e() { a } else { return };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(a, 0) = e() else { return };`
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:152:5
+   |
+LL |     let v = if let Variant::B(b) = e() { b } else { return };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::B(v) = e() else { return };`
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:262:5
    |
 LL | /     let _ = match ff {
 LL | |         Some(value) => value,
 LL | |         _ => macro_call!(),
 LL | |     };
-   | |______^ help: consider writing: `let Some(value) = ff else { macro_call!() };`
+   | |______^ help: consider writing: `let Some(_) = ff else { macro_call!() };`
 
-error: aborting due to 18 previous errors
+error: aborting due to 20 previous errors
 
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`	`1`	error: this could be rewritten as `let...else`
`2`		`- --> $DIR/manual_let_else.rs:18:5`
	`2`	`+ --> $DIR/manual_let_else.rs:24:5`
`3`	`3`	`\|`
`4`	`4`	`LL \| let v = if let Some(v_some) = g() { v_some } else { return };`
`5`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { return };`
	`5`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::manual-let-else` implied by `-D warnings`
`8`	`8`
`9`	`9`	error: this could be rewritten as `let...else`
`10`		`- --> $DIR/manual_let_else.rs:19:5`
	`10`	`+ --> $DIR/manual_let_else.rs:25:5`
`11`	`11`	`\|`
`12`	`12`	`LL \| / let v = if let Some(v_some) = g() {`
`13`	`13`	`LL \| \| v_some`
`@@ -18,13 +18,13 @@ LL \| \| };`
`18`	`18`	`\|`
`19`	`19`	`help: consider writing`
`20`	`20`	`\|`
`21`		`-LL ~ let Some(v_some) = g() else {`
	`21`	`+LL ~ let Some(v) = g() else {`
`22`	`22`	`LL + return;`
`23`	`23`	`LL + };`
`24`	`24`	`\|`
`25`	`25`
`26`	`26`	error: this could be rewritten as `let...else`
`27`		`- --> $DIR/manual_let_else.rs:25:5`
	`27`	`+ --> $DIR/manual_let_else.rs:31:5`
`28`	`28`	`\|`
`29`	`29`	`LL \| / let v = if let Some(v) = g() {`
`30`	`30`	`LL \| \| // Blocks around the identity should have no impact`
`@@ -45,25 +45,25 @@ LL + };`
`45`	`45`	`\|`
`46`	`46`
`47`	`47`	error: this could be rewritten as `let...else`
`48`		`- --> $DIR/manual_let_else.rs:38:9`
	`48`	`+ --> $DIR/manual_let_else.rs:44:9`
`49`	`49`	`\|`
`50`	`50`	`LL \| let v = if let Some(v_some) = g() { v_some } else { continue };`
`51`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { continue };`
	`51`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { continue };`
`52`	`52`
`53`	`53`	error: this could be rewritten as `let...else`
`54`		`- --> $DIR/manual_let_else.rs:39:9`
	`54`	`+ --> $DIR/manual_let_else.rs:45:9`
`55`	`55`	`\|`
`56`	`56`	`LL \| let v = if let Some(v_some) = g() { v_some } else { break };`
`57`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { break };`
	`57`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { break };`
`58`	`58`
`59`	`59`	error: this could be rewritten as `let...else`
`60`		`- --> $DIR/manual_let_else.rs:43:5`
	`60`	`+ --> $DIR/manual_let_else.rs:49:5`
`61`	`61`	`\|`
`62`	`62`	`LL \| let v = if let Some(v_some) = g() { v_some } else { panic!() };`
`63`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { panic!() };`
	`63`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { panic!() };`
`64`	`64`
`65`	`65`	error: this could be rewritten as `let...else`
`66`		`- --> $DIR/manual_let_else.rs:46:5`
	`66`	`+ --> $DIR/manual_let_else.rs:52:5`
`67`	`67`	`\|`
`68`	`68`	`LL \| / let v = if let Some(v_some) = g() {`
`69`	`69`	`LL \| \| v_some`
`@@ -74,13 +74,13 @@ LL \| \| };`
`74`	`74`	`\|`
`75`	`75`	`help: consider writing`
`76`	`76`	`\|`
`77`		`-LL ~ let Some(v_some) = g() else {`
	`77`	`+LL ~ let Some(v) = g() else {`
`78`	`78`	`LL + std::process::abort()`
`79`	`79`	`LL + };`
`80`	`80`	`\|`
`81`	`81`
`82`	`82`	error: this could be rewritten as `let...else`
`83`		`- --> $DIR/manual_let_else.rs:53:5`
	`83`	`+ --> $DIR/manual_let_else.rs:59:5`
`84`	`84`	`\|`
`85`	`85`	`LL \| / let v = if let Some(v_some) = g() {`
`86`	`86`	`LL \| \| v_some`
`@@ -91,13 +91,13 @@ LL \| \| };`
`91`	`91`	`\|`
`92`	`92`	`help: consider writing`
`93`	`93`	`\|`
`94`		`-LL ~ let Some(v_some) = g() else {`
	`94`	`+LL ~ let Some(v) = g() else {`
`95`	`95`	`LL + if true { return } else { panic!() }`
`96`	`96`	`LL + };`
`97`	`97`	`\|`
`98`	`98`
`99`	`99`	error: this could be rewritten as `let...else`
`100`		`- --> $DIR/manual_let_else.rs:60:5`
	`100`	`+ --> $DIR/manual_let_else.rs:66:5`
`101`	`101`	`\|`
`102`	`102`	`LL \| / let v = if let Some(v_some) = g() {`
`103`	`103`	`LL \| \| v_some`
`@@ -109,14 +109,14 @@ LL \| \| };`
`109`	`109`	`\|`
`110`	`110`	`help: consider writing`
`111`	`111`	`\|`
`112`		`-LL ~ let Some(v_some) = g() else {`
	`112`	`+LL ~ let Some(v) = g() else {`
`113`	`113`	`LL + if true {}`
`114`	`114`	`LL + panic!();`
`115`	`115`	`LL + };`
`116`	`116`	`\|`
`117`	`117`
`118`	`118`	error: this could be rewritten as `let...else`
`119`		`- --> $DIR/manual_let_else.rs:70:5`
	`119`	`+ --> $DIR/manual_let_else.rs:76:5`
`120`	`120`	`\|`
`121`	`121`	`LL \| / let v = if let Some(v_some) = g() {`
`122`	`122`	`LL \| \| v_some`
`@@ -129,7 +129,7 @@ LL \| \| };`
`129`	`129`	`\|`
`130`	`130`	`help: consider writing`
`131`	`131`	`\|`
`132`		`-LL ~ let Some(v_some) = g() else {`
	`132`	`+LL ~ let Some(v) = g() else {`
`133`	`133`	`LL + match () {`
`134`	`134`	`LL + _ if panic!() => {},`
`135`	`135`	`LL + _ => panic!(),`
`@@ -138,13 +138,13 @@ LL + };`
`138`	`138`	`\|`
`139`	`139`
`140`	`140`	error: this could be rewritten as `let...else`
`141`		`- --> $DIR/manual_let_else.rs:80:5`
	`141`	`+ --> $DIR/manual_let_else.rs:86:5`
`142`	`142`	`\|`
`143`	`143`	`LL \| let v = if let Some(v_some) = g() { v_some } else { if panic!() {} };`
`144`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { if panic!() {} };`
	`144`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { if panic!() {} };`
`145`	`145`
`146`	`146`	error: this could be rewritten as `let...else`
`147`		`- --> $DIR/manual_let_else.rs:83:5`
	`147`	`+ --> $DIR/manual_let_else.rs:89:5`
`148`	`148`	`\|`
`149`	`149`	`LL \| / let v = if let Some(v_some) = g() {`
`150`	`150`	`LL \| \| v_some`
`@@ -157,15 +157,15 @@ LL \| \| };`
`157`	`157`	`\|`
`158`	`158`	`help: consider writing`
`159`	`159`	`\|`
`160`		`-LL ~ let Some(v_some) = g() else {`
	`160`	`+LL ~ let Some(v) = g() else {`
`161`	`161`	`LL + match panic!() {`
`162`	`162`	`LL + _ => {},`
`163`	`163`	`LL + }`
`164`	`164`	`LL + };`
`165`	`165`	`\|`
`166`	`166`
`167`	`167`	error: this could be rewritten as `let...else`
`168`		`- --> $DIR/manual_let_else.rs:92:5`
	`168`	`+ --> $DIR/manual_let_else.rs:98:5`
`169`	`169`	`\|`
`170`	`170`	`LL \| / let v = if let Some(v_some) = g() {`
`171`	`171`	`LL \| \| v_some`
`@@ -178,15 +178,15 @@ LL \| \| };`
`178`	`178`	`\|`
`179`	`179`	`help: consider writing`
`180`	`180`	`\|`
`181`		`-LL ~ let Some(v_some) = g() else { if true {`
	`181`	`+LL ~ let Some(v) = g() else { if true {`
`182`	`182`	`LL + return;`
`183`	`183`	`LL + } else {`
`184`	`184`	`LL + panic!("diverge");`
`185`	`185`	`LL + } };`
`186`	`186`	`\|`
`187`	`187`
`188`	`188`	error: this could be rewritten as `let...else`
`189`		`- --> $DIR/manual_let_else.rs:101:5`
	`189`	`+ --> $DIR/manual_let_else.rs:107:5`
`190`	`190`	`\|`
`191`	`191`	`LL \| / let v = if let Some(v_some) = g() {`
`192`	`192`	`LL \| \| v_some`
`@@ -199,7 +199,7 @@ LL \| \| };`
`199`	`199`	`\|`
`200`	`200`	`help: consider writing`
`201`	`201`	`\|`
`202`		`-LL ~ let Some(v_some) = g() else {`
	`202`	`+LL ~ let Some(v) = g() else {`
`203`	`203`	`LL + match (g(), g()) {`
`204`	`204`	`LL + (Some(_), None) => return,`
`205`	`205`	`LL + (None, Some(_)) => {`
`@@ -215,7 +215,7 @@ LL + };`
`215`	`215`	`\|`
`216`	`216`
`217`	`217`	error: this could be rewritten as `let...else`
`218`		`- --> $DIR/manual_let_else.rs:118:5`
	`218`	`+ --> $DIR/manual_let_else.rs:124:5`
`219`	`219`	`\|`
`220`	`220`	`LL \| / let (v, w) = if let Some(v_some) = g().map(\|v\| (v, 42)) {`
`221`	`221`	`LL \| \| v_some`
`@@ -226,13 +226,13 @@ LL \| \| };`
`226`	`226`	`\|`
`227`	`227`	`help: consider writing`
`228`	`228`	`\|`
`229`		`-LL ~ let Some(v_some) = g().map(\|v\| (v, 42)) else {`
	`229`	`+LL ~ let Some((v, w)) = g().map(\|v\| (v, 42)) else {`
`230`	`230`	`LL + return;`
`231`	`231`	`LL + };`
`232`	`232`	`\|`
`233`	`233`
`234`	`234`	error: this could be rewritten as `let...else`
`235`		`- --> $DIR/manual_let_else.rs:125:5`
	`235`	`+ --> $DIR/manual_let_else.rs:131:5`
`236`	`236`	`\|`
`237`	`237`	`LL \| / let v = if let (Some(v_some), w_some) = (g(), 0) {`
`238`	`238`	`LL \| \| (w_some, v_some)`
`@@ -249,24 +249,36 @@ LL + };`
`249`	`249`	`\|`
`250`	`250`
`251`	`251`	error: this could be rewritten as `let...else`
`252`		`- --> $DIR/manual_let_else.rs:134:13`
	`252`	`+ --> $DIR/manual_let_else.rs:140:13`
`253`	`253`	`\|`
`254`	`254`	`LL \| let $n = if let Some(v) = $e { v } else { return };`
`255`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
	`255`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some($n) = g() else { return };`
`256`	`256`	`...`
`257`	`257`	`LL \| create_binding_if_some!(w, g());`
`258`	`258`	`\| ------------------------------- in this macro invocation`
`259`	`259`	`\|`
`260`	`260`	= note: this error originates in the macro `create_binding_if_some` (in Nightly builds, run with -Z macro-backtrace for more info)
`261`	`261`
`262`	`262`	error: this could be rewritten as `let...else`
`263`		`- --> $DIR/manual_let_else.rs:247:5`
	`263`	`+ --> $DIR/manual_let_else.rs:150:5`
	`264`	`+ \|`
	`265`	`+LL \| let v = if let Variant::A(a, 0) = e() { a } else { return };`
	`266`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(a, 0) = e() else { return };`
	`267`	`+`
	`268`	+error: this could be rewritten as `let...else`
	`269`	`+ --> $DIR/manual_let_else.rs:152:5`
	`270`	`+ \|`
	`271`	`+LL \| let v = if let Variant::B(b) = e() { b } else { return };`
	`272`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::B(v) = e() else { return };`
	`273`	`+`
	`274`	+error: this could be rewritten as `let...else`
	`275`	`+ --> $DIR/manual_let_else.rs:262:5`
`264`	`276`	`\|`
`265`	`277`	`LL \| / let _ = match ff {`
`266`	`278`	`LL \| \| Some(value) => value,`
`267`	`279`	`LL \| \| _ => macro_call!(),`
`268`	`280`	`LL \| \| };`
`269`		- \| \|______^ help: consider writing: `let Some(value) = ff else { macro_call!() };`
	`281`	+ \| \|______^ help: consider writing: `let Some(_) = ff else { macro_call!() };`
`270`	`282`
`271`		`-error: aborting due to 18 previous errors`
	`283`	`+error: aborting due to 20 previous errors`
`272`	`284`