fix: unnested_or_patterns suggests wrongly in let

Author: profetia

clippy_lints/src/unnested_or_patterns.rs

@@ -64,34 +64,45 @@ impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
 impl EarlyLintPass for UnnestedOrPatterns {
     fn check_arm(&mut self, cx: &EarlyContext<'_>, a: &ast::Arm) {
         if self.msrv.meets(msrvs::OR_PATTERNS) {
-            lint_unnested_or_patterns(cx, &a.pat);
+            lint_unnested_or_patterns(cx, &a.pat, PatternSource::Arm);
         }
     }
 
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
         if self.msrv.meets(msrvs::OR_PATTERNS) {
             if let ast::ExprKind::Let(pat, _, _, _) = &e.kind {
-                lint_unnested_or_patterns(cx, pat);
+                lint_unnested_or_patterns(cx, pat, PatternSource::Expr);
             }
         }
     }
 
     fn check_param(&mut self, cx: &EarlyContext<'_>, p: &ast::Param) {
         if self.msrv.meets(msrvs::OR_PATTERNS) {
-            lint_unnested_or_patterns(cx, &p.pat);
+            lint_unnested_or_patterns(cx, &p.pat, PatternSource::Param);
         }
     }
 
     fn check_local(&mut self, cx: &EarlyContext<'_>, l: &ast::Local) {
         if self.msrv.meets(msrvs::OR_PATTERNS) {
-            lint_unnested_or_patterns(cx, &l.pat);
+            lint_unnested_or_patterns(cx, &l.pat, PatternSource::Local);
         }
     }
 
     extract_msrv_attr!();
 }
 
-fn lint_unnested_or_patterns(cx: &EarlyContext<'_>, pat: &Pat) {
+enum PatternSource {
+    /// The pattern is part of a match arm
+    Arm,
+    /// The pattern is part of a if/while let
+    Expr,
+    /// The pattern is part of a function parameter
+    Param,
+    /// The pattern is part of a let binding
+    Local,
+}
+
+fn lint_unnested_or_patterns(cx: &EarlyContext<'_>, pat: &Pat, source: PatternSource) {
     if let Ident(.., None) | Expr(_) | Wild | Path(..) | Range(..) | Rest | MacCall(_) = pat.kind {
         // This is a leaf pattern, so cloning is unprofitable.
         return;
@@ -109,12 +120,15 @@ fn lint_unnested_or_patterns(cx: &EarlyContext<'_>, pat: &Pat) {
 
     span_lint_and_then(cx, UNNESTED_OR_PATTERNS, pat.span, "unnested or-patterns", |db| {
         insert_necessary_parens(&mut pat);
-        db.span_suggestion_verbose(
-            pat.span,
-            "nest the patterns",
-            pprust::pat_to_string(&pat),
-            Applicability::MachineApplicable,
-        );
+
+        // Insert additional parens if it is an or-pattern and the source is a local or parameter. This is
+        // inserted after `pat_to_string` because doing it before will break the spans
+        let new_pat = if matches!(pat.kind, Or(_)) && matches!(source, PatternSource::Local | PatternSource::Param) {
+            format!("({})", pprust::pat_to_string(&pat))
+        } else {
+            pprust::pat_to_string(&pat)
+        };
+        db.span_suggestion_verbose(pat.span, "nest the patterns", new_pat, Applicability::MachineApplicable);
     });
 }
 

tests/ui/unnested_or_patterns.fixed

@@ -64,3 +64,16 @@ fn msrv_1_53() {
     if let [1 | 53] = [0] {}
     //~^ unnested_or_patterns
 }
+
+mod issue9952 {
+    fn or_in_local() {
+        let (0 | 1 | _) = 0;
+        //~^ unnested_or_patterns
+
+        if let 0 | 1 | _ = 0 {}
+        //~^ unnested_or_patterns
+    }
+
+    fn or_in_param((x | x | x): i32) {}
+    //~^ unnested_or_patterns
+}

tests/ui/unnested_or_patterns.rs

@@ -64,3 +64,16 @@ fn msrv_1_53() {
     if let [1] | [53] = [0] {}
     //~^ unnested_or_patterns
 }
+
+mod issue9952 {
+    fn or_in_local() {
+        let (0 | (1 | _)) = 0;
+        //~^ unnested_or_patterns
+
+        if let (0 | (1 | _)) = 0 {}
+        //~^ unnested_or_patterns
+    }
+
+    fn or_in_param((x | (x | x)): i32) {}
+    //~^ unnested_or_patterns
+}

tests/ui/unnested_or_patterns.stderr

@@ -204,5 +204,41 @@ LL -     if let [1] | [53] = [0] {}
 LL +     if let [1 | 53] = [0] {}
    |
 
-error: aborting due to 17 previous errors
+error: unnested or-patterns
+  --> tests/ui/unnested_or_patterns.rs:70:13
+   |
+LL |         let (0 | (1 | _)) = 0;
+   |             ^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL -         let (0 | (1 | _)) = 0;
+LL +         let (0 | 1 | _) = 0;
+   |
+
+error: unnested or-patterns
+  --> tests/ui/unnested_or_patterns.rs:73:16
+   |
+LL |         if let (0 | (1 | _)) = 0 {}
+   |                ^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL -         if let (0 | (1 | _)) = 0 {}
+LL +         if let 0 | 1 | _ = 0 {}
+   |
+
+error: unnested or-patterns
+  --> tests/ui/unnested_or_patterns.rs:77:20
+   |
+LL |     fn or_in_param((x | (x | x)): i32) {}
+   |                    ^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL -     fn or_in_param((x | (x | x)): i32) {}
+LL +     fn or_in_param((x | x | x): i32) {}
+   |
+
+error: aborting due to 20 previous errors